summaryrefslogtreecommitdiff
path: root/libs/assimp/code/AssetLib/OpenGEX
diff options
context:
space:
mode:
Diffstat (limited to 'libs/assimp/code/AssetLib/OpenGEX')
-rw-r--r--libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp62
-rw-r--r--libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h68
-rw-r--r--libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp1326
-rw-r--r--libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h213
-rw-r--r--libs/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h264
5 files changed, 1933 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
new file mode 100644
index 0000000..328c3c4
--- /dev/null
+++ b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
@@ -0,0 +1,62 @@
+/*
+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 "OpenGEXExporter.h"
+
+namespace Assimp {
+namespace OpenGEX {
+
+#ifndef ASSIMP_BUILD_NO_OPENGEX_EXPORTER
+
+OpenGEXExporter::OpenGEXExporter() {
+}
+
+OpenGEXExporter::~OpenGEXExporter() {
+}
+
+bool OpenGEXExporter::exportScene( const char * /*filename*/, const aiScene* /*pScene*/ ) {
+ return true;
+}
+
+#endif // ASSIMP_BUILD_NO_OPENGEX_EXPORTER
+
+} // Namespace OpenGEX
+} // Namespace Assimp
diff --git a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h
new file mode 100644
index 0000000..cc22c7d
--- /dev/null
+++ b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h
@@ -0,0 +1,68 @@
+/*
+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 AI_OPENGEX_EXPORTER_H
+#define AI_OPENGEX_EXPORTER_H
+
+#include <assimp/types.h>
+
+#ifndef ASSIMP_BUILD_NO_OPENGEX_EXPORTER
+
+namespace Assimp {
+
+struct aiScene;
+
+namespace OpenGEX {
+
+class OpenGEXExporter {
+public:
+ OpenGEXExporter();
+ ~OpenGEXExporter();
+ bool exportScene( const char *filename, const aiScene* pScene );
+};
+
+} // Namespace OpenGEX
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_OPENGEX_EXPORTER
+
+#endif // AI_OPENGEX_EXPORTER_H
+
diff --git a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
new file mode 100644
index 0000000..c8e4793
--- /dev/null
+++ b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
@@ -0,0 +1,1326 @@
+/*
+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_OPENGEX_IMPORTER
+
+#include "AssetLib/OpenGEX/OpenGEXImporter.h"
+#include "PostProcessing/MakeVerboseFormat.h"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/StringComparison.h>
+#include <assimp/StringUtils.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/ai_assert.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <openddlparser/OpenDDLParser.h>
+
+static const aiImporterDesc desc = {
+ "Open Game Engine Exchange",
+ "",
+ "",
+ "",
+ aiImporterFlags_SupportTextFlavour,
+ 0,
+ 0,
+ 0,
+ 0,
+ "ogex"
+};
+
+namespace Grammar {
+ static const char* MetricType = "Metric";
+ static const char *Metric_DistanceType = "distance";
+ static const char *Metric_AngleType = "angle";
+ static const char *Metric_TimeType = "time";
+ static const char *Metric_UpType = "up";
+ static const char *NameType = "Name";
+ static const char *ObjectRefType = "ObjectRef";
+ static const char *MaterialRefType = "MaterialRef";
+ static const char *MetricKeyType = "key";
+ static const char *GeometryNodeType = "GeometryNode";
+ static const char *CameraNodeType = "CameraNode";
+ static const char *LightNodeType = "LightNode";
+ static const char *GeometryObjectType = "GeometryObject";
+ static const char *CameraObjectType = "CameraObject";
+ static const char *LightObjectType = "LightObject";
+ static const char *TransformType = "Transform";
+ static const char *MeshType = "Mesh";
+ static const char *VertexArrayType = "VertexArray";
+ static const char *IndexArrayType = "IndexArray";
+ static const char *MaterialType = "Material";
+ static const char *ColorType = "Color";
+ static const char *ParamType = "Param";
+ static const char *TextureType = "Texture";
+ static const char *AttenType = "Atten";
+
+ static const char *DiffuseColorToken = "diffuse";
+ static const char *SpecularColorToken = "specular";
+ static const char *EmissionColorToken = "emission";
+
+ static const char *DiffuseTextureToken = "diffuse";
+ static const char *DiffuseSpecularTextureToken = "specular";
+ static const char *SpecularPowerTextureToken = "specular_power";
+ static const char *EmissionTextureToken = "emission";
+ static const char *OpacyTextureToken = "opacity";
+ static const char *TransparencyTextureToken = "transparency";
+ static const char *NormalTextureToken = "normal";
+
+ enum TokenType {
+ NoneType = -1,
+ MetricToken,
+ NameToken,
+ ObjectRefToken,
+ MaterialRefToken,
+ MetricKeyToken,
+ GeometryNodeToken,
+ CameraNodeToken,
+ LightNodeToken,
+ GeometryObjectToken,
+ CameraObjectToken,
+ LightObjectToken,
+ TransformToken,
+ MeshToken,
+ VertexArrayToken,
+ IndexArrayToken,
+ MaterialToken,
+ ColorToken,
+ ParamToken,
+ TextureToken,
+ AttenToken
+ };
+
+ static const std::string ValidMetricToken[4] = {
+ Metric_DistanceType,
+ Metric_AngleType,
+ Metric_TimeType,
+ Metric_UpType
+ };
+
+ static int isValidMetricType(const char *token) {
+ if (nullptr == token) {
+ return false;
+ }
+
+ int idx(-1);
+ for (size_t i = 0; i < 4; i++) {
+ if (ValidMetricToken[i] == token) {
+ idx = (int)i;
+ break;
+ }
+ }
+
+ return idx;
+ }
+
+ static TokenType matchTokenType(const char *tokenType) {
+ if (MetricType == tokenType) {
+ return MetricToken;
+ } else if (NameType == tokenType) {
+ return NameToken;
+ } else if (ObjectRefType == tokenType) {
+ return ObjectRefToken;
+ } else if (MaterialRefType == tokenType) {
+ return MaterialRefToken;
+ } else if (MetricKeyType == tokenType) {
+ return MetricKeyToken;
+ } else if (GeometryNodeType == tokenType) {
+ return GeometryNodeToken;
+ } else if (CameraNodeType == tokenType) {
+ return CameraNodeToken;
+ } else if (LightNodeType == tokenType) {
+ return LightNodeToken;
+ } else if (GeometryObjectType == tokenType) {
+ return GeometryObjectToken;
+ } else if (CameraObjectType == tokenType) {
+ return CameraObjectToken;
+ } else if (LightObjectType == tokenType) {
+ return LightObjectToken;
+ } else if (TransformType == tokenType) {
+ return TransformToken;
+ } else if (MeshType == tokenType) {
+ return MeshToken;
+ } else if (VertexArrayType == tokenType) {
+ return VertexArrayToken;
+ } else if (IndexArrayType == tokenType) {
+ return IndexArrayToken;
+ } else if (MaterialType == tokenType) {
+ return MaterialToken;
+ } else if (ColorType == tokenType) {
+ return ColorToken;
+ } else if (ParamType == tokenType) {
+ return ParamToken;
+ } else if (TextureType == tokenType) {
+ return TextureToken;
+ } else if (AttenType == tokenType) {
+ return AttenToken;
+ }
+
+ return NoneType;
+ }
+} // Namespace Grammar
+
+namespace Assimp {
+namespace OpenGEX {
+
+USE_ODDLPARSER_NS
+
+//------------------------------------------------------------------------------------------------
+static void propId2StdString(Property *prop, std::string &name, std::string &key) {
+ name = key = std::string();
+ if (nullptr == prop) {
+ return;
+ }
+
+ if (nullptr != prop->m_key) {
+#ifdef ASSIMP_USE_HUNTER
+ name = prop->m_key->m_text.m_buffer;
+#else
+ name = prop->m_key->m_buffer;
+#endif
+ if (Value::ValueType::ddl_string == prop->m_value->m_type) {
+ key = prop->m_value->getString();
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+static void logDDLParserMessage (LogSeverity severity, const std::string &rawmsg) {
+ std::string msg = ai_str_toprintable(rawmsg);
+ switch (severity) {
+ case ddl_debug_msg: ASSIMP_LOG_DEBUG(msg); break;
+ case ddl_info_msg: ASSIMP_LOG_INFO(msg); break;
+ case ddl_warn_msg: ASSIMP_LOG_WARN(msg); break;
+ case ddl_error_msg: ASSIMP_LOG_ERROR(msg); break;
+ default: ASSIMP_LOG_VERBOSE_DEBUG(msg); break;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::VertexContainer::VertexContainer() :
+ m_numColors(0), m_colors(nullptr), m_numUVComps(), m_textureCoords() {
+ // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::VertexContainer::~VertexContainer() {
+ delete[] m_colors;
+
+ for (auto &texcoords : m_textureCoords) {
+ delete[] texcoords;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::RefInfo::RefInfo(aiNode *node, Type type, std::vector<std::string> &names) :
+ m_node(node),
+ m_type(type),
+ m_Names(names) {
+ // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::RefInfo::~RefInfo() {
+ // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::OpenGEXImporter() :
+ m_root(nullptr),
+ m_nodeChildMap(),
+ m_meshCache(),
+ m_mesh2refMap(),
+ m_material2refMap(),
+ m_ctx(nullptr),
+ m_metrics(),
+ m_currentNode(nullptr),
+ m_currentVertices(),
+ m_currentMesh(nullptr),
+ m_currentMaterial(nullptr),
+ m_currentLight(nullptr),
+ m_currentCamera(nullptr),
+ m_tokenType(Grammar::NoneType),
+ m_materialCache(),
+ m_cameraCache(),
+ m_lightCache(),
+ m_nodeStack(),
+ m_unresolvedRefStack() {
+ // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::~OpenGEXImporter() {
+}
+
+//------------------------------------------------------------------------------------------------
+bool OpenGEXImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*checkSig*/) const {
+ static const char *tokens[] = { "Metric", "GeometryNode", "VertexArray (attrib", "IndexArray" };
+ return SearchFileHeaderForToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens));
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::InternReadFile(const std::string &filename, aiScene *pScene, IOSystem *pIOHandler) {
+ // open source file
+ IOStream *file = pIOHandler->Open(filename, "rb");
+ if (!file) {
+ throw DeadlyImportError("Failed to open file ", filename);
+ }
+
+ std::vector<char> buffer;
+ TextFileToBuffer(file, buffer);
+ pIOHandler->Close(file);
+
+ OpenDDLParser myParser;
+ myParser.setLogCallback(&logDDLParserMessage);
+ myParser.setBuffer(&buffer[0], buffer.size());
+ bool success(myParser.parse());
+ if (success) {
+ m_ctx = myParser.getContext();
+ pScene->mRootNode = new aiNode;
+ pScene->mRootNode->mName.Set(filename);
+ handleNodes(m_ctx->m_root, pScene);
+ }
+
+ copyMeshes(pScene);
+ copyCameras(pScene);
+ copyLights(pScene);
+ copyMaterials(pScene);
+ resolveReferences();
+ createNodeTree(pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+const aiImporterDesc *OpenGEXImporter::GetInfo() const {
+ return &desc;
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::SetupProperties(const Importer *pImp) {
+ if (nullptr == pImp) {
+ return;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleNodes(DDLNode *node, aiScene *pScene) {
+ if (nullptr == node) {
+ return;
+ }
+
+ DDLNode::DllNodeList children = node->getChildNodeList();
+ for (DDLNode::DllNodeList::iterator it = children.begin(); it != children.end(); ++it) {
+ Grammar::TokenType tokenType(Grammar::matchTokenType((*it)->getType().c_str()));
+ switch (tokenType) {
+ case Grammar::MetricToken:
+ handleMetricNode(*it, pScene);
+ break;
+
+ case Grammar::NameToken:
+ handleNameNode(*it, pScene);
+ break;
+
+ case Grammar::ObjectRefToken:
+ handleObjectRefNode(*it, pScene);
+ break;
+
+ case Grammar::MaterialRefToken:
+ handleMaterialRefNode(*it, pScene);
+ break;
+
+ case Grammar::MetricKeyToken:
+ break;
+
+ case Grammar::GeometryNodeToken:
+ handleGeometryNode(*it, pScene);
+ break;
+
+ case Grammar::CameraNodeToken:
+ handleCameraNode(*it, pScene);
+ break;
+
+ case Grammar::LightNodeToken:
+ handleLightNode(*it, pScene);
+ break;
+
+ case Grammar::GeometryObjectToken:
+ handleGeometryObject(*it, pScene);
+ break;
+
+ case Grammar::CameraObjectToken:
+ handleCameraObject(*it, pScene);
+ break;
+
+ case Grammar::LightObjectToken:
+ handleLightObject(*it, pScene);
+ break;
+
+ case Grammar::TransformToken:
+ handleTransformNode(*it, pScene);
+ break;
+
+ case Grammar::MeshToken:
+ handleMeshNode(*it, pScene);
+ break;
+
+ case Grammar::VertexArrayToken:
+ handleVertexArrayNode(*it, pScene);
+ break;
+
+ case Grammar::IndexArrayToken:
+ handleIndexArrayNode(*it, pScene);
+ break;
+
+ case Grammar::MaterialToken:
+ handleMaterialNode(*it, pScene);
+ break;
+
+ case Grammar::ColorToken:
+ handleColorNode(*it, pScene);
+ break;
+
+ case Grammar::ParamToken:
+ handleParamNode(*it, pScene);
+ break;
+
+ case Grammar::TextureToken:
+ handleTextureNode(*it, pScene);
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMetricNode(DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node || nullptr == m_ctx) {
+ return;
+ }
+
+ if (m_ctx->m_root != node->getParent()) {
+ return;
+ }
+
+ Property *prop(node->getProperties());
+ while (nullptr != prop) {
+ if (nullptr != prop->m_key) {
+ if (Value::ValueType::ddl_string == prop->m_value->m_type) {
+ std::string valName((char *)prop->m_value->m_data);
+ int type(Grammar::isValidMetricType(valName.c_str()));
+ if (Grammar::NoneType != type) {
+ Value *val(node->getValue());
+ if (nullptr != val) {
+ if (Value::ValueType::ddl_float == val->m_type) {
+ m_metrics[type].m_floatValue = val->getFloat();
+ } else if (Value::ValueType::ddl_int32 == val->m_type) {
+ m_metrics[type].m_intValue = val->getInt32();
+ } else if (Value::ValueType::ddl_string == val->m_type) {
+ m_metrics[type].m_stringValue = std::string(val->getString());
+ } else {
+ throw DeadlyImportError("OpenGEX: invalid data type for Metric node.");
+ }
+ }
+ }
+ }
+ }
+ prop = prop->m_next;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleNameNode(DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == m_currentNode) {
+ throw DeadlyImportError("No current node for name.");
+ return;
+ }
+
+ Value *val(node->getValue());
+ if (nullptr != val) {
+ if (Value::ValueType::ddl_string != val->m_type) {
+ throw DeadlyImportError("OpenGEX: invalid data type for value in node name.");
+ return;
+ }
+
+ const std::string name(val->getString());
+ if (m_tokenType == Grammar::GeometryNodeToken || m_tokenType == Grammar::LightNodeToken || m_tokenType == Grammar::CameraNodeToken) {
+ m_currentNode->mName.Set(name.c_str());
+ } else if (m_tokenType == Grammar::MaterialToken) {
+ aiString aiName;
+ aiName.Set(name);
+ m_currentMaterial->AddProperty(&aiName, AI_MATKEY_NAME);
+ m_material2refMap[name] = m_materialCache.size() - 1;
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+static void getRefNames(DDLNode *node, std::vector<std::string> &names) {
+ ai_assert(nullptr != node);
+
+ Reference *ref = node->getReferences();
+ if (nullptr != ref) {
+ for (size_t i = 0; i < ref->m_numRefs; i++) {
+ Name *currentName(ref->m_referencedName[i]);
+ if (nullptr != currentName && nullptr != currentName->m_id) {
+#ifdef ASSIMP_USE_HUNTER
+ const std::string name(currentName->m_id->m_text.m_buffer);
+#else
+ const std::string name(currentName->m_id->m_buffer);
+#endif
+ if (!name.empty()) {
+ names.push_back(name);
+ }
+ }
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleObjectRefNode(DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == m_currentNode) {
+ throw DeadlyImportError("No parent node for name.");
+ return;
+ }
+
+ std::vector<std::string> objRefNames;
+ getRefNames(node, objRefNames);
+
+ // when we are dealing with a geometry node prepare the mesh cache
+ if (m_tokenType == Grammar::GeometryNodeToken) {
+ m_currentNode->mNumMeshes = static_cast<unsigned int>(objRefNames.size());
+ m_currentNode->mMeshes = new unsigned int[objRefNames.size()];
+ if (!objRefNames.empty()) {
+ m_unresolvedRefStack.push_back(std::unique_ptr<RefInfo>(new RefInfo(m_currentNode, RefInfo::MeshRef, objRefNames)));
+ }
+ } else if (m_tokenType == Grammar::LightNodeToken) {
+ // TODO!
+ } else if (m_tokenType == Grammar::CameraNodeToken) {
+ // TODO!
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMaterialRefNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == m_currentNode) {
+ throw DeadlyImportError("No parent node for name.");
+ return;
+ }
+
+ std::vector<std::string> matRefNames;
+ getRefNames(node, matRefNames);
+ if (!matRefNames.empty()) {
+ m_unresolvedRefStack.push_back(std::unique_ptr<RefInfo>(new RefInfo(m_currentNode, RefInfo::MaterialRef, matRefNames)));
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleGeometryNode(DDLNode *node, aiScene *pScene) {
+ aiNode *newNode = new aiNode;
+ pushNode(newNode, pScene);
+ m_tokenType = Grammar::GeometryNodeToken;
+ m_currentNode = newNode;
+ handleNodes(node, pScene);
+
+ popNode();
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleCameraNode(DDLNode *node, aiScene *pScene) {
+ aiCamera *camera(new aiCamera);
+ m_cameraCache.push_back(camera);
+ m_currentCamera = camera;
+
+ aiNode *newNode = new aiNode;
+ pushNode(newNode, pScene);
+ m_tokenType = Grammar::CameraNodeToken;
+ m_currentNode = newNode;
+
+ handleNodes(node, pScene);
+
+ popNode();
+
+ m_currentCamera->mName.Set(newNode->mName.C_Str());
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleLightNode(ODDLParser::DDLNode *node, aiScene *pScene) {
+ aiLight *light(new aiLight);
+ m_lightCache.push_back(light);
+ m_currentLight = light;
+
+ aiNode *newNode = new aiNode;
+ m_tokenType = Grammar::LightNodeToken;
+ m_currentNode = newNode;
+ pushNode(newNode, pScene);
+
+ handleNodes(node, pScene);
+
+ popNode();
+
+ m_currentLight->mName.Set(newNode->mName.C_Str());
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleGeometryObject(DDLNode *node, aiScene *pScene) {
+ // parameters will be parsed normally in the tree, so just go for it
+ handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleCameraObject(ODDLParser::DDLNode *node, aiScene *pScene) {
+ // parameters will be parsed normally in the tree, so just go for it
+
+ handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleLightObject(ODDLParser::DDLNode *node, aiScene *pScene) {
+ aiLight *light(new aiLight);
+ m_lightCache.push_back(light);
+ std::string objName = node->getName();
+ if (!objName.empty()) {
+ light->mName.Set(objName);
+ }
+ m_currentLight = light;
+
+ Property *prop(node->findPropertyByName("type"));
+ if (nullptr != prop) {
+ if (nullptr != prop->m_value) {
+ std::string typeStr(prop->m_value->getString());
+ if ("point" == typeStr) {
+ m_currentLight->mType = aiLightSource_POINT;
+ } else if ("spot" == typeStr) {
+ m_currentLight->mType = aiLightSource_SPOT;
+ } else if ("infinite" == typeStr) {
+ m_currentLight->mType = aiLightSource_DIRECTIONAL;
+ }
+ }
+ }
+
+ // parameters will be parsed normally in the tree, so just go for it
+ handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+static void setMatrix(aiNode *node, DataArrayList *transformData) {
+ ai_assert(nullptr != node);
+ ai_assert(nullptr != transformData);
+
+ float m[16];
+ size_t i(1);
+ Value *next(transformData->m_dataList->m_next);
+ m[0] = transformData->m_dataList->getFloat();
+ while (next != nullptr) {
+ m[i] = next->getFloat();
+ next = next->m_next;
+ i++;
+ }
+
+ ai_assert(i == 16);
+
+ node->mTransformation.a1 = m[0];
+ node->mTransformation.a2 = m[4];
+ node->mTransformation.a3 = m[8];
+ node->mTransformation.a4 = m[12];
+
+ node->mTransformation.b1 = m[1];
+ node->mTransformation.b2 = m[5];
+ node->mTransformation.b3 = m[9];
+ node->mTransformation.b4 = m[13];
+
+ node->mTransformation.c1 = m[2];
+ node->mTransformation.c2 = m[6];
+ node->mTransformation.c3 = m[10];
+ node->mTransformation.c4 = m[14];
+
+ node->mTransformation.d1 = m[3];
+ node->mTransformation.d2 = m[7];
+ node->mTransformation.d3 = m[11];
+ node->mTransformation.d4 = m[15];
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleTransformNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == m_currentNode) {
+ throw DeadlyImportError("No parent node for name.");
+ return;
+ }
+
+ DataArrayList *transformData(node->getDataArrayList());
+ if (nullptr != transformData) {
+ if (transformData->m_numItems != 16) {
+ throw DeadlyImportError("Invalid number of data for transform matrix.");
+ return;
+ }
+ setMatrix(m_currentNode, transformData);
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMeshNode(ODDLParser::DDLNode *node, aiScene *pScene) {
+ m_currentMesh = new aiMesh;
+ const size_t meshidx(m_meshCache.size());
+ // ownership is transferred but a reference remains in m_currentMesh
+ m_meshCache.emplace_back(m_currentMesh);
+
+ Property *prop = node->getProperties();
+ if (nullptr != prop) {
+ std::string propName, propKey;
+ propId2StdString(prop, propName, propKey);
+ if ("primitive" == propName) {
+ if ("points" == propKey) {
+ m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
+ } else if ("lines" == propKey) {
+ m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+ } else if ("triangles" == propKey) {
+ m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+ } else if ("quads" == propKey) {
+ m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+ } else {
+ ASSIMP_LOG_WARN(propKey, " is not supported primitive type.");
+ }
+ }
+ }
+
+ handleNodes(node, pScene);
+
+ DDLNode *parent(node->getParent());
+ if (nullptr != parent) {
+ const std::string &name = parent->getName();
+ m_mesh2refMap[name] = meshidx;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+enum MeshAttribute {
+ None,
+ Position,
+ Color,
+ Normal,
+ TexCoord
+};
+
+constexpr auto PosToken = "position";
+constexpr auto ColToken = "color";
+constexpr auto NormalToken = "normal";
+constexpr auto TexCoordToken = "texcoord";
+
+//------------------------------------------------------------------------------------------------
+static MeshAttribute getAttributeByName(const char *attribName) {
+ ai_assert(nullptr != attribName);
+
+ if (0 == strcmp(PosToken, attribName)) {
+ return Position;
+ } else if (0 == strcmp(ColToken, attribName)) {
+ return Color;
+ } else if (0 == strcmp(NormalToken, attribName)) {
+ return Normal;
+ } else if (0 == strcmp(TexCoordToken, attribName)) {
+ return TexCoord;
+ }
+
+ return None;
+}
+
+//------------------------------------------------------------------------------------------------
+static void fillVector3(aiVector3D *vec3, Value *vals) {
+ ai_assert(nullptr != vec3);
+ ai_assert(nullptr != vals);
+
+ float x(0.0f), y(0.0f), z(0.0f);
+ Value *next(vals);
+ x = next->getFloat();
+ next = next->m_next;
+ y = next->getFloat();
+ next = next->m_next;
+ if (nullptr != next) {
+ z = next->getFloat();
+ }
+
+ vec3->Set(x, y, z);
+}
+
+//------------------------------------------------------------------------------------------------
+static void fillColor4(aiColor4D *col4, Value *vals) {
+ ai_assert(nullptr != col4);
+ ai_assert(nullptr != vals);
+
+ Value *next(vals);
+ col4->r = next->getFloat();
+ next = next->m_next;
+ if (!next) {
+ throw DeadlyImportError("OpenGEX: Not enough values to fill 4-element color, only 1");
+ }
+
+ col4->g = next->getFloat();
+ next = next->m_next;
+ if (!next) {
+ throw DeadlyImportError("OpenGEX: Not enough values to fill 4-element color, only 2");
+ }
+
+ col4->b = next->getFloat();
+ next = next->m_next;
+ if (!next) {
+ throw DeadlyImportError("OpenGEX: Not enough values to fill 4-element color, only 3");
+ }
+
+ col4->a = next->getFloat();
+}
+
+//------------------------------------------------------------------------------------------------
+static size_t countDataArrayListItems(DataArrayList *vaList) {
+ size_t numItems(0);
+ if (nullptr == vaList) {
+ return numItems;
+ }
+
+ DataArrayList *next(vaList);
+ while (nullptr != next) {
+ if (nullptr != vaList->m_dataList) {
+ numItems++;
+ }
+ next = next->m_next;
+ }
+
+ return numItems;
+}
+
+//------------------------------------------------------------------------------------------------
+static void copyVectorArray(size_t numItems, DataArrayList *vaList, aiVector3D *vectorArray) {
+ for (size_t i = 0; i < numItems; i++) {
+ Value *next(vaList->m_dataList);
+ fillVector3(&vectorArray[i], next);
+ vaList = vaList->m_next;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+static void copyColor4DArray(size_t numItems, DataArrayList *vaList, aiColor4D *colArray) {
+ for (size_t i = 0; i < numItems; i++) {
+ Value *next(vaList->m_dataList);
+ fillColor4(&colArray[i], next);
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleVertexArrayNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node) {
+ throw DeadlyImportError("No parent node for name.");
+ return;
+ }
+
+ Property *prop = node->getProperties();
+ if (nullptr != prop) {
+ std::string propName, propKey;
+ propId2StdString(prop, propName, propKey);
+ MeshAttribute attribType(getAttributeByName(propKey.c_str()));
+ if (None == attribType) {
+ return;
+ }
+
+ DataArrayList *vaList = node->getDataArrayList();
+ if (nullptr == vaList) {
+ return;
+ }
+
+ const size_t numItems(countDataArrayListItems(vaList));
+
+ if (Position == attribType) {
+ m_currentVertices.m_vertices.resize(numItems);
+ copyVectorArray(numItems, vaList, m_currentVertices.m_vertices.data());
+ } else if (Color == attribType) {
+ m_currentVertices.m_numColors = numItems;
+ m_currentVertices.m_colors = new aiColor4D[numItems];
+ copyColor4DArray(numItems, vaList, m_currentVertices.m_colors);
+ } else if (Normal == attribType) {
+ m_currentVertices.m_normals.resize(numItems);
+ copyVectorArray(numItems, vaList, m_currentVertices.m_normals.data());
+ } else if (TexCoord == attribType) {
+ m_currentVertices.m_numUVComps[0] = numItems;
+ m_currentVertices.m_textureCoords[0] = new aiVector3D[numItems];
+ copyVectorArray(numItems, vaList, m_currentVertices.m_textureCoords[0]);
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleIndexArrayNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node) {
+ throw DeadlyImportError("No parent node for name.");
+ return;
+ }
+
+ if (nullptr == m_currentMesh) {
+ throw DeadlyImportError("No current mesh for index data found.");
+ return;
+ }
+
+ DataArrayList *vaList = node->getDataArrayList();
+ if (nullptr == vaList) {
+ return;
+ }
+
+ const size_t numItems(countDataArrayListItems(vaList));
+ m_currentMesh->mNumFaces = static_cast<unsigned int>(numItems);
+ m_currentMesh->mFaces = new aiFace[numItems];
+ m_currentMesh->mNumVertices = static_cast<unsigned int>(numItems * 3);
+ m_currentMesh->mVertices = new aiVector3D[m_currentMesh->mNumVertices];
+ bool hasColors(false);
+ if (m_currentVertices.m_numColors > 0) {
+ m_currentMesh->mColors[0] = new aiColor4D[m_currentVertices.m_numColors];
+ hasColors = true;
+ }
+ bool hasNormalCoords(false);
+ if (!m_currentVertices.m_normals.empty()) {
+ m_currentMesh->mNormals = new aiVector3D[m_currentMesh->mNumVertices];
+ hasNormalCoords = true;
+ }
+ bool hasTexCoords(false);
+ if (m_currentVertices.m_numUVComps[0] > 0) {
+ m_currentMesh->mTextureCoords[0] = new aiVector3D[m_currentMesh->mNumVertices];
+ hasTexCoords = true;
+ }
+
+ unsigned int index(0);
+ for (size_t i = 0; i < m_currentMesh->mNumFaces; i++) {
+ aiFace &current(m_currentMesh->mFaces[i]);
+ current.mNumIndices = 3;
+ current.mIndices = new unsigned int[current.mNumIndices];
+ Value *next(vaList->m_dataList);
+ for (size_t indices = 0; indices < current.mNumIndices; indices++) {
+ const int idx(next->getUnsignedInt32());
+ ai_assert(static_cast<size_t>(idx) <= m_currentVertices.m_vertices.size());
+ ai_assert(index < m_currentMesh->mNumVertices);
+ aiVector3D &pos = (m_currentVertices.m_vertices[idx]);
+ m_currentMesh->mVertices[index].Set(pos.x, pos.y, pos.z);
+ if (hasColors) {
+ aiColor4D &col = m_currentVertices.m_colors[idx];
+ m_currentMesh->mColors[0][index] = col;
+ }
+ if (hasNormalCoords) {
+ aiVector3D &normal = (m_currentVertices.m_normals[idx]);
+ m_currentMesh->mNormals[index].Set(normal.x, normal.y, normal.z);
+ }
+ if (hasTexCoords) {
+ aiVector3D &tex = (m_currentVertices.m_textureCoords[0][idx]);
+ m_currentMesh->mTextureCoords[0][index].Set(tex.x, tex.y, tex.z);
+ }
+ current.mIndices[indices] = index;
+ index++;
+
+ next = next->m_next;
+ }
+ vaList = vaList->m_next;
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+static void getColorRGB3(aiColor3D *pColor, DataArrayList *colList) {
+ if (nullptr == pColor || nullptr == colList) {
+ return;
+ }
+
+ ai_assert(3 == colList->m_numItems);
+ Value *val(colList->m_dataList);
+ pColor->r = val->getFloat();
+ val = val->getNext();
+ pColor->g = val->getFloat();
+ val = val->getNext();
+ pColor->b = val->getFloat();
+}
+
+//------------------------------------------------------------------------------------------------
+static void getColorRGB4(aiColor4D *pColor, DataArrayList *colList) {
+ if (nullptr == pColor || nullptr == colList) {
+ return;
+ }
+
+ ai_assert(4 == colList->m_numItems);
+ Value *val(colList->m_dataList);
+ pColor->r = val->getFloat();
+ val = val->getNext();
+ pColor->g = val->getFloat();
+ val = val->getNext();
+ pColor->b = val->getFloat();
+ val = val->getNext();
+ pColor->a = val->getFloat();
+}
+
+//------------------------------------------------------------------------------------------------
+enum ColorType {
+ NoneColor = 0,
+ DiffuseColor,
+ SpecularColor,
+ EmissionColor,
+ LightColor
+};
+
+//------------------------------------------------------------------------------------------------
+static ColorType getColorType(Text *id) {
+ if (nullptr == id) {
+ return NoneColor;
+ }
+
+ if (*id == Grammar::DiffuseColorToken) {
+ return DiffuseColor;
+ } else if (*id == Grammar::SpecularColorToken) {
+ return SpecularColor;
+ } else if (*id == Grammar::EmissionColorToken) {
+ return EmissionColor;
+ } else if (*id == "light") {
+ return LightColor;
+ }
+
+ return NoneColor;
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMaterialNode(ODDLParser::DDLNode *node, aiScene *pScene) {
+ m_currentMaterial = new aiMaterial;
+ m_materialCache.push_back(m_currentMaterial);
+ m_tokenType = Grammar::MaterialToken;
+ handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleColorNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node) {
+ return;
+ }
+
+ Property *prop = node->findPropertyByName("attrib");
+ if (nullptr != prop) {
+ if (nullptr != prop->m_value) {
+ DataArrayList *colList(node->getDataArrayList());
+ if (nullptr == colList) {
+ return;
+ }
+ aiColor3D col;
+ if (3 == colList->m_numItems) {
+ aiColor3D col3;
+ getColorRGB3(&col3, colList);
+ col = col3;
+ } else {
+ aiColor4D col4;
+ getColorRGB4(&col4, colList);
+ col.r = col4.r;
+ col.g = col4.g;
+ col.b = col4.b;
+ }
+#ifdef ASSIMP_USE_HUNTER
+ const ColorType colType(getColorType(&prop->m_key->m_text));
+#else
+ const ColorType colType(getColorType(prop->m_key));
+#endif
+ if (DiffuseColor == colType) {
+ m_currentMaterial->AddProperty(&col, 1, AI_MATKEY_COLOR_DIFFUSE);
+ } else if (SpecularColor == colType) {
+ m_currentMaterial->AddProperty(&col, 1, AI_MATKEY_COLOR_SPECULAR);
+ } else if (EmissionColor == colType) {
+ m_currentMaterial->AddProperty(&col, 1, AI_MATKEY_COLOR_EMISSIVE);
+ } else if (LightColor == colType) {
+ m_currentLight->mColorDiffuse = col;
+ }
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleTextureNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node) {
+ return;
+ }
+
+ Property *prop = node->findPropertyByName("attrib");
+ if (nullptr != prop) {
+ if (nullptr != prop->m_value) {
+ Value *val(node->getValue());
+ if (nullptr != val) {
+ aiString tex;
+ tex.Set(val->getString());
+ if (prop->m_value->getString() == Grammar::DiffuseTextureToken) {
+ m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_DIFFUSE(0));
+ } else if (prop->m_value->getString() == Grammar::DiffuseSpecularTextureToken) {
+ m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_SPECULAR(0));
+ } else if (prop->m_value->getString() == Grammar::SpecularPowerTextureToken) {
+ m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_SPECULAR(0));
+ } else if (prop->m_value->getString() == Grammar::EmissionTextureToken) {
+ m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_EMISSIVE(0));
+ } else if (prop->m_value->getString() == Grammar::OpacyTextureToken) {
+ m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_OPACITY(0));
+ } else if (prop->m_value->getString() == Grammar::TransparencyTextureToken) {
+ // ToDo!
+ // m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
+ } else if (prop->m_value->getString() == Grammar::NormalTextureToken) {
+ m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_NORMALS(0));
+ } else {
+ ai_assert(false);
+ }
+ }
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleParamNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node) {
+ return;
+ }
+
+ Property *prop = node->findPropertyByName("attrib");
+ if (nullptr == prop) {
+ return;
+ }
+
+ if (nullptr != prop->m_value) {
+ Value *val(node->getValue());
+ if (nullptr == val) {
+ return;
+ }
+ const float floatVal(val->getFloat());
+ if (0 == ASSIMP_strincmp("fov", prop->m_value->getString(), 3)) {
+ m_currentCamera->mHorizontalFOV = floatVal;
+ } else if (0 == ASSIMP_strincmp("near", prop->m_value->getString(), 4)) {
+ m_currentCamera->mClipPlaneNear = floatVal;
+ } else if (0 == ASSIMP_strincmp("far", prop->m_value->getString(), 3)) {
+ m_currentCamera->mClipPlaneFar = floatVal;
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleAttenNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+ if (nullptr == node) {
+ return;
+ }
+
+ Property *prop = node->findPropertyByName("curve");
+ if (nullptr != prop) {
+ if (nullptr != prop->m_value) {
+ Value *val(node->getValue());
+ const float floatVal(val->getFloat());
+ if (0 == strncmp("scale", prop->m_value->getString(), strlen("scale"))) {
+ m_currentLight->mAttenuationQuadratic = floatVal;
+ }
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyMeshes(aiScene *pScene) {
+ ai_assert(nullptr != pScene);
+
+ if (m_meshCache.empty()) {
+ return;
+ }
+
+ pScene->mNumMeshes = static_cast<unsigned int>(m_meshCache.size());
+ pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+ for (unsigned int i = 0; i < pScene->mNumMeshes; i++) {
+ pScene->mMeshes[i] = m_meshCache[i].release();
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyCameras(aiScene *pScene) {
+ ai_assert(nullptr != pScene);
+
+ if (m_cameraCache.empty()) {
+ return;
+ }
+
+ pScene->mNumCameras = static_cast<unsigned int>(m_cameraCache.size());
+ pScene->mCameras = new aiCamera *[pScene->mNumCameras];
+ std::copy(m_cameraCache.begin(), m_cameraCache.end(), pScene->mCameras);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyLights(aiScene *pScene) {
+ ai_assert(nullptr != pScene);
+
+ if (m_lightCache.empty()) {
+ return;
+ }
+
+ pScene->mNumLights = static_cast<unsigned int>(m_lightCache.size());
+ pScene->mLights = new aiLight *[pScene->mNumLights];
+ std::copy(m_lightCache.begin(), m_lightCache.end(), pScene->mLights);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyMaterials(aiScene *pScene) {
+ ai_assert(nullptr != pScene);
+
+ if (m_materialCache.empty()) {
+ return;
+ }
+
+ pScene->mNumMaterials = static_cast<unsigned int>(m_materialCache.size());
+ pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+ std::copy(m_materialCache.begin(), m_materialCache.end(), pScene->mMaterials);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::resolveReferences() {
+ if (m_unresolvedRefStack.empty()) {
+ return;
+ }
+
+ RefInfo *currentRefInfo(nullptr);
+ for (auto it = m_unresolvedRefStack.begin(); it != m_unresolvedRefStack.end(); ++it) {
+ currentRefInfo = it->get();
+ if (nullptr != currentRefInfo) {
+ aiNode *node(currentRefInfo->m_node);
+ if (RefInfo::MeshRef == currentRefInfo->m_type) {
+ for (size_t i = 0; i < currentRefInfo->m_Names.size(); ++i) {
+ const std::string &name(currentRefInfo->m_Names[i]);
+ ReferenceMap::const_iterator curIt(m_mesh2refMap.find(name));
+ if (m_mesh2refMap.end() != curIt) {
+ unsigned int meshIdx = static_cast<unsigned int>(m_mesh2refMap[name]);
+ node->mMeshes[i] = meshIdx;
+ }
+ }
+ } else if (RefInfo::MaterialRef == currentRefInfo->m_type) {
+ for (size_t i = 0; i < currentRefInfo->m_Names.size(); ++i) {
+ const std::string name(currentRefInfo->m_Names[i]);
+ ReferenceMap::const_iterator curIt(m_material2refMap.find(name));
+ if (m_material2refMap.end() != curIt) {
+ if (nullptr != m_currentMesh) {
+ unsigned int matIdx = static_cast<unsigned int>(m_material2refMap[name]);
+ if (m_currentMesh->mMaterialIndex != 0) {
+ ASSIMP_LOG_WARN("Override of material reference in current mesh by material reference.");
+ }
+ m_currentMesh->mMaterialIndex = matIdx;
+ } else {
+ ASSIMP_LOG_WARN("Cannot resolve material reference, because no current mesh is there.");
+ }
+ }
+ }
+ } else {
+ throw DeadlyImportError("Unknown reference info to resolve.");
+ }
+ }
+ }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::createNodeTree(aiScene *pScene) {
+ if (nullptr == m_root) {
+ return;
+ }
+
+ if (m_root->m_children.empty()) {
+ return;
+ }
+
+ pScene->mRootNode->mNumChildren = static_cast<unsigned int>(m_root->m_children.size());
+ pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+ std::copy(m_root->m_children.begin(), m_root->m_children.end(), pScene->mRootNode->mChildren);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::pushNode(aiNode *node, aiScene *pScene) {
+ ai_assert(nullptr != pScene);
+
+ if (nullptr == node) {
+ return;
+ }
+
+ ChildInfo *info(nullptr);
+ if (m_nodeStack.empty()) {
+ node->mParent = pScene->mRootNode;
+ NodeChildMap::iterator it(m_nodeChildMap.find(node->mParent));
+ if (m_nodeChildMap.end() == it) {
+ info = new ChildInfo;
+ m_root = info;
+ m_nodeChildMap[node->mParent] = std::unique_ptr<ChildInfo>(info);
+ } else {
+ info = it->second.get();
+ }
+ info->m_children.push_back(node);
+ } else {
+ aiNode *parent(m_nodeStack.back());
+ ai_assert(nullptr != parent);
+ node->mParent = parent;
+ NodeChildMap::iterator it(m_nodeChildMap.find(node->mParent));
+ if (m_nodeChildMap.end() == it) {
+ info = new ChildInfo;
+ m_nodeChildMap[node->mParent] = std::unique_ptr<ChildInfo>(info);
+ } else {
+ info = it->second.get();
+ }
+ info->m_children.push_back(node);
+ }
+ m_nodeStack.push_back(node);
+}
+
+//------------------------------------------------------------------------------------------------
+aiNode *OpenGEXImporter::popNode() {
+ if (m_nodeStack.empty()) {
+ return nullptr;
+ }
+
+ aiNode *node(top());
+ m_nodeStack.pop_back();
+
+ return node;
+}
+
+//------------------------------------------------------------------------------------------------
+aiNode *OpenGEXImporter::top() const {
+ if (m_nodeStack.empty()) {
+ return nullptr;
+ }
+
+ return m_nodeStack.back();
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::clearNodeStack() {
+ m_nodeStack.clear();
+}
+
+//------------------------------------------------------------------------------------------------
+
+} // Namespace OpenGEX
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_OPENGEX_IMPORTER
diff --git a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h
new file mode 100644
index 0000000..fca3eb1
--- /dev/null
+++ b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h
@@ -0,0 +1,213 @@
+/*
+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 AI_OPENGEX_IMPORTER_H
+#define AI_OPENGEX_IMPORTER_H
+
+#ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
+
+#include <assimp/BaseImporter.h>
+#include <assimp/mesh.h>
+
+#include <vector>
+#include <list>
+#include <map>
+#include <memory>
+
+namespace ODDLParser {
+ class DDLNode;
+ struct Context;
+}
+
+struct aiNode;
+struct aiMaterial;
+struct aiCamera;
+struct aiLight;
+
+namespace Assimp {
+namespace OpenGEX {
+
+struct MetricInfo {
+ enum Type {
+ Distance = 0,
+ Angle,
+ Time,
+ Up,
+ Max
+ };
+
+ std::string m_stringValue;
+ float m_floatValue;
+ int m_intValue;
+
+ MetricInfo()
+ : m_stringValue( )
+ , m_floatValue( 0.0f )
+ , m_intValue( -1 ) {
+ // empty
+ }
+};
+
+/** @brief This class is used to implement the OpenGEX importer
+ *
+ * See http://opengex.org/OpenGEX.pdf for spec.
+ */
+class OpenGEXImporter : public BaseImporter {
+public:
+ /// The class constructor.
+ OpenGEXImporter();
+
+ /// The class destructor.
+ ~OpenGEXImporter() override;
+
+ /// BaseImporter override.
+ bool CanRead( const std::string &file, IOSystem *pIOHandler, bool checkSig ) const override;
+
+protected:
+ /// BaseImporter override.
+ void InternReadFile( const std::string &file, aiScene *pScene, IOSystem *pIOHandler ) override;
+
+ /// BaseImporter override.
+ virtual const aiImporterDesc *GetInfo() const override;
+
+ /// BaseImporter override.
+ virtual void SetupProperties( const Importer *pImp ) override;
+
+ void handleNodes( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleMetricNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleNameNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleObjectRefNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleMaterialRefNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleGeometryNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleCameraNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleLightNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleGeometryObject( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleCameraObject( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleLightObject( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleTransformNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleMeshNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleVertexArrayNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleMaterialNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleColorNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleTextureNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleParamNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void handleAttenNode( ODDLParser::DDLNode *node, aiScene *pScene );
+ void copyMeshes( aiScene *pScene );
+ void copyCameras( aiScene *pScene );
+ void copyLights( aiScene *pScene );
+ void copyMaterials( aiScene *pScene );
+ void resolveReferences();
+ void pushNode( aiNode *node, aiScene *pScene );
+ aiNode *popNode();
+ aiNode *top() const;
+ void clearNodeStack();
+ void createNodeTree( aiScene *pScene );
+
+private:
+ struct VertexContainer {
+ std::vector<aiVector3D> m_vertices;
+ size_t m_numColors;
+ aiColor4D *m_colors;
+ std::vector<aiVector3D> m_normals;
+ size_t m_numUVComps[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+ aiVector3D *m_textureCoords[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+
+ VertexContainer();
+ ~VertexContainer();
+
+ VertexContainer( const VertexContainer & ) = delete;
+ VertexContainer &operator = ( const VertexContainer & ) = delete;
+ };
+
+ struct RefInfo {
+ enum Type {
+ MeshRef,
+ MaterialRef
+ };
+
+ aiNode *m_node;
+ Type m_type;
+ std::vector<std::string> m_Names;
+
+ RefInfo( aiNode *node, Type type, std::vector<std::string> &names );
+ ~RefInfo();
+
+ RefInfo( const RefInfo & ) = delete;
+ RefInfo &operator = ( const RefInfo & ) = delete;
+ };
+
+ struct ChildInfo {
+ using NodeList = std::list<aiNode*>;
+ std::list<aiNode*> m_children;
+ };
+ ChildInfo *m_root;
+ using NodeChildMap = std::map<aiNode*, std::unique_ptr<ChildInfo> >;
+ NodeChildMap m_nodeChildMap;
+
+ std::vector<std::unique_ptr<aiMesh> > m_meshCache;
+ using ReferenceMap = std::map<std::string, size_t>;
+ std::map<std::string, size_t> m_mesh2refMap;
+ std::map<std::string, size_t> m_material2refMap;
+
+ ODDLParser::Context *m_ctx;
+ MetricInfo m_metrics[ MetricInfo::Max ];
+ aiNode *m_currentNode;
+ VertexContainer m_currentVertices;
+ aiMesh *m_currentMesh; // not owned, target is owned by m_meshCache
+ aiMaterial *m_currentMaterial;
+ aiLight *m_currentLight;
+ aiCamera *m_currentCamera;
+ int m_tokenType;
+ std::vector<aiMaterial*> m_materialCache;
+ std::vector<aiCamera*> m_cameraCache;
+ std::vector<aiLight*> m_lightCache;
+ std::vector<aiNode*> m_nodeStack;
+ std::vector<std::unique_ptr<RefInfo> > m_unresolvedRefStack;
+};
+
+} // Namespace OpenGEX
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_OPENGEX_IMPORTER
+
+#endif // AI_OPENGEX_IMPORTER_H
diff --git a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h
new file mode 100644
index 0000000..5f84548
--- /dev/null
+++ b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h
@@ -0,0 +1,264 @@
+/*
+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_OPENGEXSTRUCTS_H_INC
+#define AI_OPENGEXSTRUCTS_H_INC
+
+#include <string>
+#include <map>
+
+namespace Assimp {
+namespace OpenGEX {
+
+struct Skin;
+struct Object;
+struct LightObject;
+struct CameraObject;
+struct Material;
+struct BoneNode;
+struct BoneCountArray;
+struct BoneIndexArray;
+struct BoneWeightArray;
+
+struct Metric {
+ float m_distance;
+ float m_angle;
+ float m_time;
+ float m_up;
+};
+
+struct VertexArray {
+ std::string arrayAttrib;
+ unsigned int morphIndex;
+};
+
+struct IndexArray {
+ unsigned int materialIndex;
+ unsigned int restartIndex;
+ std::string frontFace;
+};
+
+struct Mesh {
+ unsigned int meshLevel;
+ std::string meshPrimitive;
+ Skin *skinStructure;
+};
+
+struct Node {
+ std::string nodeName;
+};
+
+struct GeometryNode {
+ bool visibleFlag[ 2 ];
+ bool shadowFlag[ 2 ];
+ bool motionBlurFlag[ 2 ];
+};
+
+struct LightNode {
+ bool shadowFlag[ 2 ];
+ const LightObject *lightObjectStructure;
+};
+
+struct CameraNode {
+ const CameraObject *cameraObjectStructure;
+};
+
+struct GeometryObject {
+ Object *object;
+ bool visibleFlag;
+ bool shadowFlag;
+ bool motionBlurFlag;
+ std::map<std::string, Mesh*> meshMap;
+};
+
+struct LightObject {
+ Object *object;
+ std::string typeString;
+ bool shadowFlag;
+};
+
+struct CameraObject {
+ float focalLength;
+ float nearDepth;
+ float farDepth;
+};
+
+struct Matrix {
+ bool objectFlag;
+};
+
+struct Transform {
+ Matrix *matrix;
+ int transformCount;
+ const float *transformArray;
+};
+
+struct Translation {
+ std::string translationKind;
+};
+
+struct Rotation {
+ std::string rotationKind;
+};
+
+struct Scale {
+ std::string scaleKind;
+};
+
+struct Name {
+ std::string name;
+};
+
+struct ObjectRef {
+ Object *targetStructure;
+};
+
+struct MaterialRef {
+ unsigned int materialIndex;
+ const Material *targetStructure;
+};
+
+struct BoneRefArray {
+ int boneCount;
+ const BoneNode **boneNodeArray;
+};
+
+struct BoneCount {
+ int vertexCount;
+ const unsigned short *boneCountArray;
+ unsigned short *arrayStorage;
+};
+
+struct BoneIndex {
+ int boneIndexCount;
+ const unsigned short *boneIndexArray;
+ unsigned short *arrayStorage;
+};
+
+struct BoneWeight {
+ int boneWeightCount;
+ const float *boneWeightArray;
+};
+
+struct Skeleton {
+ const BoneRefArray *boneRefArrayStructure;
+ const Transform *transformStructure;
+};
+
+struct Skin {
+ const Skeleton *skeletonStructure;
+ const BoneCountArray *boneCountArrayStructure;
+ const BoneIndexArray *boneIndexArrayStructure;
+ const BoneWeightArray *boneWeightArrayStructure;
+};
+
+struct Material {
+ bool twoSidedFlag;
+ const char *materialName;
+};
+
+struct Attrib {
+ std::string attribString;
+};
+
+struct Param {
+ float param;
+};
+
+struct Color {
+ float color[ 4 ];
+};
+
+struct Texture {
+ std::string textureName;
+ unsigned int texcoordIndex;
+};
+
+struct Atten {
+ std::string attenKind;
+ std::string curveType;
+
+ float beginParam;
+ float endParam;
+
+ float scaleParam;
+ float offsetParam;
+
+ float constantParam;
+ float linearParam;
+ float quadraticParam;
+
+ float powerParam;
+};
+
+struct Key {
+ std::string keyKind;
+ bool scalarFlag;
+};
+
+struct Curve {
+ std::string curveType;
+ const Key *keyValueStructure;
+ const Key *keyControlStructure[ 2 ];
+ const Key *keyTensionStructure;
+ const Key *keyContinuityStructure;
+ const Key *keyBiasStructure;
+};
+
+struct Animation {
+ int clipIndex;
+ bool beginFlag;
+ bool endFlag;
+ float beginTime;
+ float endTime;
+};
+
+struct OpenGexDataDescription {
+ float distanceScale;
+ float angleScale;
+ float timeScale;
+ int upDirection;
+};
+
+} // Namespace OpenGEX
+} // Namespace Assimp
+
+#endif // AI_OPENGEXSTRUCTS_H_INC
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-24 12:43:13 +0000