switch to tinyobj and nanovg from assimp and cairo

5 files changed, 0 insertions, 1933 deletions

diff --git a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp b/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
deleted file mode 100644
index 328c3c4..0000000
--- a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-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
deleted file mode 100644
index cc22c7d..0000000
--- a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-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
deleted file mode 100644
index c8e4793..0000000
--- a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
+++ /dev/null
@@ -1,1326 +0,0 @@
-/*
-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
deleted file mode 100644
index fca3eb1..0000000
--- a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
-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
deleted file mode 100644
index 5f84548..0000000
--- a/libs/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
-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