summaryrefslogtreecommitdiff
path: root/libs/assimp/code/AssetLib/3MF
diff options
context:
space:
mode:
Diffstat (limited to 'libs/assimp/code/AssetLib/3MF')
-rw-r--r--libs/assimp/code/AssetLib/3MF/3MFTypes.h165
-rw-r--r--libs/assimp/code/AssetLib/3MF/3MFXmlTags.h117
-rw-r--r--libs/assimp/code/AssetLib/3MF/D3MFExporter.cpp403
-rw-r--r--libs/assimp/code/AssetLib/3MF/D3MFExporter.h111
-rw-r--r--libs/assimp/code/AssetLib/3MF/D3MFImporter.cpp130
-rw-r--r--libs/assimp/code/AssetLib/3MF/D3MFImporter.h91
-rw-r--r--libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp256
-rw-r--r--libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.h84
-rw-r--r--libs/assimp/code/AssetLib/3MF/XmlSerializer.cpp593
-rw-r--r--libs/assimp/code/AssetLib/3MF/XmlSerializer.h96
10 files changed, 2046 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/3MF/3MFTypes.h b/libs/assimp/code/AssetLib/3MF/3MFTypes.h
new file mode 100644
index 0000000..987cdf6
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/3MFTypes.h
@@ -0,0 +1,165 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+#include <assimp/vector3.h>
+#include <assimp/matrix4x4.h>
+#include <assimp/ParsingUtils.h>
+#include <vector>
+#include <string>
+
+struct aiMaterial;
+struct aiMesh;
+
+namespace Assimp {
+namespace D3MF {
+
+enum class ResourceType {
+ RT_Object,
+ RT_BaseMaterials,
+ RT_EmbeddedTexture2D,
+ RT_Texture2DGroup,
+ RT_Unknown
+}; // To be extended with other resource types (eg. material extension resources like Texture2d, Texture2dGroup...)
+
+class Resource {
+public:
+ int mId;
+
+ Resource(int id) :
+ mId(id) {
+ // empty
+ }
+
+ virtual ~Resource() {
+ // empty
+ }
+
+ virtual ResourceType getType() const {
+ return ResourceType::RT_Unknown;
+ }
+};
+
+class EmbeddedTexture : public Resource {
+public:
+ std::string mPath;
+ std::string mContentType;
+ std::string mTilestyleU;
+ std::string mTilestyleV;
+ std::vector<char> mBuffer;
+
+ EmbeddedTexture(int id) :
+ Resource(id),
+ mPath(),
+ mContentType(),
+ mTilestyleU(),
+ mTilestyleV() {
+ // empty
+ }
+
+ ~EmbeddedTexture() = default;
+
+ ResourceType getType() const override {
+ return ResourceType::RT_EmbeddedTexture2D;
+ }
+};
+
+class Texture2DGroup : public Resource {
+public:
+ std::vector<aiVector2D> mTex2dCoords;
+ int mTexId;
+ Texture2DGroup(int id) :
+ Resource(id),
+ mTexId(-1) {
+ // empty
+ }
+
+ ~Texture2DGroup() = default;
+
+ ResourceType getType() const override {
+ return ResourceType::RT_Texture2DGroup;
+ }
+};
+
+class BaseMaterials : public Resource {
+public:
+ std::vector<unsigned int> mMaterialIndex;
+
+ BaseMaterials(int id) :
+ Resource(id),
+ mMaterialIndex() {
+ // empty
+ }
+
+ ~BaseMaterials() = default;
+
+ ResourceType getType() const override {
+ return ResourceType::RT_BaseMaterials;
+ }
+};
+
+struct Component {
+ int mObjectId;
+ aiMatrix4x4 mTransformation;
+};
+
+class Object : public Resource {
+public:
+ std::vector<aiMesh *> mMeshes;
+ std::vector<unsigned int> mMeshIndex;
+ std::vector<Component> mComponents;
+ std::string mName;
+
+ Object(int id) :
+ Resource(id),
+ mName(std::string("Object_") + ai_to_string(id)) {
+ // empty
+ }
+
+ ~Object() = default;
+
+ ResourceType getType() const override {
+ return ResourceType::RT_Object;
+ }
+};
+
+} // namespace D3MF
+} // namespace Assimp
diff --git a/libs/assimp/code/AssetLib/3MF/3MFXmlTags.h b/libs/assimp/code/AssetLib/3MF/3MFXmlTags.h
new file mode 100644
index 0000000..63f18b4
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/3MFXmlTags.h
@@ -0,0 +1,117 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+namespace Assimp {
+namespace D3MF {
+
+namespace XmlTag {
+ // Root tag
+ const char* const RootTag = "3MF";
+
+ // Meta-data
+ const char* const meta = "metadata";
+ const char* const meta_name = "name";
+
+ // Model-data specific tags
+ const char* const model = "model";
+ const char* const model_unit = "unit";
+ const char* const metadata = "metadata";
+ const char* const resources = "resources";
+ const char* const object = "object";
+ const char* const mesh = "mesh";
+ const char* const components = "components";
+ const char* const component = "component";
+ const char* const vertices = "vertices";
+ const char* const vertex = "vertex";
+ const char* const triangles = "triangles";
+ const char* const triangle = "triangle";
+ const char* const x = "x";
+ const char* const y = "y";
+ const char* const z = "z";
+ const char* const v1 = "v1";
+ const char* const v2 = "v2";
+ const char* const v3 = "v3";
+ const char* const id = "id";
+ const char* const pid = "pid";
+ const char* const pindex = "pindex";
+ const char* const p1 = "p1";
+ const char* const name = "name";
+ const char* const type = "type";
+ const char* const build = "build";
+ const char* const item = "item";
+ const char* const objectid = "objectid";
+ const char* const transform = "transform";
+ const char *const path = "path";
+
+ // Material definitions
+ const char* const basematerials = "basematerials";
+ const char* const basematerials_base = "base";
+ const char* const basematerials_name = "name";
+ const char* const basematerials_displaycolor = "displaycolor";
+ const char* const texture_2d = "m:texture2d";
+ const char *const texture_group = "m:texture2dgroup";
+ const char *const texture_content_type = "contenttype";
+ const char *const texture_tilestyleu = "tilestyleu";
+ const char *const texture_tilestylev = "tilestylev";
+ const char *const texture_2d_coord = "m:tex2coord";
+ const char *const texture_cuurd_u = "u";
+ const char *const texture_cuurd_v = "v";
+
+ // Meta info tags
+ const char* const CONTENT_TYPES_ARCHIVE = "[Content_Types].xml";
+ const char* const ROOT_RELATIONSHIPS_ARCHIVE = "_rels/.rels";
+ const char* const SCHEMA_CONTENTTYPES = "http://schemas.openxmlformats.org/package/2006/content-types";
+ const char* const SCHEMA_RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006/relationships";
+ const char* const RELS_RELATIONSHIP_CONTAINER = "Relationships";
+ const char* const RELS_RELATIONSHIP_NODE = "Relationship";
+ const char* const RELS_ATTRIB_TARGET = "Target";
+ const char* const RELS_ATTRIB_TYPE = "Type";
+ const char* const RELS_ATTRIB_ID = "Id";
+ const char* const PACKAGE_START_PART_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel";
+ const char* const PACKAGE_PRINT_TICKET_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/printticket";
+ const char* const PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
+ const char* const PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+ const char* const PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
+}
+
+} // Namespace D3MF
+} // Namespace Assimp
diff --git a/libs/assimp/code/AssetLib/3MF/D3MFExporter.cpp b/libs/assimp/code/AssetLib/3MF/D3MFExporter.cpp
new file mode 100644
index 0000000..42cd991
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/D3MFExporter.cpp
@@ -0,0 +1,403 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
+
+#include "D3MFExporter.h"
+
+#include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include "3MFXmlTags.h"
+#include "D3MFOpcPackage.h"
+
+#ifdef ASSIMP_USE_HUNTER
+#include <zip/zip.h>
+#else
+#include <contrib/zip/src/zip.h>
+#endif
+
+namespace Assimp {
+
+void ExportScene3MF(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+ if (nullptr == pIOSystem) {
+ throw DeadlyExportError("Could not export 3MP archive: " + std::string(pFile));
+ }
+ D3MF::D3MFExporter myExporter(pFile, pScene);
+ if (myExporter.validate()) {
+ if (pIOSystem->Exists(pFile)) {
+ if (!pIOSystem->DeleteFile(pFile)) {
+ throw DeadlyExportError("File exists, cannot override : " + std::string(pFile));
+ }
+ }
+ bool ok = myExporter.exportArchive(pFile);
+ if (!ok) {
+ throw DeadlyExportError("Could not export 3MP archive: " + std::string(pFile));
+ }
+ }
+}
+
+namespace D3MF {
+
+D3MFExporter::D3MFExporter(const char *pFile, const aiScene *pScene) :
+ mArchiveName(pFile), m_zipArchive(nullptr), mScene(pScene), mModelOutput(), mRelOutput(), mContentOutput(), mBuildItems(), mRelations() {
+ // empty
+}
+
+D3MFExporter::~D3MFExporter() {
+ for (size_t i = 0; i < mRelations.size(); ++i) {
+ delete mRelations[i];
+ }
+ mRelations.clear();
+}
+
+bool D3MFExporter::validate() {
+ if (mArchiveName.empty()) {
+ return false;
+ }
+
+ if (nullptr == mScene) {
+ return false;
+ }
+
+ return true;
+}
+
+bool D3MFExporter::exportArchive(const char *file) {
+ bool ok(true);
+
+ m_zipArchive = zip_open(file, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
+ if (nullptr == m_zipArchive) {
+ return false;
+ }
+
+ ok |= exportContentTypes();
+ ok |= export3DModel();
+ ok |= exportRelations();
+
+ zip_close(m_zipArchive);
+ m_zipArchive = nullptr;
+
+ return ok;
+}
+
+bool D3MFExporter::exportContentTypes() {
+ mContentOutput.clear();
+
+ mContentOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+ mContentOutput << std::endl;
+ mContentOutput << "<Types xmlns = \"http://schemas.openxmlformats.org/package/2006/content-types\">";
+ mContentOutput << std::endl;
+ mContentOutput << "<Default Extension = \"rels\" ContentType = \"application/vnd.openxmlformats-package.relationships+xml\" />";
+ mContentOutput << std::endl;
+ mContentOutput << "<Default Extension = \"model\" ContentType = \"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\" />";
+ mContentOutput << std::endl;
+ mContentOutput << "</Types>";
+ mContentOutput << std::endl;
+ zipContentType(XmlTag::CONTENT_TYPES_ARCHIVE);
+
+ return true;
+}
+
+bool D3MFExporter::exportRelations() {
+ mRelOutput.clear();
+
+ mRelOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+ mRelOutput << std::endl;
+ mRelOutput << "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">";
+
+ for (size_t i = 0; i < mRelations.size(); ++i) {
+ if (mRelations[i]->target[0] == '/') {
+ mRelOutput << "<Relationship Target=\"" << mRelations[i]->target << "\" ";
+ } else {
+ mRelOutput << "<Relationship Target=\"/" << mRelations[i]->target << "\" ";
+ }
+ mRelOutput << "Id=\"" << mRelations[i]->id << "\" ";
+ mRelOutput << "Type=\"" << mRelations[i]->type << "\" />";
+ mRelOutput << std::endl;
+ }
+ mRelOutput << "</Relationships>";
+ mRelOutput << std::endl;
+
+ zipRelInfo("_rels", ".rels");
+ mRelOutput.flush();
+
+ return true;
+}
+
+bool D3MFExporter::export3DModel() {
+ mModelOutput.clear();
+
+ writeHeader();
+ mModelOutput << "<" << XmlTag::model << " " << XmlTag::model_unit << "=\"millimeter\""
+ << " xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\">"
+ << std::endl;
+ mModelOutput << "<" << XmlTag::resources << ">";
+ mModelOutput << std::endl;
+
+ writeMetaData();
+
+ writeBaseMaterials();
+
+ writeObjects();
+
+ mModelOutput << "</" << XmlTag::resources << ">";
+ mModelOutput << std::endl;
+ writeBuild();
+
+ mModelOutput << "</" << XmlTag::model << ">\n";
+
+ OpcPackageRelationship *info = new OpcPackageRelationship;
+ info->id = "rel0";
+ info->target = "/3D/3DModel.model";
+ info->type = XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
+ mRelations.push_back(info);
+
+ zipModel("3D", "3DModel.model");
+ mModelOutput.flush();
+
+ return true;
+}
+
+void D3MFExporter::writeHeader() {
+ mModelOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+ mModelOutput << std::endl;
+}
+
+void D3MFExporter::writeMetaData() {
+ if (nullptr == mScene->mMetaData) {
+ return;
+ }
+
+ const unsigned int numMetaEntries(mScene->mMetaData->mNumProperties);
+ if (0 == numMetaEntries) {
+ return;
+ }
+
+ const aiString *key = nullptr;
+ const aiMetadataEntry *entry(nullptr);
+ for (size_t i = 0; i < numMetaEntries; ++i) {
+ mScene->mMetaData->Get(i, key, entry);
+ std::string k(key->C_Str());
+ aiString value;
+ mScene->mMetaData->Get(k, value);
+ mModelOutput << "<" << XmlTag::meta << " " << XmlTag::meta_name << "=\"" << key->C_Str() << "\">";
+ mModelOutput << value.C_Str();
+ mModelOutput << "</" << XmlTag::meta << ">" << std::endl;
+ }
+}
+
+void D3MFExporter::writeBaseMaterials() {
+ mModelOutput << "<basematerials id=\"1\">\n";
+ std::string strName, hexDiffuseColor, tmp;
+ for (size_t i = 0; i < mScene->mNumMaterials; ++i) {
+ aiMaterial *mat = mScene->mMaterials[i];
+ aiString name;
+ if (mat->Get(AI_MATKEY_NAME, name) != aiReturn_SUCCESS) {
+ strName = "basemat_" + ai_to_string(i);
+ } else {
+ strName = name.C_Str();
+ }
+ aiColor4D color;
+ if (mat->Get(AI_MATKEY_COLOR_DIFFUSE, color) == aiReturn_SUCCESS) {
+ hexDiffuseColor.clear();
+ tmp.clear();
+ // rgbs %
+ if (color.r <= 1 && color.g <= 1 && color.b <= 1 && color.a <= 1) {
+
+ hexDiffuseColor = ai_rgba2hex(
+ (int)((ai_real)color.r) * 255,
+ (int)((ai_real)color.g) * 255,
+ (int)((ai_real)color.b) * 255,
+ (int)((ai_real)color.a) * 255,
+ true);
+
+ } else {
+ hexDiffuseColor = "#";
+ tmp = ai_decimal_to_hexa((ai_real)color.r);
+ hexDiffuseColor += tmp;
+ tmp = ai_decimal_to_hexa((ai_real)color.g);
+ hexDiffuseColor += tmp;
+ tmp = ai_decimal_to_hexa((ai_real)color.b);
+ hexDiffuseColor += tmp;
+ tmp = ai_decimal_to_hexa((ai_real)color.a);
+ hexDiffuseColor += tmp;
+ }
+ } else {
+ hexDiffuseColor = "#FFFFFFFF";
+ }
+
+ mModelOutput << "<base name=\"" + strName + "\" " + " displaycolor=\"" + hexDiffuseColor + "\" />\n";
+ }
+ mModelOutput << "</basematerials>\n";
+}
+
+void D3MFExporter::writeObjects() {
+ if (nullptr == mScene->mRootNode) {
+ return;
+ }
+
+ aiNode *root = mScene->mRootNode;
+ for (unsigned int i = 0; i < root->mNumChildren; ++i) {
+ aiNode *currentNode(root->mChildren[i]);
+ if (nullptr == currentNode) {
+ continue;
+ }
+ mModelOutput << "<" << XmlTag::object << " id=\"" << i + 2 << "\" type=\"model\">";
+ mModelOutput << std::endl;
+ for (unsigned int j = 0; j < currentNode->mNumMeshes; ++j) {
+ aiMesh *currentMesh = mScene->mMeshes[currentNode->mMeshes[j]];
+ if (nullptr == currentMesh) {
+ continue;
+ }
+ writeMesh(currentMesh);
+ }
+ mBuildItems.push_back(i);
+
+ mModelOutput << "</" << XmlTag::object << ">";
+ mModelOutput << std::endl;
+ }
+}
+
+void D3MFExporter::writeMesh(aiMesh *mesh) {
+ if (nullptr == mesh) {
+ return;
+ }
+
+ mModelOutput << "<"
+ << XmlTag::mesh
+ << ">" << "\n";
+ mModelOutput << "<"
+ << XmlTag::vertices
+ << ">" << "\n";
+ for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+ writeVertex(mesh->mVertices[i]);
+ }
+ mModelOutput << "</"
+ << XmlTag::vertices << ">"
+ << "\n";
+
+ const unsigned int matIdx(mesh->mMaterialIndex);
+
+ writeFaces(mesh, matIdx);
+
+ mModelOutput << "</"
+ << XmlTag::mesh << ">"
+ << "\n";
+}
+
+void D3MFExporter::writeVertex(const aiVector3D &pos) {
+ mModelOutput << "<" << XmlTag::vertex << " x=\"" << pos.x << "\" y=\"" << pos.y << "\" z=\"" << pos.z << "\" />";
+ mModelOutput << std::endl;
+}
+
+void D3MFExporter::writeFaces(aiMesh *mesh, unsigned int matIdx) {
+ if (nullptr == mesh) {
+ return;
+ }
+
+ if (!mesh->HasFaces()) {
+ return;
+ }
+ mModelOutput << "<"
+ << XmlTag::triangles << ">"
+ << "\n";
+ for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+ aiFace &currentFace = mesh->mFaces[i];
+ mModelOutput << "<" << XmlTag::triangle << " v1=\"" << currentFace.mIndices[0] << "\" v2=\""
+ << currentFace.mIndices[1] << "\" v3=\"" << currentFace.mIndices[2]
+ << "\" pid=\"1\" p1=\"" + ai_to_string(matIdx) + "\" />";
+ mModelOutput << "\n";
+ }
+ mModelOutput << "</"
+ << XmlTag::triangles
+ << ">";
+ mModelOutput << "\n";
+}
+
+void D3MFExporter::writeBuild() {
+ mModelOutput << "<"
+ << XmlTag::build
+ << ">"
+ << "\n";
+
+ for (size_t i = 0; i < mBuildItems.size(); ++i) {
+ mModelOutput << "<" << XmlTag::item << " objectid=\"" << i + 2 << "\"/>";
+ mModelOutput << "\n";
+ }
+ mModelOutput << "</" << XmlTag::build << ">";
+ mModelOutput << "\n";
+}
+
+void D3MFExporter::zipContentType(const std::string &filename) {
+ addFileInZip(filename, mContentOutput.str());
+}
+
+void D3MFExporter::zipModel(const std::string &folder, const std::string &modelName) {
+ const std::string entry = folder + "/" + modelName;
+ addFileInZip(entry, mModelOutput.str());
+}
+
+void D3MFExporter::zipRelInfo(const std::string &folder, const std::string &relName) {
+ const std::string entry = folder + "/" + relName;
+ addFileInZip(entry, mRelOutput.str());
+}
+
+void D3MFExporter::addFileInZip(const std::string& entry, const std::string& content) {
+ if (nullptr == m_zipArchive) {
+ throw DeadlyExportError("3MF-Export: Zip archive not valid, nullptr.");
+ }
+
+ zip_entry_open(m_zipArchive, entry.c_str());
+ zip_entry_write(m_zipArchive, content.c_str(), content.size());
+ zip_entry_close(m_zipArchive);
+}
+
+} // Namespace D3MF
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_3MF_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/libs/assimp/code/AssetLib/3MF/D3MFExporter.h b/libs/assimp/code/AssetLib/3MF/D3MFExporter.h
new file mode 100644
index 0000000..680d54f
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/D3MFExporter.h
@@ -0,0 +1,111 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
+
+#include <memory>
+#include <sstream>
+#include <vector>
+#include <assimp/vector3.h>
+
+struct aiScene;
+struct aiNode;
+struct aiMaterial;
+struct aiMesh;
+
+struct zip_t;
+
+namespace Assimp {
+
+class IOStream;
+
+namespace D3MF {
+
+
+struct OpcPackageRelationship;
+
+class D3MFExporter {
+public:
+ D3MFExporter( const char* pFile, const aiScene* pScene );
+ ~D3MFExporter();
+ bool validate();
+ bool exportArchive( const char *file );
+ bool exportContentTypes();
+ bool exportRelations();
+ bool export3DModel();
+
+protected:
+ void writeHeader();
+ void writeMetaData();
+ void writeBaseMaterials();
+ void writeObjects();
+ void writeMesh( aiMesh *mesh );
+ void writeVertex( const aiVector3D &pos );
+ void writeFaces( aiMesh *mesh, unsigned int matIdx );
+ void writeBuild();
+
+ // Zip the data
+ void zipContentType( const std::string &filename );
+ void zipModel( const std::string &folder, const std::string &modelName );
+ void zipRelInfo( const std::string &folder, const std::string &relName );
+ void addFileInZip( const std::string &entry, const std::string &content );
+
+private:
+ std::string mArchiveName;
+ zip_t *m_zipArchive;
+ const aiScene *mScene;
+ std::ostringstream mModelOutput;
+ std::ostringstream mRelOutput;
+ std::ostringstream mContentOutput;
+ std::vector<unsigned int> mBuildItems;
+ std::vector<OpcPackageRelationship*> mRelations;
+};
+
+
+} // Namespace D3MF
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_3MF_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
+
+
diff --git a/libs/assimp/code/AssetLib/3MF/D3MFImporter.cpp b/libs/assimp/code/AssetLib/3MF/D3MFImporter.cpp
new file mode 100644
index 0000000..5b0f34c
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/D3MFImporter.cpp
@@ -0,0 +1,130 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#include "D3MFImporter.h"
+#include "3MFXmlTags.h"
+#include "D3MFOpcPackage.h"
+#include "XmlSerializer.h"
+
+#include <assimp/StringComparison.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XmlParser.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/fast_atof.h>
+
+#include <cassert>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+#include <iomanip>
+#include <cstring>
+
+namespace Assimp {
+
+using namespace D3MF;
+
+static const aiImporterDesc desc = {
+ "3mf Importer",
+ "",
+ "",
+ "http://3mf.io/",
+ aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour,
+ 0,
+ 0,
+ 0,
+ 0,
+ "3mf"
+};
+
+D3MFImporter::D3MFImporter() :
+ BaseImporter() {
+ // empty
+}
+
+D3MFImporter::~D3MFImporter() {
+ // empty
+}
+
+bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool /*checkSig*/) const {
+ if (!ZipArchiveIOSystem::isZipArchive(pIOHandler, filename)) {
+ return false;
+ }
+ D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
+ return opcPackage.validate();
+}
+
+void D3MFImporter::SetupProperties(const Importer*) {
+ // empty
+}
+
+const aiImporterDesc *D3MFImporter::GetInfo() const {
+ return &desc;
+}
+
+void D3MFImporter::InternReadFile(const std::string &filename, aiScene *pScene, IOSystem *pIOHandler) {
+ D3MFOpcPackage opcPackage(pIOHandler, filename);
+
+ XmlParser xmlParser;
+ if (xmlParser.parse(opcPackage.RootStream())) {
+ XmlSerializer xmlSerializer(&xmlParser);
+ xmlSerializer.ImportXml(pScene);
+
+ const std::vector<aiTexture*> &tex = opcPackage.GetEmbeddedTextures();
+ if (!tex.empty()) {
+ pScene->mNumTextures = static_cast<unsigned int>(tex.size());
+ pScene->mTextures = new aiTexture *[pScene->mNumTextures];
+ for (unsigned int i = 0; i < pScene->mNumTextures; ++i) {
+ pScene->mTextures[i] = tex[i];
+ }
+ }
+ }
+}
+
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_3MF_IMPORTER
diff --git a/libs/assimp/code/AssetLib/3MF/D3MFImporter.h b/libs/assimp/code/AssetLib/3MF/D3MFImporter.h
new file mode 100644
index 0000000..a39ae79
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/D3MFImporter.h
@@ -0,0 +1,91 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef AI_D3MFLOADER_H_INCLUDED
+#define AI_D3MFLOADER_H_INCLUDED
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#include <assimp/BaseImporter.h>
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/// @brief The 3MF-importer class.
+///
+/// Implements the basic topology import and embedded textures.
+// ---------------------------------------------------------------------------
+class D3MFImporter : public BaseImporter {
+public:
+ /// @brief The default class constructor.
+ D3MFImporter();
+
+ /// @brief The class destructor.
+ ~D3MFImporter() override;
+
+ /// @brief Performs the data format detection.
+ /// @param pFile The filename to check.
+ /// @param pIOHandler The used IO-System.
+ /// @param checkSig true for signature checking.
+ /// @return true for can be loaded, false for not.
+ bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+ /// @brief Not used
+ /// @param pImp Not used
+ void SetupProperties(const Importer *pImp) override;
+
+ /// @brief The importer description getter.
+ /// @return The info
+ const aiImporterDesc *GetInfo() const override;
+
+protected:
+ /// @brief Internal read function, performs the file parsing.
+ /// @param pFile The filename
+ /// @param pScene The scene to load in.
+ /// @param pIOHandler The io-system
+ void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+};
+
+} // Namespace Assimp
+
+#endif // #ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#endif // AI_D3MFLOADER_H_INCLUDED
diff --git a/libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp b/libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp
new file mode 100644
index 0000000..f88039a
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp
@@ -0,0 +1,256 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#include "D3MFOpcPackage.h"
+#include <assimp/Exceptional.h>
+#include <assimp/XmlParser.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/ai_assert.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/texture.h>
+#include "3MFXmlTags.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <map>
+#include <vector>
+
+namespace Assimp {
+
+namespace D3MF {
+// ------------------------------------------------------------------------------------------------
+
+using OpcPackageRelationshipPtr = std::shared_ptr<OpcPackageRelationship>;
+
+class OpcPackageRelationshipReader {
+public:
+ OpcPackageRelationshipReader(XmlParser &parser) :
+ m_relationShips() {
+ XmlNode root = parser.getRootNode();
+ ParseRootNode(root);
+ }
+
+ void ParseRootNode(XmlNode &node) {
+ ParseAttributes(node);
+ for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+ std::string name = currentNode.name();
+ if (name == "Relationships") {
+ ParseRelationsNode(currentNode);
+ }
+ }
+ }
+
+ void ParseAttributes(XmlNode & /*node*/) {
+ // empty
+ }
+
+ bool validateRels(OpcPackageRelationshipPtr &relPtr) {
+ if (relPtr->id.empty() || relPtr->type.empty() || relPtr->target.empty()) {
+ return false;
+ }
+
+ return true;
+ }
+
+ void ParseRelationsNode(XmlNode &node) {
+ if (node.empty()) {
+ return;
+ }
+
+ for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+ const std::string name = currentNode.name();
+ if (name == "Relationship") {
+ OpcPackageRelationshipPtr relPtr(new OpcPackageRelationship());
+ relPtr->id = currentNode.attribute(XmlTag::RELS_ATTRIB_ID).as_string();
+ relPtr->type = currentNode.attribute(XmlTag::RELS_ATTRIB_TYPE).as_string();
+ relPtr->target = currentNode.attribute(XmlTag::RELS_ATTRIB_TARGET).as_string();
+ if (validateRels(relPtr)) {
+ m_relationShips.push_back(relPtr);
+ }
+ }
+ }
+ }
+
+ std::vector<OpcPackageRelationshipPtr> m_relationShips;
+};
+
+static bool IsEmbeddedTexture( const std::string &filename ) {
+ const std::string extension = BaseImporter::GetExtension(filename);
+ if (extension == "jpg" || extension == "png") {
+ std::string::size_type pos = filename.find("thumbnail");
+ if (pos == std::string::npos) {
+ return false;
+ }
+ return true;
+ }
+
+ return false;
+}
+// ------------------------------------------------------------------------------------------------
+D3MFOpcPackage::D3MFOpcPackage(IOSystem *pIOHandler, const std::string &rFile) :
+ mRootStream(nullptr),
+ mZipArchive() {
+ mZipArchive = new ZipArchiveIOSystem(pIOHandler, rFile);
+ if (!mZipArchive->isOpen()) {
+ throw DeadlyImportError("Failed to open file ", rFile, ".");
+ }
+
+ std::vector<std::string> fileList;
+ mZipArchive->getFileList(fileList);
+
+ for (auto &file : fileList) {
+ if (file == D3MF::XmlTag::ROOT_RELATIONSHIPS_ARCHIVE) {
+ if (!mZipArchive->Exists(file.c_str())) {
+ continue;
+ }
+
+ IOStream *fileStream = mZipArchive->Open(file.c_str());
+ if (nullptr == fileStream) {
+ ASSIMP_LOG_ERROR("Filestream is nullptr.");
+ continue;
+ }
+
+ std::string rootFile = ReadPackageRootRelationship(fileStream);
+ if (!rootFile.empty() && rootFile[0] == '/') {
+ rootFile = rootFile.substr(1);
+ if (rootFile[0] == '/') {
+ // deal with zip-bug
+ rootFile = rootFile.substr(1);
+ }
+ }
+
+ ASSIMP_LOG_VERBOSE_DEBUG(rootFile);
+
+ mZipArchive->Close(fileStream);
+
+ mRootStream = mZipArchive->Open(rootFile.c_str());
+ ai_assert(mRootStream != nullptr);
+ if (nullptr == mRootStream) {
+ throw DeadlyImportError("Cannot open root-file in archive : " + rootFile);
+ }
+ } else if (file == D3MF::XmlTag::CONTENT_TYPES_ARCHIVE) {
+ ASSIMP_LOG_WARN("Ignored file of unsupported type CONTENT_TYPES_ARCHIVES", file);
+ } else if (IsEmbeddedTexture(file)) {
+ IOStream *fileStream = mZipArchive->Open(file.c_str());
+ LoadEmbeddedTextures(fileStream, file);
+ mZipArchive->Close(fileStream);
+ } else {
+ ASSIMP_LOG_WARN("Ignored file of unknown type: ", file);
+ }
+ }
+}
+
+D3MFOpcPackage::~D3MFOpcPackage() {
+ mZipArchive->Close(mRootStream);
+ delete mZipArchive;
+}
+
+IOStream *D3MFOpcPackage::RootStream() const {
+ return mRootStream;
+}
+
+const std::vector<aiTexture *> &D3MFOpcPackage::GetEmbeddedTextures() const {
+ return mEmbeddedTextures;
+}
+
+static const char *const ModelRef = "3D/3dmodel.model";
+
+bool D3MFOpcPackage::validate() {
+ if (nullptr == mRootStream || nullptr == mZipArchive) {
+ return false;
+ }
+
+ return mZipArchive->Exists(ModelRef);
+}
+
+std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream *stream) {
+ XmlParser xmlParser;
+ if (!xmlParser.parse(stream)) {
+ return std::string();
+ }
+
+ OpcPackageRelationshipReader reader(xmlParser);
+
+ auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr &rel) {
+ return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
+ });
+
+ if (itr == reader.m_relationShips.end()) {
+ throw DeadlyImportError("Cannot find ", XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE);
+ }
+
+ return (*itr)->target;
+}
+
+void D3MFOpcPackage::LoadEmbeddedTextures(IOStream *fileStream, const std::string &filename) {
+ if (nullptr == fileStream) {
+ return;
+ }
+
+ const size_t size = fileStream->FileSize();
+ if (0 == size) {
+ return;
+ }
+
+ unsigned char *data = new unsigned char[size];
+ fileStream->Read(data, 1, size);
+ aiTexture *texture = new aiTexture;
+ std::string embName = "*" + filename;
+ texture->mFilename.Set(embName.c_str());
+ texture->mWidth = static_cast<unsigned int>(size);
+ texture->mHeight = 0;
+ texture->achFormatHint[0] = 'p';
+ texture->achFormatHint[1] = 'n';
+ texture->achFormatHint[2] = 'g';
+ texture->achFormatHint[3] = '\0';
+ texture->pcData = (aiTexel*) data;
+ mEmbeddedTextures.emplace_back(texture);
+}
+
+} // Namespace D3MF
+} // Namespace Assimp
+
+#endif //ASSIMP_BUILD_NO_3MF_IMPORTER
diff --git a/libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.h b/libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.h
new file mode 100644
index 0000000..f6803a0
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/D3MFOpcPackage.h
@@ -0,0 +1,84 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef D3MFOPCPACKAGE_H
+#define D3MFOPCPACKAGE_H
+
+#include <assimp/IOSystem.hpp>
+#include <memory>
+#include <string>
+
+struct aiTexture;
+
+namespace Assimp {
+
+class ZipArchiveIOSystem;
+
+namespace D3MF {
+
+struct OpcPackageRelationship {
+ std::string id;
+ std::string type;
+ std::string target;
+};
+
+class D3MFOpcPackage {
+public:
+ D3MFOpcPackage( IOSystem* pIOHandler, const std::string& file );
+ ~D3MFOpcPackage();
+ IOStream* RootStream() const;
+ bool validate();
+ const std::vector<aiTexture*> &GetEmbeddedTextures() const;
+
+protected:
+ std::string ReadPackageRootRelationship(IOStream* stream);
+ void LoadEmbeddedTextures(IOStream *fileStream, const std::string &filename);
+
+private:
+ IOStream* mRootStream;
+ ZipArchiveIOSystem *mZipArchive;
+ std::vector<aiTexture *> mEmbeddedTextures;
+};
+
+} // namespace D3MF
+} // namespace Assimp
+
+#endif // D3MFOPCPACKAGE_H
diff --git a/libs/assimp/code/AssetLib/3MF/XmlSerializer.cpp b/libs/assimp/code/AssetLib/3MF/XmlSerializer.cpp
new file mode 100644
index 0000000..9bd1c5b
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/XmlSerializer.cpp
@@ -0,0 +1,593 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#include "XmlSerializer.h"
+#include "D3MFOpcPackage.h"
+#include "3MFXmlTags.h"
+#include "3MFTypes.h"
+#include <assimp/scene.h>
+
+namespace Assimp {
+namespace D3MF {
+
+static const int IdNotSet = -1;
+
+namespace {
+
+static const size_t ColRGBA_Len = 9;
+static const size_t ColRGB_Len = 7;
+
+// format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
+bool validateColorString(const char *color) {
+ const size_t len = strlen(color);
+ if (ColRGBA_Len != len && ColRGB_Len != len) {
+ return false;
+ }
+
+ return true;
+}
+
+aiFace ReadTriangle(XmlNode &node) {
+ aiFace face;
+
+ face.mNumIndices = 3;
+ face.mIndices = new unsigned int[face.mNumIndices];
+ face.mIndices[0] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v1).as_string()));
+ face.mIndices[1] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v2).as_string()));
+ face.mIndices[2] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v3).as_string()));
+
+ return face;
+}
+
+aiVector3D ReadVertex(XmlNode &node) {
+ aiVector3D vertex;
+ vertex.x = ai_strtof(node.attribute(XmlTag::x).as_string(), nullptr);
+ vertex.y = ai_strtof(node.attribute(XmlTag::y).as_string(), nullptr);
+ vertex.z = ai_strtof(node.attribute(XmlTag::z).as_string(), nullptr);
+
+ return vertex;
+}
+
+bool getNodeAttribute(const XmlNode &node, const std::string &attribute, std::string &value) {
+ pugi::xml_attribute objectAttribute = node.attribute(attribute.c_str());
+ if (!objectAttribute.empty()) {
+ value = objectAttribute.as_string();
+ return true;
+ }
+
+ return false;
+}
+
+bool getNodeAttribute(const XmlNode &node, const std::string &attribute, int &value) {
+ std::string strValue;
+ const bool ret = getNodeAttribute(node, attribute, strValue);
+ if (ret) {
+ value = std::atoi(strValue.c_str());
+ return true;
+ }
+
+ return false;
+}
+
+aiMatrix4x4 parseTransformMatrix(std::string matrixStr) {
+ // split the string
+ std::vector<float> numbers;
+ std::string currentNumber;
+ for (char c : matrixStr) {
+ if (c == ' ') {
+ if (!currentNumber.empty()) {
+ float f = std::stof(currentNumber);
+ numbers.push_back(f);
+ currentNumber.clear();
+ }
+ } else {
+ currentNumber.push_back(c);
+ }
+ }
+ if (!currentNumber.empty()) {
+ const float f = std::stof(currentNumber);
+ numbers.push_back(f);
+ }
+
+ aiMatrix4x4 transformMatrix;
+ transformMatrix.a1 = numbers[0];
+ transformMatrix.b1 = numbers[1];
+ transformMatrix.c1 = numbers[2];
+ transformMatrix.d1 = 0;
+
+ transformMatrix.a2 = numbers[3];
+ transformMatrix.b2 = numbers[4];
+ transformMatrix.c2 = numbers[5];
+ transformMatrix.d2 = 0;
+
+ transformMatrix.a3 = numbers[6];
+ transformMatrix.b3 = numbers[7];
+ transformMatrix.c3 = numbers[8];
+ transformMatrix.d3 = 0;
+
+ transformMatrix.a4 = numbers[9];
+ transformMatrix.b4 = numbers[10];
+ transformMatrix.c4 = numbers[11];
+ transformMatrix.d4 = 1;
+
+ return transformMatrix;
+}
+
+bool parseColor(const char *color, aiColor4D &diffuse) {
+ if (nullptr == color) {
+ return false;
+ }
+
+ if (!validateColorString(color)) {
+ return false;
+ }
+
+ if ('#' != color[0]) {
+ return false;
+ }
+
+ char r[3] = { color[1], color[2], '\0' };
+ diffuse.r = static_cast<ai_real>(strtol(r, nullptr, 16)) / ai_real(255.0);
+
+ char g[3] = { color[3], color[4], '\0' };
+ diffuse.g = static_cast<ai_real>(strtol(g, nullptr, 16)) / ai_real(255.0);
+
+ char b[3] = { color[5], color[6], '\0' };
+ diffuse.b = static_cast<ai_real>(strtol(b, nullptr, 16)) / ai_real(255.0);
+ const size_t len = strlen(color);
+ if (ColRGB_Len == len) {
+ return true;
+ }
+
+ char a[3] = { color[7], color[8], '\0' };
+ diffuse.a = static_cast<ai_real>(strtol(a, nullptr, 16)) / ai_real(255.0);
+
+ return true;
+}
+
+void assignDiffuseColor(XmlNode &node, aiMaterial *mat) {
+ const char *color = node.attribute(XmlTag::basematerials_displaycolor).as_string();
+ aiColor4D diffuse;
+ if (parseColor(color, diffuse)) {
+ mat->AddProperty<aiColor4D>(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+ }
+}
+
+} // namespace
+
+XmlSerializer::XmlSerializer(XmlParser *xmlParser) :
+ mResourcesDictionnary(),
+ mMeshCount(0),
+ mXmlParser(xmlParser) {
+ ai_assert(nullptr != xmlParser);
+}
+
+XmlSerializer::~XmlSerializer() {
+ for (auto &it : mResourcesDictionnary) {
+ delete it.second;
+ }
+}
+
+void XmlSerializer::ImportXml(aiScene *scene) {
+ if (nullptr == scene) {
+ return;
+ }
+
+ scene->mRootNode = new aiNode(XmlTag::RootTag);
+ XmlNode node = mXmlParser->getRootNode().child(XmlTag::model);
+ if (node.empty()) {
+ return;
+ }
+
+ XmlNode resNode = node.child(XmlTag::resources);
+ for (auto &currentNode : resNode.children()) {
+ const std::string currentNodeName = currentNode.name();
+ if (currentNodeName == XmlTag::texture_2d) {
+ ReadEmbeddecTexture(currentNode);
+ } else if (currentNodeName == XmlTag::texture_group) {
+ ReadTextureGroup(currentNode);
+ } else if (currentNodeName == XmlTag::object) {
+ ReadObject(currentNode);
+ } else if (currentNodeName == XmlTag::basematerials) {
+ ReadBaseMaterials(currentNode);
+ } else if (currentNodeName == XmlTag::meta) {
+ ReadMetadata(currentNode);
+ }
+ }
+ StoreMaterialsInScene(scene);
+ XmlNode buildNode = node.child(XmlTag::build);
+ if (buildNode.empty()) {
+ return;
+ }
+
+ for (auto &currentNode : buildNode.children()) {
+ const std::string currentNodeName = currentNode.name();
+ if (currentNodeName == XmlTag::item) {
+ int objectId = IdNotSet;
+ std::string transformationMatrixStr;
+ aiMatrix4x4 transformationMatrix;
+ getNodeAttribute(currentNode, D3MF::XmlTag::objectid, objectId);
+ bool hasTransform = getNodeAttribute(currentNode, D3MF::XmlTag::transform, transformationMatrixStr);
+
+ auto it = mResourcesDictionnary.find(objectId);
+ if (it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_Object) {
+ Object *obj = static_cast<Object *>(it->second);
+ if (hasTransform) {
+ transformationMatrix = parseTransformMatrix(transformationMatrixStr);
+ }
+
+ addObjectToNode(scene->mRootNode, obj, transformationMatrix);
+ }
+ }
+ }
+
+ // import the metadata
+ if (!mMetaData.empty()) {
+ const size_t numMeta = mMetaData.size();
+ scene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(numMeta));
+ for (size_t i = 0; i < numMeta; ++i) {
+ aiString val(mMetaData[i].value);
+ scene->mMetaData->Set(static_cast<unsigned int>(i), mMetaData[i].name, val);
+ }
+ }
+
+ // import the meshes, materials are already stored
+ scene->mNumMeshes = static_cast<unsigned int>(mMeshCount);
+ if (scene->mNumMeshes != 0) {
+ scene->mMeshes = new aiMesh *[scene->mNumMeshes]();
+ for (auto &it : mResourcesDictionnary) {
+ if (it.second->getType() == ResourceType::RT_Object) {
+ Object *obj = static_cast<Object *>(it.second);
+ ai_assert(nullptr != obj);
+ for (unsigned int i = 0; i < obj->mMeshes.size(); ++i) {
+ scene->mMeshes[obj->mMeshIndex[i]] = obj->mMeshes[i];
+ }
+ }
+ }
+ }
+}
+
+void XmlSerializer::addObjectToNode(aiNode *parent, Object *obj, aiMatrix4x4 nodeTransform) {
+ ai_assert(nullptr != obj);
+
+ aiNode *sceneNode = new aiNode(obj->mName);
+ sceneNode->mNumMeshes = static_cast<unsigned int>(obj->mMeshes.size());
+ sceneNode->mMeshes = new unsigned int[sceneNode->mNumMeshes];
+ std::copy(obj->mMeshIndex.begin(), obj->mMeshIndex.end(), sceneNode->mMeshes);
+
+ sceneNode->mTransformation = nodeTransform;
+ if (nullptr != parent) {
+ parent->addChildren(1, &sceneNode);
+ }
+
+ for (Assimp::D3MF::Component c : obj->mComponents) {
+ auto it = mResourcesDictionnary.find(c.mObjectId);
+ if (it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_Object) {
+ addObjectToNode(sceneNode, static_cast<Object *>(it->second), c.mTransformation);
+ }
+ }
+}
+
+void XmlSerializer::ReadObject(XmlNode &node) {
+ int id = IdNotSet, pid = IdNotSet, pindex = IdNotSet;
+ bool hasId = getNodeAttribute(node, XmlTag::id, id);
+ if (!hasId) {
+ return;
+ }
+
+ bool hasPid = getNodeAttribute(node, XmlTag::pid, pid);
+ bool hasPindex = getNodeAttribute(node, XmlTag::pindex, pindex);
+
+ Object *obj = new Object(id);
+ for (XmlNode &currentNode : node.children()) {
+ const std::string currentName = currentNode.name();
+ if (currentName == D3MF::XmlTag::mesh) {
+ auto mesh = ReadMesh(currentNode);
+ mesh->mName.Set(ai_to_string(id));
+
+ if (hasPid) {
+ auto it = mResourcesDictionnary.find(pid);
+ if (hasPindex && it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_BaseMaterials) {
+ BaseMaterials *materials = static_cast<BaseMaterials *>(it->second);
+ mesh->mMaterialIndex = materials->mMaterialIndex[pindex];
+ }
+ }
+
+ obj->mMeshes.push_back(mesh);
+ obj->mMeshIndex.push_back(mMeshCount);
+ mMeshCount++;
+ } else if (currentName == D3MF::XmlTag::components) {
+ for (XmlNode &currentSubNode : currentNode.children()) {
+ const std::string subNodeName = currentSubNode.name();
+ if (subNodeName == D3MF::XmlTag::component) {
+ int objectId = IdNotSet;
+ std::string componentTransformStr;
+ aiMatrix4x4 componentTransform;
+ if (getNodeAttribute(currentSubNode, D3MF::XmlTag::transform, componentTransformStr)) {
+ componentTransform = parseTransformMatrix(componentTransformStr);
+ }
+
+ if (getNodeAttribute(currentSubNode, D3MF::XmlTag::objectid, objectId)) {
+ obj->mComponents.push_back({ objectId, componentTransform });
+ }
+ }
+ }
+ }
+ }
+
+ mResourcesDictionnary.insert(std::make_pair(id, obj));
+}
+
+aiMesh *XmlSerializer::ReadMesh(XmlNode &node) {
+ if (node.empty()) {
+ return nullptr;
+ }
+
+ aiMesh *mesh = new aiMesh();
+ for (XmlNode &currentNode : node.children()) {
+ const std::string currentName = currentNode.name();
+ if (currentName == XmlTag::vertices) {
+ ImportVertices(currentNode, mesh);
+ } else if (currentName == XmlTag::triangles) {
+ ImportTriangles(currentNode, mesh);
+ }
+ }
+
+ return mesh;
+}
+
+void XmlSerializer::ReadMetadata(XmlNode &node) {
+ pugi::xml_attribute attribute = node.attribute(D3MF::XmlTag::meta_name);
+ const std::string name = attribute.as_string();
+ const std::string value = node.value();
+ if (name.empty()) {
+ return;
+ }
+
+ MetaEntry entry;
+ entry.name = name;
+ entry.value = value;
+ mMetaData.push_back(entry);
+}
+
+void XmlSerializer::ImportVertices(XmlNode &node, aiMesh *mesh) {
+ ai_assert(nullptr != mesh);
+
+ std::vector<aiVector3D> vertices;
+ for (XmlNode &currentNode : node.children()) {
+ const std::string currentName = currentNode.name();
+ if (currentName == XmlTag::vertex) {
+ vertices.push_back(ReadVertex(currentNode));
+ }
+ }
+
+ mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
+ mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+ std::copy(vertices.begin(), vertices.end(), mesh->mVertices);
+}
+
+void XmlSerializer::ImportTriangles(XmlNode &node, aiMesh *mesh) {
+ std::vector<aiFace> faces;
+ for (XmlNode &currentNode : node.children()) {
+ const std::string currentName = currentNode.name();
+ if (currentName == XmlTag::triangle) {
+ int pid = IdNotSet, p1 = IdNotSet;
+ bool hasPid = getNodeAttribute(currentNode, D3MF::XmlTag::pid, pid);
+ bool hasP1 = getNodeAttribute(currentNode, D3MF::XmlTag::p1, p1);
+
+ if (hasPid && hasP1) {
+ auto it = mResourcesDictionnary.find(pid);
+ if (it != mResourcesDictionnary.end()) {
+ if (it->second->getType() == ResourceType::RT_BaseMaterials) {
+ BaseMaterials *baseMaterials = static_cast<BaseMaterials *>(it->second);
+ mesh->mMaterialIndex = baseMaterials->mMaterialIndex[p1];
+ } else if (it->second->getType() == ResourceType::RT_Texture2DGroup) {
+ if (mesh->mTextureCoords[0] == nullptr) {
+ Texture2DGroup *group = static_cast<Texture2DGroup *>(it->second);
+ const std::string name = ai_to_string(group->mTexId);
+ for (size_t i = 0; i < mMaterials.size(); ++i) {
+ if (name == mMaterials[i]->GetName().C_Str()) {
+ mesh->mMaterialIndex = static_cast<unsigned int>(i);
+ }
+ }
+ mesh->mTextureCoords[0] = new aiVector3D[group->mTex2dCoords.size()];
+ for (unsigned int i = 0; i < group->mTex2dCoords.size(); ++i) {
+ mesh->mTextureCoords[0][i] = aiVector3D(group->mTex2dCoords[i].x, group->mTex2dCoords[i].y, 0);
+ }
+ }
+ }
+ }
+ }
+
+ aiFace face = ReadTriangle(currentNode);
+ faces.push_back(face);
+ }
+ }
+
+ mesh->mNumFaces = static_cast<unsigned int>(faces.size());
+ mesh->mFaces = new aiFace[mesh->mNumFaces];
+ mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+ std::copy(faces.begin(), faces.end(), mesh->mFaces);
+}
+
+void XmlSerializer::ReadBaseMaterials(XmlNode &node) {
+ int id = IdNotSet;
+ if (getNodeAttribute(node, D3MF::XmlTag::id, id)) {
+ BaseMaterials *baseMaterials = new BaseMaterials(id);
+
+ for (XmlNode &currentNode : node.children()) {
+ const std::string currentName = currentNode.name();
+ if (currentName == XmlTag::basematerials_base) {
+ baseMaterials->mMaterialIndex.push_back(static_cast<unsigned int>(mMaterials.size()));
+ mMaterials.push_back(readMaterialDef(currentNode, id));
+ }
+ }
+
+ mResourcesDictionnary.insert(std::make_pair(id, baseMaterials));
+ }
+}
+
+void XmlSerializer::ReadEmbeddecTexture(XmlNode &node) {
+ if (node.empty()) {
+ return;
+ }
+
+ std::string value;
+ EmbeddedTexture *tex2D = nullptr;
+ if (XmlParser::getStdStrAttribute(node, XmlTag::id, value)) {
+ tex2D = new EmbeddedTexture(atoi(value.c_str()));
+ }
+ if (nullptr == tex2D) {
+ return;
+ }
+
+ if (XmlParser::getStdStrAttribute(node, XmlTag::path, value)) {
+ tex2D->mPath = value;
+ }
+ if (XmlParser::getStdStrAttribute(node, XmlTag::texture_content_type, value)) {
+ tex2D->mContentType = value;
+ }
+ if (XmlParser::getStdStrAttribute(node, XmlTag::texture_tilestyleu, value)) {
+ tex2D->mTilestyleU = value;
+ }
+ if (XmlParser::getStdStrAttribute(node, XmlTag::texture_tilestylev, value)) {
+ tex2D->mTilestyleV = value;
+ }
+ mEmbeddedTextures.emplace_back(tex2D);
+ StoreEmbeddedTexture(tex2D);
+}
+
+void XmlSerializer::StoreEmbeddedTexture(EmbeddedTexture *tex) {
+ aiMaterial *mat = new aiMaterial;
+ aiString s;
+ s.Set(ai_to_string(tex->mId).c_str());
+ mat->AddProperty(&s, AI_MATKEY_NAME);
+ const std::string name = "*" + tex->mPath;
+ s.Set(name);
+ mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
+
+ aiColor3D col;
+ mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_DIFFUSE);
+ mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_AMBIENT);
+ mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_EMISSIVE);
+ mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_SPECULAR);
+ mMaterials.emplace_back(mat);
+}
+
+void XmlSerializer::ReadTextureCoords2D(XmlNode &node, Texture2DGroup *tex2DGroup) {
+ if (node.empty() || nullptr == tex2DGroup) {
+ return;
+ }
+
+ int id = IdNotSet;
+ if (XmlParser::getIntAttribute(node, "texid", id)) {
+ tex2DGroup->mTexId = id;
+ }
+
+ double value = 0.0;
+ for (XmlNode currentNode : node.children()) {
+ const std::string currentName = currentNode.name();
+ aiVector2D texCoord;
+ if (currentName == XmlTag::texture_2d_coord) {
+ XmlParser::getDoubleAttribute(currentNode, XmlTag::texture_cuurd_u, value);
+ texCoord.x = (ai_real)value;
+ XmlParser::getDoubleAttribute(currentNode, XmlTag::texture_cuurd_v, value);
+ texCoord.y = (ai_real)value;
+ tex2DGroup->mTex2dCoords.push_back(texCoord);
+ }
+ }
+}
+
+void XmlSerializer::ReadTextureGroup(XmlNode &node) {
+ if (node.empty()) {
+ return;
+ }
+
+ int id = IdNotSet;
+ if (!XmlParser::getIntAttribute(node, XmlTag::id, id)) {
+ return;
+ }
+
+ Texture2DGroup *group = new Texture2DGroup(id);
+ ReadTextureCoords2D(node, group);
+ mResourcesDictionnary.insert(std::make_pair(id, group));
+}
+
+aiMaterial *XmlSerializer::readMaterialDef(XmlNode &node, unsigned int basematerialsId) {
+ aiMaterial *material = new aiMaterial();
+ material->mNumProperties = 0;
+ std::string name;
+ bool hasName = getNodeAttribute(node, D3MF::XmlTag::basematerials_name, name);
+
+ std::string stdMaterialName;
+ const std::string strId(ai_to_string(basematerialsId));
+ stdMaterialName += "id";
+ stdMaterialName += strId;
+ stdMaterialName += "_";
+ if (hasName) {
+ stdMaterialName += std::string(name);
+ } else {
+ stdMaterialName += "basemat_";
+ stdMaterialName += ai_to_string(mMaterials.size());
+ }
+
+ aiString assimpMaterialName(stdMaterialName);
+ material->AddProperty(&assimpMaterialName, AI_MATKEY_NAME);
+
+ assignDiffuseColor(node, material);
+
+ return material;
+}
+
+void XmlSerializer::StoreMaterialsInScene(aiScene *scene) {
+ if (nullptr == scene || mMaterials.empty()) {
+ return;
+ }
+
+ scene->mNumMaterials = static_cast<unsigned int>(mMaterials.size());
+ scene->mMaterials = new aiMaterial *[scene->mNumMaterials];
+ for (size_t i = 0; i < mMaterials.size(); ++i) {
+ scene->mMaterials[i] = mMaterials[i];
+ }
+}
+
+} // namespace D3MF
+} // namespace Assimp
diff --git a/libs/assimp/code/AssetLib/3MF/XmlSerializer.h b/libs/assimp/code/AssetLib/3MF/XmlSerializer.h
new file mode 100644
index 0000000..6cf6a70
--- /dev/null
+++ b/libs/assimp/code/AssetLib/3MF/XmlSerializer.h
@@ -0,0 +1,96 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+#include <assimp/XmlParser.h>
+#include <assimp/mesh.h>
+#include <vector>
+#include <map>
+
+struct aiNode;
+struct aiMesh;
+struct aiMaterial;
+
+namespace Assimp {
+namespace D3MF {
+
+class Resource;
+class D3MFOpcPackage;
+class Object;
+class Texture2DGroup;
+class EmbeddedTexture;
+
+class XmlSerializer {
+public:
+ XmlSerializer(XmlParser *xmlParser);
+ ~XmlSerializer();
+ void ImportXml(aiScene *scene);
+
+private:
+ void addObjectToNode(aiNode *parent, Object *obj, aiMatrix4x4 nodeTransform);
+ void ReadObject(XmlNode &node);
+ aiMesh *ReadMesh(XmlNode &node);
+ void ReadMetadata(XmlNode &node);
+ void ImportVertices(XmlNode &node, aiMesh *mesh);
+ void ImportTriangles(XmlNode &node, aiMesh *mesh);
+ void ReadBaseMaterials(XmlNode &node);
+ void ReadEmbeddecTexture(XmlNode &node);
+ void StoreEmbeddedTexture(EmbeddedTexture *tex);
+ void ReadTextureCoords2D(XmlNode &node, Texture2DGroup *tex2DGroup);
+ void ReadTextureGroup(XmlNode &node);
+ aiMaterial *readMaterialDef(XmlNode &node, unsigned int basematerialsId);
+ void StoreMaterialsInScene(aiScene *scene);
+
+private:
+ struct MetaEntry {
+ std::string name;
+ std::string value;
+ };
+ std::vector<MetaEntry> mMetaData;
+ std::vector<EmbeddedTexture *> mEmbeddedTextures;
+ std::vector<aiMaterial *> mMaterials;
+ std::map<unsigned int, Resource *> mResourcesDictionnary;
+ unsigned int mMeshCount;
+ XmlParser *mXmlParser;
+};
+
+} // namespace D3MF
+} // namespace Assimp
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-01 16:41:01 +0000