move 3rd-party librarys into libs/ and add built-in honeysuckle

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