switch to tinyobj and nanovg from assimp and cairo

49 files changed, 0 insertions, 13826 deletions

diff --git a/libs/assimp/code/Common/AssertHandler.cpp b/libs/assimp/code/Common/AssertHandler.cpp
deleted file mode 100644
index d0bd6cc..0000000
--- a/libs/assimp/code/Common/AssertHandler.cpp
+++ /dev/null
@@ -1,72 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file  AssertHandler.cpp
- *  @brief Implementation of assert handling logic.
- */
-
-#include "AssertHandler.h"
-
-#include <iostream>
-#include <cstdlib>
-
-void Assimp::defaultAiAssertHandler(const char* failedExpression, const char* file, int line)
-{
-    std::cerr << "ai_assert failure in " << file << "(" << line << "): " << failedExpression << std::endl;
-    std::abort();
-}
-
-namespace
-{
-    Assimp::AiAssertHandler s_handler = Assimp::defaultAiAssertHandler;
-}
-
-void Assimp::setAiAssertHandler(AiAssertHandler handler)
-{
-    s_handler = handler;
-}
-
-void Assimp::aiAssertViolation(const char* failedExpression, const char* file, int line)
-{
-    s_handler(failedExpression, file, line);
-}
diff --git a/libs/assimp/code/Common/AssertHandler.h b/libs/assimp/code/Common/AssertHandler.h
deleted file mode 100644
index 2515f0b..0000000
--- a/libs/assimp/code/Common/AssertHandler.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Provides facilities to replace the default assert handler. */
-
-#ifndef INCLUDED_AI_ASSERTHANDLER_H
-#define INCLUDED_AI_ASSERTHANDLER_H
-
-#include <assimp/ai_assert.h>
-#include <assimp/defs.h>
-
-namespace Assimp
-{
-    // ---------------------------------------------------------------------------
-    /** Signature of functions which handle assert violations.
-     */
-    using AiAssertHandler = void (*)(const char* failedExpression, const char* file, int line);
-
-    // ---------------------------------------------------------------------------
-    /** Set the assert handler.
-     */
-    ASSIMP_API void setAiAssertHandler(AiAssertHandler handler);
-
-    // ---------------------------------------------------------------------------
-    /** The assert handler which is set by default.
-     *
-     * This issues a message to stderr and calls abort.
-     */
-    ASSIMP_API void defaultAiAssertHandler(const char* failedExpression, const char* file, int line);
-
-    // ---------------------------------------------------------------------------
-    /** Dispatches an assert violation to the assert handler.
-     */
-    ASSIMP_API void aiAssertViolation(const char* failedExpression, const char* file, int line);
-} // end of namespace Assimp
-
-#endif // INCLUDED_AI_ASSERTHANDLER_H
\ No newline at end of file
diff --git a/libs/assimp/code/Common/Assimp.cpp b/libs/assimp/code/Common/Assimp.cpp
deleted file mode 100644
index 71e312c..0000000
--- a/libs/assimp/code/Common/Assimp.cpp
+++ /dev/null
@@ -1,1299 +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.
----------------------------------------------------------------------------
-*/
-/** @file  Assimp.cpp
- *  @brief Implementation of the Plain-C API
- */
-
-#include <assimp/BaseImporter.h>
-#include <assimp/Exceptional.h>
-#include <assimp/GenericProperty.h>
-#include <assimp/cimport.h>
-#include <assimp/importerdesc.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Importer.hpp>
-#include <assimp/LogStream.hpp>
-
-#include "CApi/CInterfaceIOWrapper.h"
-#include "Importer.h"
-#include "ScenePrivate.h"
-
-#include <list>
-
-// ------------------------------------------------------------------------------------------------
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-#include <mutex>
-#include <thread>
-#endif
-// ------------------------------------------------------------------------------------------------
-using namespace Assimp;
-
-namespace Assimp {
-// underlying structure for aiPropertyStore
-typedef BatchLoader::PropertyMap PropertyMap;
-
-#if defined(__has_warning)
-#if __has_warning("-Wordered-compare-function-pointers")
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wordered-compare-function-pointers"
-#endif
-#endif
-
-/** Stores the LogStream objects for all active C log streams */
-struct mpred {
-    bool operator()(const aiLogStream &s0, const aiLogStream &s1) const {
-        return s0.callback < s1.callback && s0.user < s1.user;
-    }
-};
-
-#if defined(__has_warning)
-#if __has_warning("-Wordered-compare-function-pointers")
-#pragma GCC diagnostic pop
-#endif
-#endif
-typedef std::map<aiLogStream, Assimp::LogStream *, mpred> LogStreamMap;
-
-/** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */
-typedef std::list<Assimp::LogStream *> PredefLogStreamMap;
-
-/** Local storage of all active log streams */
-static LogStreamMap gActiveLogStreams;
-
-/** Local storage of LogStreams allocated by #aiGetPredefinedLogStream */
-static PredefLogStreamMap gPredefinedStreams;
-
-/** Error message of the last failed import process */
-static std::string gLastErrorString;
-
-/** Verbose logging active or not? */
-static aiBool gVerboseLogging = false;
-
-/** will return all registered importers. */
-void GetImporterInstanceList(std::vector<BaseImporter *> &out);
-
-/** will delete all registered importers. */
-void DeleteImporterInstanceList(std::vector<BaseImporter *> &out);
-} // namespace Assimp
-
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-/** Global mutex to manage the access to the log-stream map */
-static std::mutex gLogStreamMutex;
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Custom LogStream implementation for the C-API
-class LogToCallbackRedirector : public LogStream {
-public:
-    explicit LogToCallbackRedirector(const aiLogStream &s) :
-            stream(s) {
-        ai_assert(nullptr != s.callback);
-    }
-
-    ~LogToCallbackRedirector() {
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-        std::lock_guard<std::mutex> lock(gLogStreamMutex);
-#endif
-        // (HACK) Check whether the 'stream.user' pointer points to a
-        // custom LogStream allocated by #aiGetPredefinedLogStream.
-        // In this case, we need to delete it, too. Of course, this
-        // might cause strange problems, but the chance is quite low.
-
-        PredefLogStreamMap::iterator it = std::find(gPredefinedStreams.begin(),
-                gPredefinedStreams.end(), (Assimp::LogStream *)stream.user);
-
-        if (it != gPredefinedStreams.end()) {
-            delete *it;
-            gPredefinedStreams.erase(it);
-        }
-    }
-
-    /** @copydoc LogStream::write */
-    void write(const char *message) {
-        stream.callback(message, stream.user);
-    }
-
-private:
-    aiLogStream stream;
-};
-
-// ------------------------------------------------------------------------------------------------
-void ReportSceneNotFoundError() {
-    ASSIMP_LOG_ERROR("Unable to find the Assimp::Importer for this aiScene. "
-                     "The C-API does not accept scenes produced by the C++ API and vice versa");
-
-    ai_assert(false);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the given file and returns its content.
-const aiScene *aiImportFile(const char *pFile, unsigned int pFlags) {
-    return aiImportFileEx(pFile, pFlags, nullptr);
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiScene *aiImportFileEx(const char *pFile, unsigned int pFlags, aiFileIO *pFS) {
-    return aiImportFileExWithProperties(pFile, pFlags, pFS, nullptr);
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiScene *aiImportFileExWithProperties(const char *pFile, unsigned int pFlags,
-        aiFileIO *pFS, const aiPropertyStore *props) {
-    ai_assert(nullptr != pFile);
-
-    const aiScene *scene = nullptr;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // create an Importer for this file
-    Assimp::Importer *imp = new Assimp::Importer();
-
-    // copy properties
-    if (props) {
-        const PropertyMap *pp = reinterpret_cast<const PropertyMap *>(props);
-        ImporterPimpl *pimpl = imp->Pimpl();
-        pimpl->mIntProperties = pp->ints;
-        pimpl->mFloatProperties = pp->floats;
-        pimpl->mStringProperties = pp->strings;
-        pimpl->mMatrixProperties = pp->matrices;
-    }
-    // setup a custom IO system if necessary
-    if (pFS) {
-        imp->SetIOHandler(new CIOSystemWrapper(pFS));
-    }
-
-    // and have it read the file
-    scene = imp->ReadFile(pFile, pFlags);
-
-    // if succeeded, store the importer in the scene and keep it alive
-    if (scene) {
-        ScenePrivateData *priv = const_cast<ScenePrivateData *>(ScenePriv(scene));
-        priv->mOrigImporter = imp;
-    } else {
-        // if failed, extract error code and destroy the import
-        gLastErrorString = imp->GetErrorString();
-        delete imp;
-    }
-
-    // return imported data. If the import failed the pointer is nullptr anyways
-    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
-
-    return scene;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiScene *aiImportFileFromMemory(
-        const char *pBuffer,
-        unsigned int pLength,
-        unsigned int pFlags,
-        const char *pHint) {
-    return aiImportFileFromMemoryWithProperties(pBuffer, pLength, pFlags, pHint, nullptr);
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiScene *aiImportFileFromMemoryWithProperties(
-        const char *pBuffer,
-        unsigned int pLength,
-        unsigned int pFlags,
-        const char *pHint,
-        const aiPropertyStore *props) {
-    ai_assert(nullptr != pBuffer);
-    ai_assert(0 != pLength);
-
-    const aiScene *scene = nullptr;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // create an Importer for this file
-    Assimp::Importer *imp = new Assimp::Importer();
-
-    // copy properties
-    if (props) {
-        const PropertyMap *pp = reinterpret_cast<const PropertyMap *>(props);
-        ImporterPimpl *pimpl = imp->Pimpl();
-        pimpl->mIntProperties = pp->ints;
-        pimpl->mFloatProperties = pp->floats;
-        pimpl->mStringProperties = pp->strings;
-        pimpl->mMatrixProperties = pp->matrices;
-    }
-
-    // and have it read the file from the memory buffer
-    scene = imp->ReadFileFromMemory(pBuffer, pLength, pFlags, pHint);
-
-    // if succeeded, store the importer in the scene and keep it alive
-    if (scene) {
-        ScenePrivateData *priv = const_cast<ScenePrivateData *>(ScenePriv(scene));
-        priv->mOrigImporter = imp;
-    } else {
-        // if failed, extract error code and destroy the import
-        gLastErrorString = imp->GetErrorString();
-        delete imp;
-    }
-    // return imported data. If the import failed the pointer is nullptr anyways
-    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
-    return scene;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Releases all resources associated with the given import process.
-void aiReleaseImport(const aiScene *pScene) {
-    if (!pScene) {
-        return;
-    }
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // find the importer associated with this data
-    const ScenePrivateData *priv = ScenePriv(pScene);
-    if (!priv || !priv->mOrigImporter) {
-        delete pScene;
-    } else {
-        // deleting the Importer also deletes the scene
-        // Note: the reason that this is not written as 'delete priv->mOrigImporter'
-        // is a suspected bug in gcc 4.4+ (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52339)
-        Importer *importer = priv->mOrigImporter;
-        delete importer;
-    }
-
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API const aiScene *aiApplyPostProcessing(const aiScene *pScene,
-        unsigned int pFlags) {
-    const aiScene *sc = nullptr;
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // find the importer associated with this data
-    const ScenePrivateData *priv = ScenePriv(pScene);
-    if (!priv || !priv->mOrigImporter) {
-        ReportSceneNotFoundError();
-        return nullptr;
-    }
-
-    sc = priv->mOrigImporter->ApplyPostProcessing(pFlags);
-
-    if (!sc) {
-        aiReleaseImport(pScene);
-        return nullptr;
-    }
-
-    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
-    return sc;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing(const aiScene *scene,
-        BaseProcess *process,
-        bool requestValidation) {
-    const aiScene *sc(nullptr);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // find the importer associated with this data
-    const ScenePrivateData *priv = ScenePriv(scene);
-    if (nullptr == priv || nullptr == priv->mOrigImporter) {
-        ReportSceneNotFoundError();
-        return nullptr;
-    }
-
-    sc = priv->mOrigImporter->ApplyCustomizedPostProcessing(process, requestValidation);
-
-    if (!sc) {
-        aiReleaseImport(scene);
-        return nullptr;
-    }
-
-    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
-
-    return sc;
-}
-
-// ------------------------------------------------------------------------------------------------
-void CallbackToLogRedirector(const char *msg, char *dt) {
-    ai_assert(nullptr != msg);
-    ai_assert(nullptr != dt);
-    LogStream *s = (LogStream *)dt;
-
-    s->write(msg);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) {
-    aiLogStream sout;
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    LogStream *stream = LogStream::createDefaultStream(pStream, file);
-    if (!stream) {
-        sout.callback = nullptr;
-        sout.user = nullptr;
-    } else {
-        sout.callback = &CallbackToLogRedirector;
-        sout.user = (char *)stream;
-    }
-    gPredefinedStreams.push_back(stream);
-    ASSIMP_END_EXCEPTION_REGION(aiLogStream);
-    return sout;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiAttachLogStream(const aiLogStream *stream) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-    std::lock_guard<std::mutex> lock(gLogStreamMutex);
-#endif
-
-    LogStream *lg = new LogToCallbackRedirector(*stream);
-    gActiveLogStreams[*stream] = lg;
-
-    if (DefaultLogger::isNullLogger()) {
-        DefaultLogger::create(nullptr, (gVerboseLogging == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL));
-    }
-    DefaultLogger::get()->attachStream(lg);
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API aiReturn aiDetachLogStream(const aiLogStream *stream) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-    std::lock_guard<std::mutex> lock(gLogStreamMutex);
-#endif
-    // find the log-stream associated with this data
-    LogStreamMap::iterator it = gActiveLogStreams.find(*stream);
-    // it should be there... else the user is playing fools with us
-    if (it == gActiveLogStreams.end()) {
-        return AI_FAILURE;
-    }
-    DefaultLogger::get()->detachStream(it->second);
-    delete it->second;
-
-    gActiveLogStreams.erase(it);
-
-    if (gActiveLogStreams.empty()) {
-        DefaultLogger::kill();
-    }
-    ASSIMP_END_EXCEPTION_REGION(aiReturn);
-    return AI_SUCCESS;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiDetachAllLogStreams(void) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-    std::lock_guard<std::mutex> lock(gLogStreamMutex);
-#endif
-    Logger *logger(DefaultLogger::get());
-    if (nullptr == logger) {
-        return;
-    }
-
-    for (LogStreamMap::iterator it = gActiveLogStreams.begin(); it != gActiveLogStreams.end(); ++it) {
-        logger->detachStream(it->second);
-        delete it->second;
-    }
-    gActiveLogStreams.clear();
-    DefaultLogger::kill();
-
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiEnableVerboseLogging(aiBool d) {
-    if (!DefaultLogger::isNullLogger()) {
-        DefaultLogger::get()->setLogSeverity((d == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL));
-    }
-    gVerboseLogging = d;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns the error text of the last failed import process.
-const char *aiGetErrorString() {
-    return gLastErrorString.c_str();
-}
-
-// -----------------------------------------------------------------------------------------------
-// Return the description of a importer given its index
-const aiImporterDesc *aiGetImportFormatDescription(size_t pIndex) {
-    return Importer().GetImporterInfo(pIndex);
-}
-
-// -----------------------------------------------------------------------------------------------
-// Return the number of importers
-size_t aiGetImportFormatCount(void) {
-    return Importer().GetImporterCount();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns the error text of the last failed import process.
-aiBool aiIsExtensionSupported(const char *szExtension) {
-    ai_assert(nullptr != szExtension);
-    aiBool candoit = AI_FALSE;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // FIXME: no need to create a temporary Importer instance just for that ..
-    Assimp::Importer tmp;
-    candoit = tmp.IsExtensionSupported(std::string(szExtension)) ? AI_TRUE : AI_FALSE;
-
-    ASSIMP_END_EXCEPTION_REGION(aiBool);
-    return candoit;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a list of all file extensions supported by ASSIMP
-void aiGetExtensionList(aiString *szOut) {
-    ai_assert(nullptr != szOut);
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // FIXME: no need to create a temporary Importer instance just for that ..
-    Assimp::Importer tmp;
-    tmp.GetExtensionList(*szOut);
-
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the memory requirements for a particular import.
-void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn,
-        C_STRUCT aiMemoryInfo *in) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // find the importer associated with this data
-    const ScenePrivateData *priv = ScenePriv(pIn);
-    if (!priv || !priv->mOrigImporter) {
-        ReportSceneNotFoundError();
-        return;
-    }
-
-    return priv->mOrigImporter->GetMemoryRequirements(*in);
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) {
-    return reinterpret_cast<aiPropertyStore *>(new PropertyMap());
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiReleasePropertyStore(aiPropertyStore *p) {
-    delete reinterpret_cast<PropertyMap *>(p);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Importer::SetPropertyInteger
-ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore *p, const char *szName, int value) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
-    SetGenericProperty<int>(pp->ints, szName, value);
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Importer::SetPropertyFloat
-ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore *p, const char *szName, ai_real value) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
-    SetGenericProperty<ai_real>(pp->floats, szName, value);
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Importer::SetPropertyString
-ASSIMP_API void aiSetImportPropertyString(aiPropertyStore *p, const char *szName,
-        const C_STRUCT aiString *st) {
-    if (!st) {
-        return;
-    }
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
-    SetGenericProperty<std::string>(pp->strings, szName, std::string(st->C_Str()));
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Importer::SetPropertyMatrix
-ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore *p, const char *szName,
-        const C_STRUCT aiMatrix4x4 *mat) {
-    if (!mat) {
-        return;
-    }
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
-    SetGenericProperty<aiMatrix4x4>(pp->matrices, szName, *mat);
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Rotation matrix to quaternion
-ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion *quat, const aiMatrix3x3 *mat) {
-    ai_assert(nullptr != quat);
-    ai_assert(nullptr != mat);
-    *quat = aiQuaternion(*mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Matrix decomposition
-ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4 *mat, aiVector3D *scaling,
-        aiQuaternion *rotation,
-        aiVector3D *position) {
-    ai_assert(nullptr != rotation);
-    ai_assert(nullptr != position);
-    ai_assert(nullptr != scaling);
-    ai_assert(nullptr != mat);
-    mat->Decompose(*scaling, *rotation, *position);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Matrix transpose
-ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3 *mat) {
-    ai_assert(nullptr != mat);
-    mat->Transpose();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4 *mat) {
-    ai_assert(nullptr != mat);
-    mat->Transpose();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Vector transformation
-ASSIMP_API void aiTransformVecByMatrix3(aiVector3D *vec,
-        const aiMatrix3x3 *mat) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != vec);
-    *vec *= (*mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiTransformVecByMatrix4(aiVector3D *vec,
-        const aiMatrix4x4 *mat) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != vec);
-
-    *vec *= (*mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Matrix multiplication
-ASSIMP_API void aiMultiplyMatrix4(
-        aiMatrix4x4 *dst,
-        const aiMatrix4x4 *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = (*dst) * (*src);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMultiplyMatrix3(
-        aiMatrix3x3 *dst,
-        const aiMatrix3x3 *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = (*dst) * (*src);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Matrix identity
-ASSIMP_API void aiIdentityMatrix3(
-        aiMatrix3x3 *mat) {
-    ai_assert(nullptr != mat);
-    *mat = aiMatrix3x3();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiIdentityMatrix4(
-        aiMatrix4x4 *mat) {
-    ai_assert(nullptr != mat);
-    *mat = aiMatrix4x4();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API C_STRUCT const aiImporterDesc *aiGetImporterDesc(const char *extension) {
-    if (nullptr == extension) {
-        return nullptr;
-    }
-    const aiImporterDesc *desc(nullptr);
-    std::vector<BaseImporter *> out;
-    GetImporterInstanceList(out);
-    for (size_t i = 0; i < out.size(); ++i) {
-        if (0 == strncmp(out[i]->GetInfo()->mFileExtensions, extension, strlen(extension))) {
-            desc = out[i]->GetInfo();
-            break;
-        }
-    }
-
-    DeleteImporterInstanceList(out);
-
-    return desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiVector2AreEqual(
-        const C_STRUCT aiVector2D *a,
-        const C_STRUCT aiVector2D *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return *a == *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiVector2AreEqualEpsilon(
-        const C_STRUCT aiVector2D *a,
-        const C_STRUCT aiVector2D *b,
-        const float epsilon) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return a->Equal(*b, epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2Add(
-        C_STRUCT aiVector2D *dst,
-        const C_STRUCT aiVector2D *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = *dst + *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2Subtract(
-        C_STRUCT aiVector2D *dst,
-        const C_STRUCT aiVector2D *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = *dst - *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2Scale(
-        C_STRUCT aiVector2D *dst,
-        const float s) {
-    ai_assert(nullptr != dst);
-    *dst *= s;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2SymMul(
-        C_STRUCT aiVector2D *dst,
-        const C_STRUCT aiVector2D *other) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != other);
-    *dst = dst->SymMul(*other);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2DivideByScalar(
-        C_STRUCT aiVector2D *dst,
-        const float s) {
-    ai_assert(nullptr != dst);
-    *dst /= s;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2DivideByVector(
-        C_STRUCT aiVector2D *dst,
-        C_STRUCT aiVector2D *v) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != v);
-    *dst = *dst / *v;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiVector2Length(
-        const C_STRUCT aiVector2D *v) {
-    ai_assert(nullptr != v);
-    return v->Length();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiVector2SquareLength(
-        const C_STRUCT aiVector2D *v) {
-    ai_assert(nullptr != v);
-    return v->SquareLength();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2Negate(
-        C_STRUCT aiVector2D *dst) {
-    ai_assert(nullptr != dst);
-    *dst = -(*dst);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiVector2DotProduct(
-        const C_STRUCT aiVector2D *a,
-        const C_STRUCT aiVector2D *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return (*a) * (*b);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector2Normalize(
-        C_STRUCT aiVector2D *v) {
-    ai_assert(nullptr != v);
-    v->Normalize();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiVector3AreEqual(
-        const C_STRUCT aiVector3D *a,
-        const C_STRUCT aiVector3D *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return *a == *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiVector3AreEqualEpsilon(
-        const C_STRUCT aiVector3D *a,
-        const C_STRUCT aiVector3D *b,
-        const float epsilon) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return a->Equal(*b, epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiVector3LessThan(
-        const C_STRUCT aiVector3D *a,
-        const C_STRUCT aiVector3D *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return *a < *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3Add(
-        C_STRUCT aiVector3D *dst,
-        const C_STRUCT aiVector3D *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = *dst + *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3Subtract(
-        C_STRUCT aiVector3D *dst,
-        const C_STRUCT aiVector3D *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = *dst - *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3Scale(
-        C_STRUCT aiVector3D *dst,
-        const float s) {
-    ai_assert(nullptr != dst);
-    *dst *= s;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3SymMul(
-        C_STRUCT aiVector3D *dst,
-        const C_STRUCT aiVector3D *other) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != other);
-    *dst = dst->SymMul(*other);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3DivideByScalar(
-        C_STRUCT aiVector3D *dst, const float s) {
-    ai_assert(nullptr != dst);
-    *dst /= s;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3DivideByVector(
-        C_STRUCT aiVector3D *dst,
-        C_STRUCT aiVector3D *v) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != v);
-    *dst = *dst / *v;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiVector3Length(
-        const C_STRUCT aiVector3D *v) {
-    ai_assert(nullptr != v);
-    return v->Length();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiVector3SquareLength(
-        const C_STRUCT aiVector3D *v) {
-    ai_assert(nullptr != v);
-    return v->SquareLength();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3Negate(
-        C_STRUCT aiVector3D *dst) {
-    ai_assert(nullptr != dst);
-    *dst = -(*dst);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiVector3DotProduct(
-        const C_STRUCT aiVector3D *a,
-        const C_STRUCT aiVector3D *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return (*a) * (*b);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3CrossProduct(
-        C_STRUCT aiVector3D *dst,
-        const C_STRUCT aiVector3D *a,
-        const C_STRUCT aiVector3D *b) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    *dst = *a ^ *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3Normalize(
-        C_STRUCT aiVector3D *v) {
-    ai_assert(nullptr != v);
-    v->Normalize();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3NormalizeSafe(
-        C_STRUCT aiVector3D *v) {
-    ai_assert(nullptr != v);
-    v->NormalizeSafe();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiVector3RotateByQuaternion(
-        C_STRUCT aiVector3D *v,
-        const C_STRUCT aiQuaternion *q) {
-    ai_assert(nullptr != v);
-    ai_assert(nullptr != q);
-    *v = q->Rotate(*v);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3FromMatrix4(
-        C_STRUCT aiMatrix3x3 *dst,
-        const C_STRUCT aiMatrix4x4 *mat) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != mat);
-    *dst = aiMatrix3x3(*mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3FromQuaternion(
-        C_STRUCT aiMatrix3x3 *mat,
-        const C_STRUCT aiQuaternion *q) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != q);
-    *mat = q->GetMatrix();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiMatrix3AreEqual(
-        const C_STRUCT aiMatrix3x3 *a,
-        const C_STRUCT aiMatrix3x3 *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return *a == *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiMatrix3AreEqualEpsilon(
-        const C_STRUCT aiMatrix3x3 *a,
-        const C_STRUCT aiMatrix3x3 *b,
-        const float epsilon) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return a->Equal(*b, epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3Inverse(C_STRUCT aiMatrix3x3 *mat) {
-    ai_assert(nullptr != mat);
-    mat->Inverse();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiMatrix3Determinant(const C_STRUCT aiMatrix3x3 *mat) {
-    ai_assert(nullptr != mat);
-    return mat->Determinant();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3RotationZ(
-        C_STRUCT aiMatrix3x3 *mat,
-        const float angle) {
-    ai_assert(nullptr != mat);
-    aiMatrix3x3::RotationZ(angle, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3FromRotationAroundAxis(
-        C_STRUCT aiMatrix3x3 *mat,
-        const C_STRUCT aiVector3D *axis,
-        const float angle) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != axis);
-    aiMatrix3x3::Rotation(angle, *axis, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3Translation(
-        C_STRUCT aiMatrix3x3 *mat,
-        const C_STRUCT aiVector2D *translation) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != translation);
-    aiMatrix3x3::Translation(*translation, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix3FromTo(
-        C_STRUCT aiMatrix3x3 *mat,
-        const C_STRUCT aiVector3D *from,
-        const C_STRUCT aiVector3D *to) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != from);
-    ai_assert(nullptr != to);
-    aiMatrix3x3::FromToMatrix(*from, *to, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4FromMatrix3(
-        C_STRUCT aiMatrix4x4 *dst,
-        const C_STRUCT aiMatrix3x3 *mat) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != mat);
-    *dst = aiMatrix4x4(*mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4FromScalingQuaternionPosition(
-        C_STRUCT aiMatrix4x4 *mat,
-        const C_STRUCT aiVector3D *scaling,
-        const C_STRUCT aiQuaternion *rotation,
-        const C_STRUCT aiVector3D *position) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != scaling);
-    ai_assert(nullptr != rotation);
-    ai_assert(nullptr != position);
-    *mat = aiMatrix4x4(*scaling, *rotation, *position);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4Add(
-        C_STRUCT aiMatrix4x4 *dst,
-        const C_STRUCT aiMatrix4x4 *src) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != src);
-    *dst = *dst + *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiMatrix4AreEqual(
-        const C_STRUCT aiMatrix4x4 *a,
-        const C_STRUCT aiMatrix4x4 *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return *a == *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiMatrix4AreEqualEpsilon(
-        const C_STRUCT aiMatrix4x4 *a,
-        const C_STRUCT aiMatrix4x4 *b,
-        const float epsilon) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return a->Equal(*b, epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4Inverse(C_STRUCT aiMatrix4x4 *mat) {
-    ai_assert(nullptr != mat);
-    mat->Inverse();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API float aiMatrix4Determinant(const C_STRUCT aiMatrix4x4 *mat) {
-    ai_assert(nullptr != mat);
-    return mat->Determinant();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiMatrix4IsIdentity(const C_STRUCT aiMatrix4x4 *mat) {
-    ai_assert(nullptr != mat);
-    return mat->IsIdentity();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(
-        const C_STRUCT aiMatrix4x4 *mat,
-        C_STRUCT aiVector3D *scaling,
-        C_STRUCT aiVector3D *rotation,
-        C_STRUCT aiVector3D *position) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != scaling);
-    ai_assert(nullptr != rotation);
-    ai_assert(nullptr != position);
-    mat->Decompose(*scaling, *rotation, *position);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition(
-        const C_STRUCT aiMatrix4x4 *mat,
-        C_STRUCT aiVector3D *scaling,
-        C_STRUCT aiVector3D *axis,
-        ai_real *angle,
-        C_STRUCT aiVector3D *position) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != scaling);
-    ai_assert(nullptr != axis);
-    ai_assert(nullptr != angle);
-    ai_assert(nullptr != position);
-    mat->Decompose(*scaling, *axis, *angle, *position);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4DecomposeNoScaling(
-        const C_STRUCT aiMatrix4x4 *mat,
-        C_STRUCT aiQuaternion *rotation,
-        C_STRUCT aiVector3D *position) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != rotation);
-    ai_assert(nullptr != position);
-    mat->DecomposeNoScaling(*rotation, *position);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4FromEulerAngles(
-        C_STRUCT aiMatrix4x4 *mat,
-        float x, float y, float z) {
-    ai_assert(nullptr != mat);
-    mat->FromEulerAnglesXYZ(x, y, z);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4RotationX(
-        C_STRUCT aiMatrix4x4 *mat,
-        const float angle) {
-    ai_assert(nullptr != mat);
-    aiMatrix4x4::RotationX(angle, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4RotationY(
-        C_STRUCT aiMatrix4x4 *mat,
-        const float angle) {
-    ai_assert(NULL != mat);
-    aiMatrix4x4::RotationY(angle, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4RotationZ(
-        C_STRUCT aiMatrix4x4 *mat,
-        const float angle) {
-    ai_assert(nullptr != mat);
-    aiMatrix4x4::RotationZ(angle, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4FromRotationAroundAxis(
-        C_STRUCT aiMatrix4x4 *mat,
-        const C_STRUCT aiVector3D *axis,
-        const float angle) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != axis);
-    aiMatrix4x4::Rotation(angle, *axis, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4Translation(
-        C_STRUCT aiMatrix4x4 *mat,
-        const C_STRUCT aiVector3D *translation) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != translation);
-    aiMatrix4x4::Translation(*translation, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4Scaling(
-        C_STRUCT aiMatrix4x4 *mat,
-        const C_STRUCT aiVector3D *scaling) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != scaling);
-    aiMatrix4x4::Scaling(*scaling, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiMatrix4FromTo(
-        C_STRUCT aiMatrix4x4 *mat,
-        const C_STRUCT aiVector3D *from,
-        const C_STRUCT aiVector3D *to) {
-    ai_assert(nullptr != mat);
-    ai_assert(nullptr != from);
-    ai_assert(nullptr != to);
-    aiMatrix4x4::FromToMatrix(*from, *to, *mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionFromEulerAngles(
-        C_STRUCT aiQuaternion *q,
-        float x, float y, float z) {
-    ai_assert(nullptr != q);
-    *q = aiQuaternion(x, y, z);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionFromAxisAngle(
-        C_STRUCT aiQuaternion *q,
-        const C_STRUCT aiVector3D *axis,
-        const float angle) {
-    ai_assert(nullptr != q);
-    ai_assert(nullptr != axis);
-    *q = aiQuaternion(*axis, angle);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionFromNormalizedQuaternion(
-        C_STRUCT aiQuaternion *q,
-        const C_STRUCT aiVector3D *normalized) {
-    ai_assert(nullptr != q);
-    ai_assert(nullptr != normalized);
-    *q = aiQuaternion(*normalized);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiQuaternionAreEqual(
-        const C_STRUCT aiQuaternion *a,
-        const C_STRUCT aiQuaternion *b) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return *a == *b;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API int aiQuaternionAreEqualEpsilon(
-        const C_STRUCT aiQuaternion *a,
-        const C_STRUCT aiQuaternion *b,
-        const float epsilon) {
-    ai_assert(nullptr != a);
-    ai_assert(nullptr != b);
-    return a->Equal(*b, epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionNormalize(
-        C_STRUCT aiQuaternion *q) {
-    ai_assert(nullptr != q);
-    q->Normalize();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionConjugate(
-        C_STRUCT aiQuaternion *q) {
-    ai_assert(nullptr != q);
-    q->Conjugate();
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionMultiply(
-        C_STRUCT aiQuaternion *dst,
-        const C_STRUCT aiQuaternion *q) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != q);
-    *dst = (*dst) * (*q);
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiQuaternionInterpolate(
-        C_STRUCT aiQuaternion *dst,
-        const C_STRUCT aiQuaternion *start,
-        const C_STRUCT aiQuaternion *end,
-        const float factor) {
-    ai_assert(nullptr != dst);
-    ai_assert(nullptr != start);
-    ai_assert(nullptr != end);
-    aiQuaternion::Interpolate(*dst, *start, *end, factor);
-}
-
-
-// stb_image is a lightweight image loader. It is shared by:
-//  - M3D import
-//  - PBRT export
-// Since it's a header-only library, its implementation must be instantiated in some cpp file.
-// Don't scatter this task over multiple importers/exporters. Maintain it in a central place (here!).
-
-#define ASSIMP_HAS_PBRT_EXPORT (!ASSIMP_BUILD_NO_EXPORT && !ASSIMP_BUILD_NO_PBRT_EXPORTER)
-#define ASSIMP_HAS_M3D ((!ASSIMP_BUILD_NO_EXPORT && !ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER)
-
-#if ASSIMP_HAS_PBRT_EXPORT
-#   define ASSIMP_NEEDS_STB_IMAGE 1
-#elif ASSIMP_HAS_M3D
-#   define ASSIMP_NEEDS_STB_IMAGE 1
-#   define STBI_ONLY_PNG
-#endif
-
-#if ASSIMP_NEEDS_STB_IMAGE
-
-#   if _MSC_VER // "unreferenced function has been removed" (SSE2 detection routine in x64 builds)
-#       pragma warning(push)
-#       pragma warning(disable: 4505)
-#   endif
-
-#   define STB_IMAGE_IMPLEMENTATION
-#   include "stb/stb_image.h"
-
-#   if _MSC_VER
-#       pragma warning(pop)
-#   endif
-
-#endif
diff --git a/libs/assimp/code/Common/Base64.cpp b/libs/assimp/code/Common/Base64.cpp
deleted file mode 100644
index 3e9c474..0000000
--- a/libs/assimp/code/Common/Base64.cpp
+++ /dev/null
@@ -1,179 +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 <assimp/Base64.hpp>
-#include <assimp/Exceptional.h>
-
-namespace Assimp {
-
-namespace Base64 {
-
-static const uint8_t tableDecodeBase64[128] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63,
-    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 64, 0, 0,
-    0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0,
-    0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0
-};
-
-static const char *tableEncodeBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-
-static inline char EncodeChar(uint8_t b) {
-    return tableEncodeBase64[size_t(b)];
-}
-
-inline uint8_t DecodeChar(char c) {
-    if (c & 0x80) {
-        throw DeadlyImportError("Invalid base64 char value: ", size_t(c));
-    }
-    return tableDecodeBase64[size_t(c & 0x7F)]; // TODO faster with lookup table or ifs?
-}
-
-void Encode(const uint8_t *in, size_t inLength, std::string &out) {
-    size_t outLength = ((inLength + 2) / 3) * 4;
-
-    size_t j = out.size();
-    out.resize(j + outLength);
-
-    for (size_t i = 0; i < inLength; i += 3) {
-        uint8_t b = (in[i] & 0xFC) >> 2;
-        out[j++] = EncodeChar(b);
-
-        b = (in[i] & 0x03) << 4;
-        if (i + 1 < inLength) {
-            b |= (in[i + 1] & 0xF0) >> 4;
-            out[j++] = EncodeChar(b);
-
-            b = (in[i + 1] & 0x0F) << 2;
-            if (i + 2 < inLength) {
-                b |= (in[i + 2] & 0xC0) >> 6;
-                out[j++] = EncodeChar(b);
-
-                b = in[i + 2] & 0x3F;
-                out[j++] = EncodeChar(b);
-            } else {
-                out[j++] = EncodeChar(b);
-                out[j++] = '=';
-            }
-        } else {
-            out[j++] = EncodeChar(b);
-            out[j++] = '=';
-            out[j++] = '=';
-        }
-    }
-}
-
-void Encode(const std::vector<uint8_t> &in, std::string &out) {
-    Encode(in.data(), in.size(), out);
-}
-
-std::string Encode(const std::vector<uint8_t> &in) {
-    std::string encoded;
-    Encode(in, encoded);
-    return encoded;
-}
-
-size_t Decode(const char *in, size_t inLength, uint8_t *&out) {
-    if (inLength % 4 != 0) {
-        throw DeadlyImportError("Invalid base64 encoded data: \"", std::string(in, std::min(size_t(32), inLength)), "\", length:", inLength);
-    }
-
-    if (inLength < 4) {
-        out = nullptr;
-        return 0;
-    }
-
-    int nEquals = int(in[inLength - 1] == '=') +
-                  int(in[inLength - 2] == '=');
-
-    size_t outLength = (inLength * 3) / 4 - nEquals;
-    out = new uint8_t[outLength];
-    memset(out, 0, outLength);
-
-    size_t i, j = 0;
-
-    for (i = 0; i + 4 < inLength; i += 4) {
-        uint8_t b0 = DecodeChar(in[i]);
-        uint8_t b1 = DecodeChar(in[i + 1]);
-        uint8_t b2 = DecodeChar(in[i + 2]);
-        uint8_t b3 = DecodeChar(in[i + 3]);
-
-        out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4));
-        out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2));
-        out[j++] = (uint8_t)((b2 << 6) | b3);
-    }
-
-    {
-        uint8_t b0 = DecodeChar(in[i]);
-        uint8_t b1 = DecodeChar(in[i + 1]);
-        uint8_t b2 = DecodeChar(in[i + 2]);
-        uint8_t b3 = DecodeChar(in[i + 3]);
-
-        out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4));
-        if (b2 < 64) out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2));
-        if (b3 < 64) out[j++] = (uint8_t)((b2 << 6) | b3);
-    }
-
-    return outLength;
-}
-
-size_t Decode(const std::string &in, std::vector<uint8_t> &out) {
-    uint8_t *outPtr = nullptr;
-    size_t decodedSize = Decode(in.data(), in.size(), outPtr);
-    if (outPtr == nullptr) {
-        return 0;
-    }
-    out.assign(outPtr, outPtr + decodedSize);
-    delete[] outPtr;
-    return decodedSize;
-}
-
-std::vector<uint8_t> Decode(const std::string &in) {
-    std::vector<uint8_t> result;
-    Decode(in, result);
-    return result;
-}
-
-} // namespace Base64
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/BaseImporter.cpp b/libs/assimp/code/Common/BaseImporter.cpp
deleted file mode 100644
index 383300e..0000000
--- a/libs/assimp/code/Common/BaseImporter.cpp
+++ /dev/null
@@ -1,620 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file  BaseImporter.cpp
- *  @brief Implementation of BaseImporter
- */
-
-#include "FileSystemFilter.h"
-#include "Importer.h"
-#include <assimp/BaseImporter.h>
-#include <assimp/ByteSwapper.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/importerdesc.h>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <assimp/Importer.hpp>
-
-#include <cctype>
-#include <ios>
-#include <list>
-#include <memory>
-#include <sstream>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-BaseImporter::BaseImporter() AI_NO_EXCEPT
-        : m_progress() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-BaseImporter::~BaseImporter() {
-    // nothing to do here
-}
-
-void BaseImporter::UpdateImporterScale(Importer *pImp) {
-    ai_assert(pImp != nullptr);
-    ai_assert(importerScale != 0.0);
-    ai_assert(fileScale != 0.0);
-
-    double activeScale = importerScale * fileScale;
-
-    // Set active scaling
-    pImp->SetPropertyFloat(AI_CONFIG_APP_SCALE_KEY, static_cast<float>(activeScale));
-
-    ASSIMP_LOG_DEBUG("UpdateImporterScale scale set: ", activeScale);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file and returns the imported data.
-aiScene *BaseImporter::ReadFile(Importer *pImp, const std::string &pFile, IOSystem *pIOHandler) {
-
-    m_progress = pImp->GetProgressHandler();
-    if (nullptr == m_progress) {
-        return nullptr;
-    }
-
-    ai_assert(m_progress);
-
-    // Gather configuration properties for this run
-    SetupProperties(pImp);
-
-    // Construct a file system filter to improve our success ratio at reading external files
-    FileSystemFilter filter(pFile, pIOHandler);
-
-    // create a scene object to hold the data
-    std::unique_ptr<aiScene> sc(new aiScene());
-
-    // dispatch importing
-    try {
-        InternReadFile(pFile, sc.get(), &filter);
-
-        // Calculate import scale hook - required because pImp not available anywhere else
-        // passes scale into ScaleProcess
-        UpdateImporterScale(pImp);
-
-    } catch( const std::exception &err ) {
-        // extract error description
-        m_ErrorText = err.what();
-        ASSIMP_LOG_ERROR(err.what());
-        m_Exception = std::current_exception();
-        return nullptr;
-    }
-
-    // return what we gathered from the import.
-    return sc.release();
-}
-
-// ------------------------------------------------------------------------------------------------
-void BaseImporter::SetupProperties(const Importer *) {
-    // the default implementation does nothing
-}
-
-// ------------------------------------------------------------------------------------------------
-void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
-    const aiImporterDesc *desc = GetInfo();
-    ai_assert(desc != nullptr);
-
-    const char *ext = desc->mFileExtensions;
-    ai_assert(ext != nullptr);
-
-    const char *last = ext;
-    do {
-        if (!*ext || *ext == ' ') {
-            extensions.insert(std::string(last, ext - last));
-            ai_assert(ext - last > 0);
-            last = ext;
-            while (*last == ' ') {
-                ++last;
-            }
-        }
-    } while (*ext++);
-}
-
-// ------------------------------------------------------------------------------------------------
-/*static*/ bool BaseImporter::SearchFileHeaderForToken(IOSystem *pIOHandler,
-        const std::string &pFile,
-        const char **tokens,
-        std::size_t numTokens,
-        unsigned int searchBytes /* = 200 */,
-        bool tokensSol /* false */,
-        bool noAlphaBeforeTokens /* false */) {
-    ai_assert(nullptr != tokens);
-    ai_assert(0 != numTokens);
-    ai_assert(0 != searchBytes);
-
-    if (nullptr == pIOHandler) {
-        return false;
-    }
-
-    std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile));
-    if (pStream) {
-        // read 200 characters from the file
-        std::unique_ptr<char[]> _buffer(new char[searchBytes + 1 /* for the '\0' */]);
-        char *buffer(_buffer.get());
-        const size_t read(pStream->Read(buffer, 1, searchBytes));
-        if (0 == read) {
-            return false;
-        }
-
-        for (size_t i = 0; i < read; ++i) {
-            buffer[i] = static_cast<char>(::tolower((unsigned char)buffer[i]));
-        }
-
-        // It is not a proper handling of unicode files here ...
-        // ehm ... but it works in most cases.
-        char *cur = buffer, *cur2 = buffer, *end = &buffer[read];
-        while (cur != end) {
-            if (*cur) {
-                *cur2++ = *cur;
-            }
-            ++cur;
-        }
-        *cur2 = '\0';
-
-        std::string token;
-        for (unsigned int i = 0; i < numTokens; ++i) {
-            ai_assert(nullptr != tokens[i]);
-            const size_t len(strlen(tokens[i]));
-            token.clear();
-            const char *ptr(tokens[i]);
-            for (size_t tokIdx = 0; tokIdx < len; ++tokIdx) {
-                token.push_back(static_cast<char>(tolower(static_cast<unsigned char>(*ptr))));
-                ++ptr;
-            }
-            const char *r = strstr(buffer, token.c_str());
-            if (!r) {
-                continue;
-            }
-            // We need to make sure that we didn't accidentally identify the end of another token as our token,
-            // e.g. in a previous version the "gltf " present in some gltf files was detected as "f "
-            if (noAlphaBeforeTokens && (r != buffer && isalpha(static_cast<unsigned char>(r[-1])))) {
-                continue;
-            }
-            // We got a match, either we don't care where it is, or it happens to
-            // be in the beginning of the file / line
-            if (!tokensSol || r == buffer || r[-1] == '\r' || r[-1] == '\n') {
-                ASSIMP_LOG_DEBUG("Found positive match for header keyword: ", tokens[i]);
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Simple check for file extension
-/*static*/ bool BaseImporter::SimpleExtensionCheck(const std::string &pFile,
-        const char *ext0,
-        const char *ext1,
-        const char *ext2) {
-    std::string::size_type pos = pFile.find_last_of('.');
-
-    // no file extension - can't read
-    if (pos == std::string::npos)
-        return false;
-
-    const char *ext_real = &pFile[pos + 1];
-    if (!ASSIMP_stricmp(ext_real, ext0))
-        return true;
-
-    // check for other, optional, file extensions
-    if (ext1 && !ASSIMP_stricmp(ext_real, ext1))
-        return true;
-
-    if (ext2 && !ASSIMP_stricmp(ext_real, ext2))
-        return true;
-
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get file extension from path
-std::string BaseImporter::GetExtension(const std::string &file) {
-    std::string::size_type pos = file.find_last_of('.');
-
-    // no file extension at all
-    if (pos == std::string::npos) {
-        return std::string();
-    }
-
-    // thanks to Andy Maloney for the hint
-    std::string ret = file.substr(pos + 1);
-    ret = ai_tolower(ret);
-
-    return ret;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Check for magic bytes at the beginning of the file.
-/* static */ bool BaseImporter::CheckMagicToken(IOSystem *pIOHandler, const std::string &pFile,
-        const void *_magic, std::size_t num, unsigned int offset, unsigned int size) {
-    ai_assert(size <= 16);
-    ai_assert(_magic);
-
-    if (!pIOHandler) {
-        return false;
-    }
-    union {
-        const char *magic;
-        const uint16_t *magic_u16;
-        const uint32_t *magic_u32;
-    };
-    magic = reinterpret_cast<const char *>(_magic);
-    std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile));
-    if (pStream) {
-
-        // skip to offset
-        pStream->Seek(offset, aiOrigin_SET);
-
-        // read 'size' characters from the file
-        union {
-            char data[16];
-            uint16_t data_u16[8];
-            uint32_t data_u32[4];
-        };
-        if (size != pStream->Read(data, 1, size)) {
-            return false;
-        }
-
-        for (unsigned int i = 0; i < num; ++i) {
-            // also check against big endian versions of tokens with size 2,4
-            // that's just for convenience, the chance that we cause conflicts
-            // is quite low and it can save some lines and prevent nasty bugs
-            if (2 == size) {
-                uint16_t rev = *magic_u16;
-                ByteSwap::Swap(&rev);
-                if (data_u16[0] == *magic_u16 || data_u16[0] == rev) {
-                    return true;
-                }
-            } else if (4 == size) {
-                uint32_t rev = *magic_u32;
-                ByteSwap::Swap(&rev);
-                if (data_u32[0] == *magic_u32 || data_u32[0] == rev) {
-                    return true;
-                }
-            } else {
-                // any length ... just compare
-                if (!memcmp(magic, data, size)) {
-                    return true;
-                }
-            }
-            magic += size;
-        }
-    }
-    return false;
-}
-
-#ifdef ASSIMP_USE_HUNTER
-#include <utf8.h>
-#else
-#include "../contrib/utf8cpp/source/utf8.h"
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Convert to UTF8 data
-void BaseImporter::ConvertToUTF8(std::vector<char> &data) {
-    //ConversionResult result;
-    if (data.size() < 8) {
-        throw DeadlyImportError("File is too small");
-    }
-
-    // UTF 8 with BOM
-    if ((uint8_t)data[0] == 0xEF && (uint8_t)data[1] == 0xBB && (uint8_t)data[2] == 0xBF) {
-        ASSIMP_LOG_DEBUG("Found UTF-8 BOM ...");
-
-        std::copy(data.begin() + 3, data.end(), data.begin());
-        data.resize(data.size() - 3);
-        return;
-    }
-
-    // UTF 32 BE with BOM
-    if (*((uint32_t *)&data.front()) == 0xFFFE0000) {
-
-        // swap the endianness ..
-        for (uint32_t *p = (uint32_t *)&data.front(), *end = (uint32_t *)&data.back(); p <= end; ++p) {
-            AI_SWAP4P(p);
-        }
-    }
-
-    // UTF 32 LE with BOM
-    if (*((uint32_t *)&data.front()) == 0x0000FFFE) {
-        ASSIMP_LOG_DEBUG("Found UTF-32 BOM ...");
-
-        std::vector<char> output;
-        int *ptr = (int *)&data[0];
-        int *end = ptr + (data.size() / sizeof(int)) + 1;
-        utf8::utf32to8(ptr, end, back_inserter(output));
-        return;
-    }
-
-    // UTF 16 BE with BOM
-    if (*((uint16_t *)&data.front()) == 0xFFFE) {
-        // Check to ensure no overflow can happen
-        if(data.size() % 2 != 0) {
-            return;
-        }
-        // swap the endianness ..
-        for (uint16_t *p = (uint16_t *)&data.front(), *end = (uint16_t *)&data.back(); p <= end; ++p) {
-            ByteSwap::Swap2(p);
-        }
-    }
-
-    // UTF 16 LE with BOM
-    if (*((uint16_t *)&data.front()) == 0xFEFF) {
-        ASSIMP_LOG_DEBUG("Found UTF-16 BOM ...");
-
-        std::vector<unsigned char> output;
-        utf8::utf16to8(data.begin(), data.end(), back_inserter(output));
-        return;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert to UTF8 data to ISO-8859-1
-void BaseImporter::ConvertUTF8toISO8859_1(std::string &data) {
-    size_t size = data.size();
-    size_t i = 0, j = 0;
-
-    while (i < size) {
-        if ((unsigned char)data[i] < (size_t)0x80) {
-            data[j] = data[i];
-        } else if (i < size - 1) {
-            if ((unsigned char)data[i] == 0xC2) {
-                data[j] = data[++i];
-            } else if ((unsigned char)data[i] == 0xC3) {
-                data[j] = ((unsigned char)data[++i] + 0x40);
-            } else {
-                std::stringstream stream;
-                stream << "UTF8 code " << std::hex << data[i] << data[i + 1] << " can not be converted into ISA-8859-1.";
-                ASSIMP_LOG_ERROR(stream.str());
-
-                data[j++] = data[i++];
-                data[j] = data[i];
-            }
-        } else {
-            ASSIMP_LOG_ERROR("UTF8 code but only one character remaining");
-
-            data[j] = data[i];
-        }
-
-        i++;
-        j++;
-    }
-
-    data.resize(j);
-}
-
-// ------------------------------------------------------------------------------------------------
-void BaseImporter::TextFileToBuffer(IOStream *stream,
-        std::vector<char> &data,
-        TextFileMode mode) {
-    ai_assert(nullptr != stream);
-
-    const size_t fileSize = stream->FileSize();
-    if (mode == FORBID_EMPTY) {
-        if (!fileSize) {
-            throw DeadlyImportError("File is empty");
-        }
-    }
-
-    data.reserve(fileSize + 1);
-    data.resize(fileSize);
-    if (fileSize > 0) {
-        if (fileSize != stream->Read(&data[0], 1, fileSize)) {
-            throw DeadlyImportError("File read error");
-        }
-
-        ConvertToUTF8(data);
-    }
-
-    // append a binary zero to simplify string parsing
-    data.push_back(0);
-}
-
-// ------------------------------------------------------------------------------------------------
-namespace Assimp {
-// Represents an import request
-struct LoadRequest {
-    LoadRequest(const std::string &_file, unsigned int _flags, const BatchLoader::PropertyMap *_map, unsigned int _id) :
-            file(_file),
-            flags(_flags),
-            refCnt(1),
-            scene(nullptr),
-            loaded(false),
-            id(_id) {
-        if (_map) {
-            map = *_map;
-        }
-    }
-
-    bool operator==(const std::string &f) const {
-        return file == f;
-    }
-
-    const std::string file;
-    unsigned int flags;
-    unsigned int refCnt;
-    aiScene *scene;
-    bool loaded;
-    BatchLoader::PropertyMap map;
-    unsigned int id;
-};
-} // namespace Assimp
-
-// ------------------------------------------------------------------------------------------------
-// BatchLoader::pimpl data structure
-struct Assimp::BatchData {
-    BatchData(IOSystem *pIO, bool validate) :
-            pIOSystem(pIO), pImporter(nullptr), next_id(0xffff), validate(validate) {
-        ai_assert(nullptr != pIO);
-
-        pImporter = new Importer();
-        pImporter->SetIOHandler(pIO);
-    }
-
-    ~BatchData() {
-        pImporter->SetIOHandler(nullptr); /* get pointer back into our possession */
-        delete pImporter;
-    }
-
-    // IO system to be used for all imports
-    IOSystem *pIOSystem;
-
-    // Importer used to load all meshes
-    Importer *pImporter;
-
-    // List of all imports
-    std::list<LoadRequest> requests;
-
-    // Base path
-    std::string pathBase;
-
-    // Id for next item
-    unsigned int next_id;
-
-    // Validation enabled state
-    bool validate;
-};
-
-typedef std::list<LoadRequest>::iterator LoadReqIt;
-
-// ------------------------------------------------------------------------------------------------
-BatchLoader::BatchLoader(IOSystem *pIO, bool validate) {
-    ai_assert(nullptr != pIO);
-
-    m_data = new BatchData(pIO, validate);
-}
-
-// ------------------------------------------------------------------------------------------------
-BatchLoader::~BatchLoader() {
-    // delete all scenes what have not been polled by the user
-    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
-        delete (*it).scene;
-    }
-    delete m_data;
-}
-
-// ------------------------------------------------------------------------------------------------
-void BatchLoader::setValidation(bool enabled) {
-    m_data->validate = enabled;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool BatchLoader::getValidation() const {
-    return m_data->validate;
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned int BatchLoader::AddLoadRequest(const std::string &file,
-        unsigned int steps /*= 0*/, const PropertyMap *map /*= nullptr*/) {
-    ai_assert(!file.empty());
-
-    // check whether we have this loading request already
-    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
-        // Call IOSystem's path comparison function here
-        if (m_data->pIOSystem->ComparePaths((*it).file, file)) {
-            if (map) {
-                if (!((*it).map == *map)) {
-                    continue;
-                }
-            } else if (!(*it).map.empty()) {
-                continue;
-            }
-
-            (*it).refCnt++;
-            return (*it).id;
-        }
-    }
-
-    // no, we don't have it. So add it to the queue ...
-    m_data->requests.emplace_back(file, steps, map, m_data->next_id);
-    return m_data->next_id++;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiScene *BatchLoader::GetImport(unsigned int which) {
-    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
-        if ((*it).id == which && (*it).loaded) {
-            aiScene *sc = (*it).scene;
-            if (!(--(*it).refCnt)) {
-                m_data->requests.erase(it);
-            }
-            return sc;
-        }
-    }
-    return nullptr;
-}
-
-// ------------------------------------------------------------------------------------------------
-void BatchLoader::LoadAll() {
-    // no threaded implementation for the moment
-    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
-        // force validation in debug builds
-        unsigned int pp = (*it).flags;
-        if (m_data->validate) {
-            pp |= aiProcess_ValidateDataStructure;
-        }
-
-        // setup config properties if necessary
-        ImporterPimpl *pimpl = m_data->pImporter->Pimpl();
-        pimpl->mFloatProperties = (*it).map.floats;
-        pimpl->mIntProperties = (*it).map.ints;
-        pimpl->mStringProperties = (*it).map.strings;
-        pimpl->mMatrixProperties = (*it).map.matrices;
-
-        if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_INFO("%%% BEGIN EXTERNAL FILE %%%");
-            ASSIMP_LOG_INFO("File: ", (*it).file);
-        }
-        m_data->pImporter->ReadFile((*it).file, pp);
-        (*it).scene = m_data->pImporter->GetOrphanedScene();
-        (*it).loaded = true;
-
-        ASSIMP_LOG_INFO("%%% END EXTERNAL FILE %%%");
-    }
-}
diff --git a/libs/assimp/code/Common/BaseProcess.cpp b/libs/assimp/code/Common/BaseProcess.cpp
deleted file mode 100644
index 48895b9..0000000
--- a/libs/assimp/code/Common/BaseProcess.cpp
+++ /dev/null
@@ -1,100 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of BaseProcess */
-
-#include "BaseProcess.h"
-#include "Importer.h"
-#include <assimp/BaseImporter.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-BaseProcess::BaseProcess() AI_NO_EXCEPT
-        : shared(),
-          progress() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-BaseProcess::~BaseProcess() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-void BaseProcess::ExecuteOnScene(Importer *pImp) {
-    ai_assert( nullptr != pImp );
-    ai_assert( nullptr != pImp->Pimpl()->mScene);
-
-    progress = pImp->GetProgressHandler();
-    ai_assert(nullptr != progress);
-
-    SetupProperties(pImp);
-
-    // catch exceptions thrown inside the PostProcess-Step
-    try {
-        Execute(pImp->Pimpl()->mScene);
-
-    } catch (const std::exception &err) {
-
-        // extract error description
-        pImp->Pimpl()->mErrorString = err.what();
-        ASSIMP_LOG_ERROR(pImp->Pimpl()->mErrorString);
-
-        // and kill the partially imported data
-        delete pImp->Pimpl()->mScene;
-        pImp->Pimpl()->mScene = nullptr;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void BaseProcess::SetupProperties(const Importer * /*pImp*/) {
-    // the default implementation does nothing
-}
-
-// ------------------------------------------------------------------------------------------------
-bool BaseProcess::RequireVerboseFormat() const {
-    return true;
-}
diff --git a/libs/assimp/code/Common/BaseProcess.h b/libs/assimp/code/Common/BaseProcess.h
deleted file mode 100644
index 6440356..0000000
--- a/libs/assimp/code/Common/BaseProcess.h
+++ /dev/null
@@ -1,251 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Base class of all import post processing steps */
-#ifndef INCLUDED_AI_BASEPROCESS_H
-#define INCLUDED_AI_BASEPROCESS_H
-
-#include <assimp/GenericProperty.h>
-
-#include <map>
-
-struct aiScene;
-
-namespace Assimp {
-
-class Importer;
-
-// ---------------------------------------------------------------------------
-/** Helper class to allow post-processing steps to interact with each other.
- *
- *  The class maintains a simple property list that can be used by pp-steps
- *  to provide additional information to other steps. This is primarily
- *  intended for cross-step optimizations.
- */
-class SharedPostProcessInfo {
-public:
-    struct Base {
-        virtual ~Base() {}
-    };
-
-    //! Represents data that is allocated on the heap, thus needs to be deleted
-    template <typename T>
-    struct THeapData : public Base {
-        explicit THeapData(T *in) :
-                data(in) {}
-
-        ~THeapData() {
-            delete data;
-        }
-        T *data;
-    };
-
-    //! Represents static, by-value data not allocated on the heap
-    template <typename T>
-    struct TStaticData : public Base {
-        explicit TStaticData(T in) :
-                data(in) {}
-
-        ~TStaticData() {}
-
-        T data;
-    };
-
-    // some typedefs for cleaner code
-    typedef unsigned int KeyType;
-    typedef std::map<KeyType, Base *> PropertyMap;
-
-public:
-    //! Destructor
-    ~SharedPostProcessInfo() {
-        Clean();
-    }
-
-    //! Remove all stored properties from the table
-    void Clean() {
-        // invoke the virtual destructor for all stored properties
-        for (PropertyMap::iterator it = pmap.begin(), end = pmap.end();
-                it != end; ++it) {
-            delete (*it).second;
-        }
-        pmap.clear();
-    }
-
-    //! Add a heap property to the list
-    template <typename T>
-    void AddProperty(const char *name, T *in) {
-        AddProperty(name, (Base *)new THeapData<T>(in));
-    }
-
-    //! Add a static by-value property to the list
-    template <typename T>
-    void AddProperty(const char *name, T in) {
-        AddProperty(name, (Base *)new TStaticData<T>(in));
-    }
-
-    //! Get a heap property
-    template <typename T>
-    bool GetProperty(const char *name, T *&out) const {
-        THeapData<T> *t = (THeapData<T> *)GetPropertyInternal(name);
-        if (!t) {
-            out = nullptr;
-            return false;
-        }
-        out = t->data;
-        return true;
-    }
-
-    //! Get a static, by-value property
-    template <typename T>
-    bool GetProperty(const char *name, T &out) const {
-        TStaticData<T> *t = (TStaticData<T> *)GetPropertyInternal(name);
-        if ( nullptr == t) {
-            return false;
-        }
-        out = t->data;
-        return true;
-    }
-
-    //! Remove a property of a specific type
-    void RemoveProperty(const char *name) {
-        SetGenericPropertyPtr<Base>(pmap, name, nullptr );
-    }
-
-private:
-    void AddProperty(const char *name, Base *data) {
-        SetGenericPropertyPtr<Base>(pmap, name, data);
-    }
-
-    Base *GetPropertyInternal(const char *name) const {
-        return GetGenericProperty<Base *>(pmap, name, nullptr );
-    }
-
-private:
-    //! Map of all stored properties
-    PropertyMap pmap;
-};
-
-#define AI_SPP_SPATIAL_SORT "$Spat"
-
-// ---------------------------------------------------------------------------
-/** The BaseProcess defines a common interface for all post processing steps.
- * A post processing step is run after a successful import if the caller
- * specified the corresponding flag when calling ReadFile().
- * Enum #aiPostProcessSteps defines which flags are available.
- * After a successful import the Importer iterates over its internal array
- * of processes and calls IsActive() on each process to evaluate if the step
- * should be executed. If the function returns true, the class' Execute()
- * function is called subsequently.
- */
-class ASSIMP_API_WINONLY BaseProcess {
-    friend class Importer;
-
-public:
-    /** Constructor to be privately used by Importer */
-    BaseProcess() AI_NO_EXCEPT;
-
-    /** Destructor, private as well */
-    virtual ~BaseProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag.
-     * @param pFlags The processing flags the importer was called with. A
-     *   bitwise combination of #aiPostProcessSteps.
-     * @return true if the process is present in this flag fields,
-     *   false if not.
-    */
-    virtual bool IsActive(unsigned int pFlags) const = 0;
-
-    // -------------------------------------------------------------------
-    /** Check whether this step expects its input vertex data to be
-     *  in verbose format. */
-    virtual bool RequireVerboseFormat() const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * The function deletes the scene if the postprocess step fails (
-    * the object pointer will be set to nullptr).
-    * @param pImp Importer instance (pImp->mScene must be valid)
-    */
-    void ExecuteOnScene(Importer *pImp);
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    virtual void SetupProperties(const Importer *pImp);
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * A process should throw an ImportErrorException* if it fails.
-    * This method must be implemented by deriving classes.
-    * @param pScene The imported data to work at.
-    */
-    virtual void Execute(aiScene *pScene) = 0;
-
-    // -------------------------------------------------------------------
-    /** Assign a new SharedPostProcessInfo to the step. This object
-     *  allows multiple postprocess steps to share data.
-     * @param sh May be nullptr
-    */
-    inline void SetSharedData(SharedPostProcessInfo *sh) {
-        shared = sh;
-    }
-
-    // -------------------------------------------------------------------
-    /** Get the shared data that is assigned to the step.
-    */
-    inline SharedPostProcessInfo *GetSharedData() {
-        return shared;
-    }
-
-protected:
-    /** See the doc of #SharedPostProcessInfo for more details */
-    SharedPostProcessInfo *shared;
-
-    /** Currently active progress handler */
-    ProgressHandler *progress;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_BASEPROCESS_H_INC
diff --git a/libs/assimp/code/Common/Bitmap.cpp b/libs/assimp/code/Common/Bitmap.cpp
deleted file mode 100644
index 65dfd17..0000000
--- a/libs/assimp/code/Common/Bitmap.cpp
+++ /dev/null
@@ -1,156 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Bitmap.cpp
- *  @brief Defines bitmap format helper for textures
- *
- * Used for file formats which embed their textures into the model file.
- */
-
-#include <assimp/Bitmap.h>
-#include <assimp/ByteSwapper.h>
-#include <assimp/texture.h>
-#include <assimp/IOStream.hpp>
-
-namespace Assimp {
-
-bool Bitmap::Save(aiTexture *texture, IOStream *file) {
-    if (file == nullptr) {
-        return false;
-    }
-
-    Header header;
-    DIB dib;
-    dib.size = DIB::dib_size;
-    dib.width = texture->mWidth;
-    dib.height = texture->mHeight;
-    dib.planes = 1;
-    dib.bits_per_pixel = 8 * mBytesPerPixel;
-    dib.compression = 0;
-    dib.image_size = (((dib.width * mBytesPerPixel) + 3) & 0x0000FFFC) * dib.height;
-    dib.x_resolution = 0;
-    dib.y_resolution = 0;
-    dib.nb_colors = 0;
-    dib.nb_important_colors = 0;
-
-    header.type = 0x4D42; // 'BM'
-    header.offset = Header::header_size + DIB::dib_size;
-    header.size = header.offset + dib.image_size;
-    header.reserved1 = 0;
-    header.reserved2 = 0;
-
-    WriteHeader(header, file);
-    WriteDIB(dib, file);
-    WriteData(texture, file);
-
-    return true;
-}
-
-template <typename T>
-inline std::size_t Copy(uint8_t *data, const T &field) {
-#ifdef AI_BUILD_BIG_ENDIAN
-    T field_swapped = AI_BE(field);
-    std::memcpy(data, &field_swapped, sizeof(field));
-    return sizeof(field);
-#else
-    std::memcpy(data, &AI_BE(field), sizeof(field));
-    return sizeof(field);
-#endif
-}
-
-void Bitmap::WriteHeader(Header &header, IOStream *file) {
-    uint8_t data[Header::header_size];
-
-    std::size_t offset = 0;
-
-    offset += Copy(&data[offset], header.type);
-    offset += Copy(&data[offset], header.size);
-    offset += Copy(&data[offset], header.reserved1);
-    offset += Copy(&data[offset], header.reserved2);
-    Copy(&data[offset], header.offset);
-
-    file->Write(data, Header::header_size, 1);
-}
-
-void Bitmap::WriteDIB(DIB &dib, IOStream *file) {
-    uint8_t data[DIB::dib_size];
-
-    std::size_t offset = 0;
-
-    offset += Copy(&data[offset], dib.size);
-    offset += Copy(&data[offset], dib.width);
-    offset += Copy(&data[offset], dib.height);
-    offset += Copy(&data[offset], dib.planes);
-    offset += Copy(&data[offset], dib.bits_per_pixel);
-    offset += Copy(&data[offset], dib.compression);
-    offset += Copy(&data[offset], dib.image_size);
-    offset += Copy(&data[offset], dib.x_resolution);
-    offset += Copy(&data[offset], dib.y_resolution);
-    offset += Copy(&data[offset], dib.nb_colors);
-    Copy(&data[offset], dib.nb_important_colors);
-
-    file->Write(data, DIB::dib_size, 1);
-}
-
-void Bitmap::WriteData(aiTexture *texture, IOStream *file) {
-    static const std::size_t padding_offset = 4;
-    static const uint8_t padding_data[padding_offset] = { 0x0, 0x0, 0x0, 0x0 };
-
-    unsigned int padding = (padding_offset - ((mBytesPerPixel * texture->mWidth) % padding_offset)) % padding_offset;
-    uint8_t pixel[mBytesPerPixel];
-
-    for (std::size_t i = 0; i < texture->mHeight; ++i) {
-        for (std::size_t j = 0; j < texture->mWidth; ++j) {
-            const aiTexel &texel = texture->pcData[(texture->mHeight - i - 1) * texture->mWidth + j]; // Bitmap files are stored in bottom-up format
-
-            pixel[0] = texel.r;
-            pixel[1] = texel.g;
-            pixel[2] = texel.b;
-            pixel[3] = texel.a;
-
-            file->Write(pixel, mBytesPerPixel, 1);
-        }
-
-        file->Write(padding_data, padding, 1);
-    }
-}
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/Compression.cpp b/libs/assimp/code/Common/Compression.cpp
deleted file mode 100644
index 3bf306d..0000000
--- a/libs/assimp/code/Common/Compression.cpp
+++ /dev/null
@@ -1,214 +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 "Compression.h"
-#include <assimp/ai_assert.h>
-#include <assimp/Exceptional.h>
-
-namespace Assimp {
-
-struct Compression::impl {
-    bool mOpen;
-    z_stream mZSstream;
-    FlushMode mFlushMode;
-
-    impl() :
-            mOpen(false),
-            mZSstream(),
-            mFlushMode(Compression::FlushMode::NoFlush) {
-        // empty
-    }
-};
-
-Compression::Compression() :
-        mImpl(new impl) {
-    // empty
-}
-
-Compression::~Compression() {
-    ai_assert(mImpl != nullptr);
-
-    delete mImpl;
-}
-
-bool Compression::open(Format format, FlushMode flush, int windowBits) {
-    ai_assert(mImpl != nullptr);
-
-    if (mImpl->mOpen) {
-        return false;
-    }
-
-    // build a zlib stream
-    mImpl->mZSstream.opaque = Z_NULL;
-    mImpl->mZSstream.zalloc = Z_NULL;
-    mImpl->mZSstream.zfree = Z_NULL;
-    mImpl->mFlushMode = flush;
-    if (format == Format::Binary) {
-        mImpl->mZSstream.data_type = Z_BINARY;
-    } else {
-        mImpl->mZSstream.data_type = Z_ASCII;
-    }
-
-    // raw decompression without a zlib or gzip header
-    if (windowBits == 0) {
-        inflateInit(&mImpl->mZSstream);
-    } else {
-        inflateInit2(&mImpl->mZSstream, windowBits);
-    }
-    mImpl->mOpen = true;
-
-    return mImpl->mOpen;
-}
-
-static int getFlushMode(Compression::FlushMode flush) {
-    int z_flush = 0;
-    switch (flush) {
-        case Compression::FlushMode::NoFlush:
-            z_flush = Z_NO_FLUSH;
-            break;
-        case Compression::FlushMode::Block:
-            z_flush = Z_BLOCK;
-            break;
-        case Compression::FlushMode::Tree:
-            z_flush = Z_TREES;
-            break;
-        case Compression::FlushMode::SyncFlush:
-            z_flush = Z_SYNC_FLUSH;
-            break;
-        case Compression::FlushMode::Finish:
-            z_flush = Z_FINISH;
-            break;
-        default:
-            ai_assert(false);
-            break;
-    }
-
-    return z_flush;
-}
-
-constexpr size_t MYBLOCK = 32786;
-
-size_t Compression::decompress(const void *data, size_t in, std::vector<char> &uncompressed) {
-    ai_assert(mImpl != nullptr);
-    if (data == nullptr || in == 0) {
-        return 0l;
-    }
-
-    mImpl->mZSstream.next_in = (Bytef*)(data);
-    mImpl->mZSstream.avail_in = (uInt)in;
-
-    int ret = 0;
-    size_t total = 0l;
-    const int flushMode = getFlushMode(mImpl->mFlushMode);
-    if (flushMode == Z_FINISH) {
-        mImpl->mZSstream.avail_out = static_cast<uInt>(uncompressed.size());
-        mImpl->mZSstream.next_out = reinterpret_cast<Bytef *>(&*uncompressed.begin());
-        ret = inflate(&mImpl->mZSstream, Z_FINISH);
-
-        if (ret != Z_STREAM_END && ret != Z_OK) {
-            throw DeadlyImportError("Compression", "Failure decompressing this file using gzip.");
-        }
-        total = mImpl->mZSstream.avail_out;
-    } else {
-        do {
-            Bytef block[MYBLOCK] = {};
-            mImpl->mZSstream.avail_out = MYBLOCK;
-            mImpl->mZSstream.next_out = block;
-
-            ret = inflate(&mImpl->mZSstream, flushMode);
-
-            if (ret != Z_STREAM_END && ret != Z_OK) {
-                throw DeadlyImportError("Compression", "Failure decompressing this file using gzip.");
-            }
-            const size_t have = MYBLOCK - mImpl->mZSstream.avail_out;
-            total += have;
-            uncompressed.resize(total);
-            ::memcpy(uncompressed.data() + total - have, block, have);
-        } while (ret != Z_STREAM_END);
-    }
-
-    return total;
-}
-
-size_t Compression::decompressBlock(const void *data, size_t in, char *out, size_t availableOut) {
-    ai_assert(mImpl != nullptr);
-    if (data == nullptr || in == 0 || out == nullptr || availableOut == 0) {
-        return 0l;
-    }
-
-    // push data to the stream
-    mImpl->mZSstream.next_in = (Bytef *)data;
-    mImpl->mZSstream.avail_in = (uInt)in;
-    mImpl->mZSstream.next_out = (Bytef *)out;
-    mImpl->mZSstream.avail_out = (uInt)availableOut;
-
-    // and decompress the data ....
-    int ret = ::inflate(&mImpl->mZSstream, Z_SYNC_FLUSH);
-    if (ret != Z_OK && ret != Z_STREAM_END) {
-        throw DeadlyImportError("X: Failed to decompress MSZIP-compressed data");
-    }
-
-    ::inflateReset(&mImpl->mZSstream);
-    ::inflateSetDictionary(&mImpl->mZSstream, (const Bytef *)out, (uInt)availableOut - mImpl->mZSstream.avail_out);
-
-    return availableOut - (size_t)mImpl->mZSstream.avail_out;
-}
-
-bool Compression::isOpen() const {
-    ai_assert(mImpl != nullptr);
-
-    return mImpl->mOpen;
-}
-
-bool Compression::close() {
-    ai_assert(mImpl != nullptr);
-
-    if (!mImpl->mOpen) {
-        return false;
-    }
-
-    inflateEnd(&mImpl->mZSstream);
-    mImpl->mOpen = false;
-
-    return true;
-}
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/Compression.h b/libs/assimp/code/Common/Compression.h
deleted file mode 100644
index edf1d23..0000000
--- a/libs/assimp/code/Common/Compression.h
+++ /dev/null
@@ -1,121 +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
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#include <zlib.h>
-#else
-#include "../contrib/zlib/zlib.h"
-#endif
-
-#include <vector>
-#include <cstddef> // size_t
-
-namespace Assimp {
-
-/// @brief This class provides the decompression of zlib-compressed data.
-class Compression {
-public:
-    static const int MaxWBits = MAX_WBITS;
-
-    /// @brief Describes the format data type
-    enum class Format {
-        InvalidFormat = -1, ///< Invalid enum type.
-        Binary = 0,         ///< Binary format.
-        ASCII,              ///< ASCII format.
-
-        NumFormats          ///< The number of supported formats.
-    };
-
-    /// @brief The supported flush mode, used for blocked access.
-    enum class FlushMode {
-        InvalidFormat = -1, ///< Invalid enum type.
-        NoFlush = 0,        ///< No flush, will be done on inflate end.
-        Block,              ///< Assists in combination of compress.
-        Tree,               ///< Assists in combination of compress and returns if stream is finish.
-        SyncFlush,          ///< Synced flush mode.
-        Finish,             ///< Finish mode, all in once, no block access.
-
-        NumModes            ///< The number of supported modes.
-    };
-
-    /// @brief  The class constructor.
-    Compression();
-
-    ///	@brief  The class destructor.
-    ~Compression();
-
-    /// @brief  Will open the access to the compression.
-    /// @param[in] format       The format type
-    /// @param[in] flush        The flush mode.
-    /// @param[in] windowBits   The windows history working size, shall be between 8 and 15.
-    /// @return true if close was successful, false if not.
-    bool open(Format format, FlushMode flush, int windowBits);
-
-    /// @brief  Will return the open state.
-    /// @return true if the access is opened, false if not.
-    bool isOpen() const;
-
-    /// @brief  Will close the decompress access.
-    /// @return true if close was successful, false if not.
-    bool close();
-
-    /// @brief Will decompress the data buffer in one step.
-    /// @param[in] data         The data to decompress
-    /// @param[in] in           The size of the data.
-    /// @param[out uncompressed A std::vector containing the decompressed data.
-    size_t decompress(const void *data, size_t in, std::vector<char> &uncompressed);
-
-    /// @brief Will decompress the data buffer block-wise.
-    /// @param[in]  data         The compressed data
-    /// @param[in]  in           The size of the data buffer
-    /// @param[out] out          The output buffer
-    /// @param[out] availableOut The upper limit of the output buffer.
-    /// @return The size of the decompressed data buffer.
-    size_t decompressBlock(const void *data, size_t in, char *out, size_t availableOut);
-
-private:
-    struct impl;
-    impl *mImpl;
-};
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/CreateAnimMesh.cpp b/libs/assimp/code/Common/CreateAnimMesh.cpp
deleted file mode 100644
index 58f3d90..0000000
--- a/libs/assimp/code/Common/CreateAnimMesh.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (C) 2016 The Qt Company Ltd.
-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 <assimp/CreateAnimMesh.h>
-
-namespace Assimp    {
-
-aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh, bool needPositions, bool needNormals, bool needTangents, bool needColors, bool needTexCoords)
-{
-    aiAnimMesh *animesh = new aiAnimMesh;
-    animesh->mNumVertices = mesh->mNumVertices;
-    if (needPositions && mesh->mVertices) {
-        animesh->mVertices = new aiVector3D[animesh->mNumVertices];
-        std::memcpy(animesh->mVertices, mesh->mVertices, mesh->mNumVertices * sizeof(aiVector3D));
-    }
-    if (needNormals && mesh->mNormals) {
-        animesh->mNormals = new aiVector3D[animesh->mNumVertices];
-        std::memcpy(animesh->mNormals, mesh->mNormals, mesh->mNumVertices * sizeof(aiVector3D));
-    }
-    if (needTangents && mesh->mTangents) {
-        animesh->mTangents = new aiVector3D[animesh->mNumVertices];
-        std::memcpy(animesh->mTangents, mesh->mTangents, mesh->mNumVertices * sizeof(aiVector3D));
-    }
-    if (needTangents && mesh->mBitangents) {
-        animesh->mBitangents = new aiVector3D[animesh->mNumVertices];
-        std::memcpy(animesh->mBitangents, mesh->mBitangents, mesh->mNumVertices * sizeof(aiVector3D));
-    }
-
-    if (needColors) {
-        for (int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
-            if (mesh->mColors[i]) {
-                animesh->mColors[i] = new aiColor4D[animesh->mNumVertices];
-                std::memcpy(animesh->mColors[i], mesh->mColors[i], mesh->mNumVertices * sizeof(aiColor4D));
-            } else {
-                animesh->mColors[i] = nullptr;
-            }
-        }
-    }
-
-    if (needTexCoords) {
-        for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-            if (mesh->mTextureCoords[i]) {
-                animesh->mTextureCoords[i] = new aiVector3D[animesh->mNumVertices];
-                std::memcpy(animesh->mTextureCoords[i], mesh->mTextureCoords[i], mesh->mNumVertices * sizeof(aiVector3D));
-            } else {
-                animesh->mTextureCoords[i] = nullptr;
-            }
-        }
-    }
-    return animesh;
-}
-
-} // end of namespace Assimp
diff --git a/libs/assimp/code/Common/DefaultIOStream.cpp b/libs/assimp/code/Common/DefaultIOStream.cpp
deleted file mode 100644
index e30f26a..0000000
--- a/libs/assimp/code/Common/DefaultIOStream.cpp
+++ /dev/null
@@ -1,180 +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.
----------------------------------------------------------------------------
-*/
-/** @file  DefaultIOStream.cpp
- *  @brief Default File I/O implementation for #Importer
- */
-
-#include <assimp/DefaultIOStream.h>
-#include <assimp/ai_assert.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-using namespace Assimp;
-
-namespace {
-
-template <size_t sizeOfPointer>
-inline size_t select_ftell(FILE *file) {
-    return ::ftell(file);
-}
-
-template <size_t sizeOfPointer>
-inline int select_fseek(FILE *file, int64_t offset, int origin) {
-    return ::fseek(file, static_cast<long>(offset), origin);
-}
-
-
-
-#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
-template <>
-inline size_t select_ftell<8>(FILE *file) {
-    return (size_t)::_ftelli64(file);
-}
-
-template <>
-inline int select_fseek<8>(FILE *file, int64_t offset, int origin) {
-    return ::_fseeki64(file, offset, origin);
-}
-
-#endif // #if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
-
-} // namespace
-
-// ----------------------------------------------------------------------------------
-DefaultIOStream::~DefaultIOStream() {
-    if (mFile) {
-        ::fclose(mFile);
-    }
-}
-
-// ----------------------------------------------------------------------------------
-size_t DefaultIOStream::Read(void *pvBuffer,
-        size_t pSize,
-        size_t pCount) {
-    if (0 == pCount) {
-        return 0;
-    }
-    ai_assert(nullptr != pvBuffer);
-    ai_assert(0 != pSize);
-
-    return (mFile ? ::fread(pvBuffer, pSize, pCount, mFile) : 0);
-}
-
-// ----------------------------------------------------------------------------------
-size_t DefaultIOStream::Write(const void *pvBuffer,
-        size_t pSize,
-        size_t pCount) {
-    ai_assert(nullptr != pvBuffer);
-    ai_assert(0 != pSize);
-
-    return (mFile ? ::fwrite(pvBuffer, pSize, pCount, mFile) : 0);
-}
-
-// ----------------------------------------------------------------------------------
-aiReturn DefaultIOStream::Seek(size_t pOffset,
-        aiOrigin pOrigin) {
-    if (!mFile) {
-        return AI_FAILURE;
-    }
-
-    // Just to check whether our enum maps one to one with the CRT constants
-    static_assert(aiOrigin_CUR == SEEK_CUR &&
-                          aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET,
-            "aiOrigin_CUR == SEEK_CUR && \
-        aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET");
-
-    // do the seek
-    return (0 == select_fseek<sizeof(void *)>(mFile, (int64_t)pOffset, (int)pOrigin) ? AI_SUCCESS : AI_FAILURE);
-}
-
-// ----------------------------------------------------------------------------------
-size_t DefaultIOStream::Tell() const {
-    if (!mFile) {
-        return 0;
-    }
-    return select_ftell<sizeof(void *)>(mFile);
-}
-
-// ----------------------------------------------------------------------------------
-size_t DefaultIOStream::FileSize() const {
-    if (!mFile || mFilename.empty()) {
-        return 0;
-    }
-
-    if (SIZE_MAX == mCachedSize) {
-
-        // Although fseek/ftell would allow us to reuse the existing file handle here,
-        // it is generally unsafe because:
-        //  - For binary streams, it is not technically well-defined
-        //  - For text files the results are meaningless
-        // That's why we use the safer variant fstat here.
-        //
-        // See here for details:
-        // https://www.securecoding.cert.org/confluence/display/seccode/FIO19-C.+Do+not+use+fseek()+and+ftell()+to+compute+the+size+of+a+regular+file
-#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
-        struct __stat64 fileStat;
-        //using fileno + fstat avoids having to handle the filename
-        int err = _fstat64(_fileno(mFile), &fileStat);
-        if (0 != err)
-            return 0;
-        mCachedSize = (size_t)(fileStat.st_size);
-#elif defined __GNUC__ || defined __APPLE__ || defined __MACH__ || defined __FreeBSD__
-        struct stat fileStat;
-        int err = stat(mFilename.c_str(), &fileStat);
-        if (0 != err)
-            return 0;
-        const unsigned long long cachedSize = fileStat.st_size;
-        mCachedSize = static_cast<size_t>(cachedSize);
-#else
-#error "Unknown platform"
-#endif
-    }
-    return mCachedSize;
-}
-
-// ----------------------------------------------------------------------------------
-void DefaultIOStream::Flush() {
-    if (mFile) {
-        ::fflush(mFile);
-    }
-}
-
-// ----------------------------------------------------------------------------------
diff --git a/libs/assimp/code/Common/DefaultIOSystem.cpp b/libs/assimp/code/Common/DefaultIOSystem.cpp
deleted file mode 100644
index b28910c..0000000
--- a/libs/assimp/code/Common/DefaultIOSystem.cpp
+++ /dev/null
@@ -1,223 +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.
----------------------------------------------------------------------------
-*/
-/** @file Default implementation of IOSystem using the standard C file functions */
-
-#include <assimp/StringComparison.h>
-
-#include <assimp/DefaultIOStream.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/ai_assert.h>
-#include <stdlib.h>
-#include <assimp/DefaultLogger.hpp>
-
-#ifdef __unix__
-#    include <stdlib.h>
-#    include <sys/param.h>
-#endif
-
-#ifdef _WIN32
-#    include <windows.h>
-#endif
-
-using namespace Assimp;
-
-#ifdef _WIN32
-
-const std::wstring wdummy;
-
-static std::wstring Utf8ToWide(const char *in) {
-    if (nullptr == in) {
-        return wdummy;
-    }
-    int size = MultiByteToWideChar(CP_UTF8, 0, in, -1, nullptr, 0);
-    // size includes terminating null; std::wstring adds null automatically
-    std::wstring out(static_cast<size_t>(size) - 1, L'\0');
-    MultiByteToWideChar(CP_UTF8, 0, in, -1, &out[0], size);
-
-    return out;
-}
-
-const std::string dummy;
-
-static std::string WideToUtf8(const wchar_t *in) {
-    if (nullptr == in) {
-        return dummy;
-    }
-    int size = WideCharToMultiByte(CP_UTF8, 0, in, -1, nullptr, 0, nullptr, nullptr);
-    // size includes terminating null; std::string adds null automatically
-    std::string out(static_cast<size_t>(size) - 1, '\0');
-    WideCharToMultiByte(CP_UTF8, 0, in, -1, &out[0], size, nullptr, nullptr);
-
-    return out;
-}
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Tests for the existence of a file at the given path.
-bool DefaultIOSystem::Exists(const char *pFile) const {
-#ifdef _WIN32
-    struct __stat64 filestat;
-    if (_wstat64(Utf8ToWide(pFile).c_str(), &filestat) != 0) {
-        return false;
-    }
-#else
-    FILE *file = ::fopen(pFile, "rb");
-    if (!file) {
-        return false;
-    }
-
-    ::fclose(file);
-#endif
-
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Open a new file with a given path.
-IOStream *DefaultIOSystem::Open(const char *strFile, const char *strMode) {
-    ai_assert(strFile != nullptr);
-    ai_assert(strMode != nullptr);
-    FILE *file;
-#ifdef _WIN32
-    std::wstring name = Utf8ToWide(strFile);
-    if (name.empty()) {
-        return nullptr;
-    }
-
-    file = ::_wfopen(name.c_str(), Utf8ToWide(strMode).c_str());
-#else
-    file = ::fopen(strFile, strMode);
-#endif
-    if (!file) {
-        return nullptr;
-    }
-
-    return new DefaultIOStream(file, strFile);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Closes the given file and releases all resources associated with it.
-void DefaultIOSystem::Close(IOStream *pFile) {
-    delete pFile;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns the operation specific directory separator
-char DefaultIOSystem::getOsSeparator() const {
-#ifndef _WIN32
-    return '/';
-#else
-    return '\\';
-#endif
-}
-
-// ------------------------------------------------------------------------------------------------
-// IOSystem default implementation (ComparePaths isn't a pure virtual function)
-bool IOSystem::ComparePaths(const char *one, const char *second) const {
-    return !ASSIMP_stricmp(one, second);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert a relative path into an absolute path
-inline static std::string MakeAbsolutePath(const char *in) {
-    ai_assert(in);
-    std::string out;
-#ifdef _WIN32
-    wchar_t *ret = ::_wfullpath(nullptr, Utf8ToWide(in).c_str(), 0);
-    if (ret) {
-        out = WideToUtf8(ret);
-        free(ret);
-    }
-#else
-    char *ret = realpath(in, nullptr);
-    if (ret) {
-        out = ret;
-        free(ret);
-    }
-#endif
-    else {
-        // preserve the input path, maybe someone else is able to fix
-        // the path before it is accessed (e.g. our file system filter)
-        ASSIMP_LOG_WARN("Invalid path: ", std::string(in));
-        out = in;
-    }
-    return out;
-}
-
-// ------------------------------------------------------------------------------------------------
-// DefaultIOSystem's more specialized implementation
-bool DefaultIOSystem::ComparePaths(const char *one, const char *second) const {
-    // chances are quite good both paths are formatted identically,
-    // so we can hopefully return here already
-    if (!ASSIMP_stricmp(one, second))
-        return true;
-
-    std::string temp1 = MakeAbsolutePath(one);
-    std::string temp2 = MakeAbsolutePath(second);
-
-    return !ASSIMP_stricmp(temp1, temp2);
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string DefaultIOSystem::fileName(const std::string &path) {
-    std::string ret = path;
-    std::size_t last = ret.find_last_of("\\/");
-    if (last != std::string::npos) ret = ret.substr(last + 1);
-    return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string DefaultIOSystem::completeBaseName(const std::string &path) {
-    std::string ret = fileName(path);
-    std::size_t pos = ret.find_last_of('.');
-    if (pos != std::string::npos) ret = ret.substr(0, pos);
-    return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string DefaultIOSystem::absolutePath(const std::string &path) {
-    std::string ret = path;
-    std::size_t last = ret.find_last_of("\\/");
-    if (last != std::string::npos) ret = ret.substr(0, last);
-    return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
diff --git a/libs/assimp/code/Common/DefaultLogger.cpp b/libs/assimp/code/Common/DefaultLogger.cpp
deleted file mode 100644
index 5cb32d3..0000000
--- a/libs/assimp/code/Common/DefaultLogger.cpp
+++ /dev/null
@@ -1,430 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file  DefaultLogger.cpp
- *  @brief Implementation of DefaultLogger (and Logger)
- */
-
-// Default log streams
-#include "FileLogStream.h"
-#include "StdOStreamLogStream.h"
-#include "Win32DebugLogStream.h"
-#include <assimp/StringUtils.h>
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/ai_assert.h>
-#include <stdio.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/NullLogger.hpp>
-#include <iostream>
-
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-#include <mutex>
-#include <thread>
-std::mutex loggerMutex;
-#endif
-
-namespace Assimp {
-
-// ----------------------------------------------------------------------------------
-NullLogger DefaultLogger::s_pNullLogger;
-Logger *DefaultLogger::m_pLogger = &DefaultLogger::s_pNullLogger;
-
-static const unsigned int SeverityAll = Logger::Info | Logger::Err | Logger::Warn | Logger::Debugging;
-
-// ----------------------------------------------------------------------------------
-// Represents a log-stream + its error severity
-struct LogStreamInfo {
-    unsigned int m_uiErrorSeverity;
-    LogStream *m_pStream;
-
-    // Constructor
-    LogStreamInfo(unsigned int uiErrorSev, LogStream *pStream) :
-            m_uiErrorSeverity(uiErrorSev),
-            m_pStream(pStream) {
-        // empty
-    }
-
-    // Destructor
-    ~LogStreamInfo() {
-        delete m_pStream;
-    }
-};
-
-// ----------------------------------------------------------------------------------
-// Construct a default log stream
-LogStream *LogStream::createDefaultStream(aiDefaultLogStream streams,
-        const char *name /*= "AssimpLog.txt"*/,
-        IOSystem *io /*= nullptr*/) {
-    switch (streams) {
-        // This is a platform-specific feature
-    case aiDefaultLogStream_DEBUGGER:
-#ifdef WIN32
-        return new Win32DebugLogStream();
-#else
-        return nullptr;
-#endif
-
-    // Platform-independent default streams
-    case aiDefaultLogStream_STDERR:
-        return new StdOStreamLogStream(std::cerr);
-    case aiDefaultLogStream_STDOUT:
-        return new StdOStreamLogStream(std::cout);
-    case aiDefaultLogStream_FILE:
-        return (name && *name ? new FileLogStream(name, io) : nullptr);
-    default:
-        // We don't know this default log stream, so raise an assertion
-        ai_assert(false);
-    };
-
-    // For compilers without dead code path detection
-    return nullptr;
-}
-
-// ----------------------------------------------------------------------------------
-//  Creates the only singleton instance
-Logger *DefaultLogger::create(const char *name /*= "AssimpLog.txt"*/,
-        LogSeverity severity /*= NORMAL*/,
-        unsigned int defStreams /*= aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE*/,
-        IOSystem *io /*= nullptr*/) {
-    // enter the mutex here to avoid concurrency problems
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-    std::lock_guard<std::mutex> lock(loggerMutex);
-#endif
-
-    if (m_pLogger && !isNullLogger()) {
-        delete m_pLogger;
-    }
-
-    m_pLogger = new DefaultLogger(severity);
-
-    // Attach default log streams
-    // Stream the log to the MSVC debugger?
-    if (defStreams & aiDefaultLogStream_DEBUGGER) {
-        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_DEBUGGER));
-    }
-
-    // Stream the log to COUT?
-    if (defStreams & aiDefaultLogStream_STDOUT) {
-        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_STDOUT));
-    }
-
-    // Stream the log to CERR?
-    if (defStreams & aiDefaultLogStream_STDERR) {
-        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_STDERR));
-    }
-
-    // Stream the log to a file
-    if (defStreams & aiDefaultLogStream_FILE && name && *name) {
-        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_FILE, name, io));
-    }
-
-    return m_pLogger;
-}
-
-// ----------------------------------------------------------------------------------
-void Logger::debug(const char *message) {
-
-    // SECURITY FIX: otherwise it's easy to produce overruns since
-    // sometimes importers will include data from the input file
-    // (i.e. node names) in their messages.
-    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
-        return OnDebug("<fixme: long message discarded>");
-    }
-    return OnDebug(message);
-}
-
-// ----------------------------------------------------------------------------------
-void Logger::verboseDebug(const char *message) {
-
-    // SECURITY FIX: see above
-    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
-        return OnVerboseDebug("<fixme: long message discarded>");
-    }
-    return OnVerboseDebug(message);
-}
-
-// ----------------------------------------------------------------------------------
-void Logger::info(const char *message) {
-
-    // SECURITY FIX: see above
-    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
-        return OnInfo("<fixme: long message discarded>");
-    }
-    return OnInfo(message);
-}
-
-// ----------------------------------------------------------------------------------
-void Logger::warn(const char *message) {
-
-    // SECURITY FIX: see above
-    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
-        return OnWarn("<fixme: long message discarded>");
-    }
-    return OnWarn(message);
-}
-
-// ----------------------------------------------------------------------------------
-void Logger::error(const char *message) {
-    // SECURITY FIX: see above
-    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
-        return OnError("<fixme: long message discarded>");
-    }
-    return OnError(message);
-}
-
-// ----------------------------------------------------------------------------------
-void DefaultLogger::set(Logger *logger) {
-    // enter the mutex here to avoid concurrency problems
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-    std::lock_guard<std::mutex> lock(loggerMutex);
-#endif
-
-    if (nullptr == logger) {
-        logger = &s_pNullLogger;
-    }
-    if (nullptr != m_pLogger && !isNullLogger()) {
-        delete m_pLogger;
-    }
-
-    DefaultLogger::m_pLogger = logger;
-}
-
-// ----------------------------------------------------------------------------------
-bool DefaultLogger::isNullLogger() {
-    return m_pLogger == &s_pNullLogger;
-}
-
-// ----------------------------------------------------------------------------------
-Logger *DefaultLogger::get() {
-    return m_pLogger;
-}
-
-// ----------------------------------------------------------------------------------
-//  Kills the only instance
-void DefaultLogger::kill() {
-    // enter the mutex here to avoid concurrency problems
-#ifndef ASSIMP_BUILD_SINGLETHREADED
-    std::lock_guard<std::mutex> lock(loggerMutex);
-#endif
-
-    if (m_pLogger == &s_pNullLogger) {
-        return;
-    }
-    delete m_pLogger;
-    m_pLogger = &s_pNullLogger;
-}
-
-// ----------------------------------------------------------------------------------
-//  Debug message
-void DefaultLogger::OnDebug(const char *message) {
-    if (m_Severity < Logger::DEBUGGING) {
-        return;
-    }
-
-    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-    char msg[Size];
-    ai_snprintf(msg, Size, "Debug, T%u: %s", GetThreadID(), message);
-
-    WriteToStreams(msg, Logger::Debugging);
-}
-
-//  Verbose debug message
-void DefaultLogger::OnVerboseDebug(const char *message) {
-    if (m_Severity < Logger::VERBOSE) {
-        return;
-    }
-
-    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-    char msg[Size];
-    ai_snprintf(msg, Size, "Debug, T%u: %s", GetThreadID(), message);
-
-    WriteToStreams(msg, Logger::Debugging);
-}
-
-// ----------------------------------------------------------------------------------
-//  Logs an info
-void DefaultLogger::OnInfo(const char *message) {
-    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-    char msg[Size];
-    ai_snprintf(msg, Size, "Info,  T%u: %s", GetThreadID(), message);
-
-    WriteToStreams(msg, Logger::Info);
-}
-
-// ----------------------------------------------------------------------------------
-//  Logs a warning
-void DefaultLogger::OnWarn(const char *message) {
-    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-    char msg[Size];
-    ai_snprintf(msg, Size, "Warn,  T%u: %s", GetThreadID(), message);
-
-    WriteToStreams(msg, Logger::Warn);
-}
-
-// ----------------------------------------------------------------------------------
-//  Logs an error
-void DefaultLogger::OnError(const char *message) {
-    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-    char msg[Size];
-    ai_snprintf(msg, Size, "Error, T%u: %s", GetThreadID(), message);
-
-    WriteToStreams(msg, Logger::Err);
-}
-
-// ----------------------------------------------------------------------------------
-//  Will attach a new stream
-bool DefaultLogger::attachStream(LogStream *pStream, unsigned int severity) {
-    if (nullptr == pStream) {
-        return false;
-    }
-
-    if (0 == severity) {
-        severity = Logger::Info | Logger::Err | Logger::Warn | Logger::Debugging;
-    }
-
-    for (StreamIt it = m_StreamArray.begin();
-            it != m_StreamArray.end();
-            ++it) {
-        if ((*it)->m_pStream == pStream) {
-            (*it)->m_uiErrorSeverity |= severity;
-            return true;
-        }
-    }
-
-    LogStreamInfo *pInfo = new LogStreamInfo(severity, pStream);
-    m_StreamArray.push_back(pInfo);
-    return true;
-}
-
-// ----------------------------------------------------------------------------------
-//  Detach a stream
-bool DefaultLogger::detachStream(LogStream *pStream, unsigned int severity) {
-    if (nullptr == pStream) {
-        return false;
-    }
-
-    if (0 == severity) {
-        severity = SeverityAll;
-    }
-
-    bool res(false);
-    for (StreamIt it = m_StreamArray.begin(); it != m_StreamArray.end(); ++it) {
-        if ((*it)->m_pStream == pStream) {
-            (*it)->m_uiErrorSeverity &= ~severity;
-            if ((*it)->m_uiErrorSeverity == 0) {
-                // don't delete the underlying stream 'cause the caller gains ownership again
-                (**it).m_pStream = nullptr;
-                delete *it;
-                m_StreamArray.erase(it);
-                res = true;
-                break;
-            }
-            return true;
-        }
-    }
-    return res;
-}
-
-// ----------------------------------------------------------------------------------
-//  Constructor
-DefaultLogger::DefaultLogger(LogSeverity severity) :
-        Logger(severity), noRepeatMsg(false), lastLen(0) {
-    lastMsg[0] = '\0';
-}
-
-// ----------------------------------------------------------------------------------
-//  Destructor
-DefaultLogger::~DefaultLogger() {
-    for (StreamIt it = m_StreamArray.begin(); it != m_StreamArray.end(); ++it) {
-        // also frees the underlying stream, we are its owner.
-        delete *it;
-    }
-}
-
-// ----------------------------------------------------------------------------------
-//  Writes message to stream
-void DefaultLogger::WriteToStreams(const char *message, ErrorSeverity ErrorSev) {
-    ai_assert(nullptr != message);
-
-    // Check whether this is a repeated message
-    auto thisLen = ::strlen(message);
-    if (thisLen == lastLen - 1 && !::strncmp(message, lastMsg, lastLen - 1)) {
-        if (!noRepeatMsg) {
-            noRepeatMsg = true;
-            message = "Skipping one or more lines with the same contents\n";
-        }
-        return;
-    } else {
-        // append a new-line character to the message to be printed
-        lastLen = thisLen;
-        ::memcpy(lastMsg, message, lastLen + 1);
-        ::strcat(lastMsg + lastLen, "\n");
-
-        message = lastMsg;
-        noRepeatMsg = false;
-        ++lastLen;
-    }
-    for (ConstStreamIt it = m_StreamArray.begin();
-            it != m_StreamArray.end();
-            ++it) {
-        if (ErrorSev & (*it)->m_uiErrorSeverity)
-            (*it)->m_pStream->write(message);
-    }
-}
-
-// ----------------------------------------------------------------------------------
-//  Returns thread id, if not supported only a zero will be returned.
-unsigned int DefaultLogger::GetThreadID() {
-    // fixme: we can get this value via std::threads
-    // std::this_thread::get_id().hash() returns a (big) size_t, not sure if this is useful in this case.
-#ifdef WIN32
-    return (unsigned int)::GetCurrentThreadId();
-#else
-    return 0; // not supported
-#endif
-}
-
-// ----------------------------------------------------------------------------------
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/DefaultProgressHandler.h b/libs/assimp/code/Common/DefaultProgressHandler.h
deleted file mode 100644
index ac1bb68..0000000
--- a/libs/assimp/code/Common/DefaultProgressHandler.h
+++ /dev/null
@@ -1,66 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file ProgressHandler.hpp
- *  @brief Abstract base class 'ProgressHandler'.
- */
-#ifndef INCLUDED_AI_DEFAULTPROGRESSHANDLER_H
-#define INCLUDED_AI_DEFAULTPROGRESSHANDLER_H
-
-#include <assimp/ProgressHandler.hpp>
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------
-/**
- *  @brief Internal default implementation of the #ProgressHandler interface.
- */
-class DefaultProgressHandler : public ProgressHandler    {
-public:
-    ///	@brief Ignores the update callback.
-    bool Update(float) override {
-        return false;
-    }
-};
-
-} // Namespace Assimp
-
-#endif // INCLUDED_AI_DEFAULTPROGRESSHANDLER_H
diff --git a/libs/assimp/code/Common/Exceptional.cpp b/libs/assimp/code/Common/Exceptional.cpp
deleted file mode 100644
index b25281a..0000000
--- a/libs/assimp/code/Common/Exceptional.cpp
+++ /dev/null
@@ -1,52 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Exceptional.cpp
-
-Implementations of the exception classes.
-
-*/
-
-#include <assimp/Exceptional.h>
-#include <assimp/TinyFormatter.h>
-
-DeadlyErrorBase::DeadlyErrorBase(Assimp::Formatter::format f) :
-        runtime_error(std::string(f)){}
diff --git a/libs/assimp/code/Common/Exporter.cpp b/libs/assimp/code/Common/Exporter.cpp
deleted file mode 100644
index 9a4e2cf..0000000
--- a/libs/assimp/code/Common/Exporter.cpp
+++ /dev/null
@@ -1,695 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Exporter.cpp
-
-Assimp export interface. While it's public interface bears many similarities
-to the import interface (in fact, it is largely symmetric), the internal
-implementations differs a lot. Exporters are considered stateless and are
-simple callbacks which we maintain in a global list along with their
-description strings.
-
-Here we implement only the C++ interface (Assimp::Exporter).
-*/
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-
-#include <assimp/BlobIOSystem.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/Exporter.hpp>
-#include <assimp/mesh.h>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <assimp/Exceptional.h>
-
-#include "Common/DefaultProgressHandler.h"
-#include "Common/BaseProcess.h"
-#include "Common/ScenePrivate.h"
-#include "PostProcessing/CalcTangentsProcess.h"
-#include "PostProcessing/MakeVerboseFormat.h"
-#include "PostProcessing/JoinVerticesProcess.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-#include "PostProcessing/PretransformVertices.h"
-
-#include <memory>
-
-namespace Assimp {
-
-#ifdef _MSC_VER
-#    pragma warning( disable : 4800 )
-#endif // _MSC_VER
-
-
-// PostStepRegistry.cpp
-void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
-
-// ------------------------------------------------------------------------------------------------
-// Exporter worker function prototypes. Do not use const, because some exporter need to convert
-// the scene temporary
-#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-void ExportSceneCollada(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_X_EXPORTER
-void ExportSceneXFile(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
-void ExportSceneStep(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
-void ExportSceneObj(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneObjNoMtl(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_STL_EXPORTER
-void ExportSceneSTL(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneSTLBinary(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_PLY_EXPORTER
-void ExportScenePly(const char*,IOSystem*, const aiScene*, const ExportProperties*);
-void ExportScenePlyBinary(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
-void ExportScene3DS(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
-void ExportSceneGLTF(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneGLB(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneGLTF2(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneGLB2(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
-void ExportSceneAssbin(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
-void ExportSceneAssxml(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
-void ExportSceneX3D(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
-void ExportSceneFBX(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneFBXA(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
-void ExportScene3MF( const char*, IOSystem*, const aiScene*, const ExportProperties* );
-#endif
-#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
-void ExportSceneM3D(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneM3DA(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
-void ExportAssimp2Json(const char* , IOSystem*, const aiScene* , const Assimp::ExportProperties*);
-#endif
-#ifndef ASSIMP_BUILD_NO_PBRT_EXPORTER
-void ExportScenePbrt(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-#endif
-
-static void setupExporterArray(std::vector<Exporter::ExportFormatEntry> &exporters) {
-	(void)exporters;
-
-#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_X_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("x", "X Files", "x", &ExportSceneXFile,
-			aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("stp", "Step Files", "stp", &ExportSceneStep, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("obj", "Wavefront OBJ format", "obj", &ExportSceneObj,
-			aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */));
-	exporters.push_back(Exporter::ExportFormatEntry("objnomtl", "Wavefront OBJ format without material file", "obj", &ExportSceneObjNoMtl,
-			aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_STL_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("stl", "Stereolithography", "stl", &ExportSceneSTL,
-			aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices));
-	exporters.push_back(Exporter::ExportFormatEntry("stlb", "Stereolithography (binary)", "stl", &ExportSceneSTLBinary,
-			aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_PLY_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("ply", "Stanford Polygon Library", "ply", &ExportScenePly,
-			aiProcess_PreTransformVertices));
-	exporters.push_back(Exporter::ExportFormatEntry("plyb", "Stanford Polygon Library (binary)", "ply", &ExportScenePlyBinary,
-			aiProcess_PreTransformVertices));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("3ds", "Autodesk 3DS (legacy)", "3ds", &ExportScene3DS,
-			aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_JoinIdenticalVertices));
-#endif
-
-#if !defined(ASSIMP_BUILD_NO_GLTF_EXPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_EXPORTER)
-	exporters.push_back(Exporter::ExportFormatEntry("gltf2", "GL Transmission Format v. 2", "gltf", &ExportSceneGLTF2,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-	exporters.push_back(Exporter::ExportFormatEntry("glb2", "GL Transmission Format v. 2 (binary)", "glb", &ExportSceneGLB2,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-#endif
-
-#if !defined(ASSIMP_BUILD_NO_GLTF_EXPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_EXPORTER)
-	exporters.push_back(Exporter::ExportFormatEntry("gltf", "GL Transmission Format", "gltf", &ExportSceneGLTF,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-	exporters.push_back(Exporter::ExportFormatEntry("glb", "GL Transmission Format (binary)", "glb", &ExportSceneGLB,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("assbin", "Assimp Binary File", "assbin", &ExportSceneAssbin, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("assxml", "Assimp XML Document", "assxml", &ExportSceneAssxml, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("x3d", "Extensible 3D", "x3d", &ExportSceneX3D, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("fbx", "Autodesk FBX (binary)", "fbx", &ExportSceneFBX, 0));
-	exporters.push_back(Exporter::ExportFormatEntry("fbxa", "Autodesk FBX (ascii)", "fbx", &ExportSceneFBXA, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("m3d", "Model 3D (binary)", "m3d", &ExportSceneM3D, 0));
-	exporters.push_back(Exporter::ExportFormatEntry("m3da", "Model 3D (ascii)", "a3d", &ExportSceneM3DA, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("3mf", "The 3MF-File-Format", "3mf", &ExportScene3MF, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_PBRT_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("pbrt", "pbrt-v4 scene description file", "pbrt", &ExportScenePbrt, aiProcess_Triangulate | aiProcess_SortByPType));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("assjson", "Assimp JSON Document", "json", &ExportAssimp2Json, 0));
-#endif
-}
-
-class ExporterPimpl {
-public:
-    ExporterPimpl()
-    : blob()
-    , mIOSystem(new Assimp::DefaultIOSystem())
-    , mIsDefaultIOHandler(true)
-    , mProgressHandler( nullptr )
-    , mIsDefaultProgressHandler( true )
-    , mPostProcessingSteps()
-    , mError()
-    , mExporters() {
-        GetPostProcessingStepInstanceList(mPostProcessingSteps);
-
-        // grab all built-in exporters
-		setupExporterArray(mExporters);
-    }
-
-    ~ExporterPimpl() {
-        delete blob;
-
-        // Delete all post-processing plug-ins
-        for( unsigned int a = 0; a < mPostProcessingSteps.size(); a++) {
-            delete mPostProcessingSteps[a];
-        }
-        delete mProgressHandler;
-    }
-
-public:
-    aiExportDataBlob* blob;
-    std::shared_ptr< Assimp::IOSystem > mIOSystem;
-    bool mIsDefaultIOHandler;
-
-    /** The progress handler */
-    ProgressHandler *mProgressHandler;
-    bool mIsDefaultProgressHandler;
-
-    /** Post processing steps we can apply at the imported data. */
-    std::vector< BaseProcess* > mPostProcessingSteps;
-
-    /** Last fatal export error */
-    std::string mError;
-
-    /** Exporters, this includes those registered using #Assimp::Exporter::RegisterExporter */
-    std::vector<Exporter::ExportFormatEntry> mExporters;
-};
-
-} // end of namespace Assimp
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-Exporter :: Exporter()
-: pimpl(new ExporterPimpl()) {
-    pimpl->mProgressHandler = new DefaultProgressHandler();
-}
-
-// ------------------------------------------------------------------------------------------------
-Exporter::~Exporter() {
-	ai_assert(nullptr != pimpl);
-	FreeBlob();
-    delete pimpl;
-}
-
-// ------------------------------------------------------------------------------------------------
-void Exporter::SetIOHandler( IOSystem* pIOHandler) {
-	ai_assert(nullptr != pimpl);
-	pimpl->mIsDefaultIOHandler = !pIOHandler;
-    pimpl->mIOSystem.reset(pIOHandler);
-}
-
-// ------------------------------------------------------------------------------------------------
-IOSystem* Exporter::GetIOHandler() const {
-	ai_assert(nullptr != pimpl);
-	return pimpl->mIOSystem.get();
-}
-
-// ------------------------------------------------------------------------------------------------
-bool Exporter::IsDefaultIOHandler() const {
-	ai_assert(nullptr != pimpl);
-	return pimpl->mIsDefaultIOHandler;
-}
-
-// ------------------------------------------------------------------------------------------------
-void Exporter::SetProgressHandler(ProgressHandler* pHandler) {
-    ai_assert(nullptr != pimpl);
-
-    if ( nullptr == pHandler) {
-        // Release pointer in the possession of the caller
-        pimpl->mProgressHandler = new DefaultProgressHandler();
-        pimpl->mIsDefaultProgressHandler = true;
-        return;
-    }
-
-    if (pimpl->mProgressHandler == pHandler) {
-        return;
-    }
-
-    delete pimpl->mProgressHandler;
-    pimpl->mProgressHandler = pHandler;
-    pimpl->mIsDefaultProgressHandler = false;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const char* pFormatId,
-                                                unsigned int pPreprocessing, const ExportProperties* pProperties) {
-	ai_assert(nullptr != pimpl);
-    if (pimpl->blob) {
-        delete pimpl->blob;
-        pimpl->blob = nullptr;
-    }
-
-    auto baseName = pProperties ? pProperties->GetPropertyString(AI_CONFIG_EXPORT_BLOB_NAME, AI_BLOBIO_MAGIC) : AI_BLOBIO_MAGIC;
-
-    std::shared_ptr<IOSystem> old = pimpl->mIOSystem;
-    BlobIOSystem *blobio = new BlobIOSystem(baseName);
-    pimpl->mIOSystem = std::shared_ptr<IOSystem>( blobio );
-
-    if (AI_SUCCESS != Export(pScene,pFormatId,blobio->GetMagicFileName(), pPreprocessing, pProperties)) {
-        pimpl->mIOSystem = old;
-        return nullptr;
-    }
-
-    pimpl->blob = blobio->GetBlobChain();
-    pimpl->mIOSystem = old;
-
-    return pimpl->blob;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const char* pPath,
-        unsigned int pPreprocessing, const ExportProperties* pProperties) {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-	ai_assert(nullptr != pimpl);
-    // when they create scenes from scratch, users will likely create them not in verbose
-    // format. They will likely not be aware that there is a flag in the scene to indicate
-    // this, however. To avoid surprises and bug reports, we check for duplicates in
-    // meshes upfront.
-    const bool is_verbose_format = !(pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) || MakeVerboseFormatProcess::IsVerboseFormat(pScene);
-
-    pimpl->mProgressHandler->UpdateFileWrite(0, 4);
-
-    pimpl->mError = "";
-    for (size_t i = 0; i < pimpl->mExporters.size(); ++i) {
-        const Exporter::ExportFormatEntry& exp = pimpl->mExporters[i];
-        if (!strcmp(exp.mDescription.id,pFormatId)) {
-            try {
-                // Always create a full copy of the scene. We might optimize this one day,
-                // but for now it is the most pragmatic way.
-                aiScene* scenecopy_tmp = nullptr;
-                SceneCombiner::CopyScene(&scenecopy_tmp,pScene);
-
-                pimpl->mProgressHandler->UpdateFileWrite(1, 4);
-
-                std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
-                const ScenePrivateData* const priv = ScenePriv(pScene);
-
-                // steps that are not idempotent, i.e. we might need to run them again, usually to get back to the
-                // original state before the step was applied first. When checking which steps we don't need
-                // to run, those are excluded.
-                const unsigned int nonIdempotentSteps = aiProcess_FlipWindingOrder | aiProcess_FlipUVs | aiProcess_MakeLeftHanded;
-
-                // Erase all pp steps that were already applied to this scene
-                const unsigned int pp = (exp.mEnforcePP | pPreprocessing) & ~(priv && !priv->mIsCopy
-                    ? (priv->mPPStepsApplied & ~nonIdempotentSteps)
-                    : 0u);
-
-                // If no extra post-processing was specified, and we obtained this scene from an
-                // Assimp importer, apply the reverse steps automatically.
-                // TODO: either drop this, or document it. Otherwise it is just a bad surprise.
-                //if (!pPreprocessing && priv) {
-                //  pp |= (nonIdempotentSteps & priv->mPPStepsApplied);
-                //}
-
-                // If the input scene is not in verbose format, but there is at least post-processing step that relies on it,
-                // we need to run the MakeVerboseFormat step first.
-                bool must_join_again = false;
-                if (!is_verbose_format) {
-                    bool verbosify = false;
-                    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
-                        BaseProcess* const p = pimpl->mPostProcessingSteps[a];
-
-                        if (p->IsActive(pp) && p->RequireVerboseFormat()) {
-                            verbosify = true;
-                            break;
-                        }
-                    }
-
-                    if (verbosify || (exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
-                        ASSIMP_LOG_DEBUG("export: Scene data not in verbose format, applying MakeVerboseFormat step first");
-
-                        MakeVerboseFormatProcess proc;
-                        proc.Execute(scenecopy.get());
-
-                        if(!(exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
-                            must_join_again = true;
-                        }
-                    }
-                }
-
-                pimpl->mProgressHandler->UpdateFileWrite(2, 4);
-
-                if (pp) {
-                    // the three 'conversion' steps need to be executed first because all other steps rely on the standard data layout
-                    {
-                        FlipWindingOrderProcess step;
-                        if (step.IsActive(pp)) {
-                            step.Execute(scenecopy.get());
-                        }
-                    }
-
-                    {
-                        FlipUVsProcess step;
-                        if (step.IsActive(pp)) {
-                            step.Execute(scenecopy.get());
-                        }
-                    }
-
-                    {
-                        MakeLeftHandedProcess step;
-                        if (step.IsActive(pp)) {
-                            step.Execute(scenecopy.get());
-                        }
-                    }
-
-                    bool exportPointCloud(false);
-                    if (nullptr != pProperties) {
-                        exportPointCloud = pProperties->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
-                    }
-
-                    // dispatch other processes
-                    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
-                        BaseProcess* const p = pimpl->mPostProcessingSteps[a];
-
-                        if (p->IsActive(pp)
-                            && !dynamic_cast<FlipUVsProcess*>(p)
-                            && !dynamic_cast<FlipWindingOrderProcess*>(p)
-                            && !dynamic_cast<MakeLeftHandedProcess*>(p)) {
-                            if (dynamic_cast<PretransformVertices*>(p) && exportPointCloud) {
-                                continue;
-                            }
-                            p->Execute(scenecopy.get());
-                        }
-                    }
-                    ScenePrivateData* const privOut = ScenePriv(scenecopy.get());
-                    ai_assert(nullptr != privOut);
-
-                    privOut->mPPStepsApplied |= pp;
-                }
-
-                pimpl->mProgressHandler->UpdateFileWrite(3, 4);
-
-                if(must_join_again) {
-                    JoinVerticesProcess proc;
-                    proc.Execute(scenecopy.get());
-                }
-
-                ExportProperties emptyProperties;  // Never pass nullptr ExportProperties so Exporters don't have to worry.
-                ExportProperties* pProp = pProperties ? (ExportProperties*)pProperties : &emptyProperties;
-        		pProp->SetPropertyBool("bJoinIdenticalVertices", pp & aiProcess_JoinIdenticalVertices);
-                exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProp);
-
-                pimpl->mProgressHandler->UpdateFileWrite(4, 4);
-            } catch (DeadlyExportError& err) {
-                pimpl->mError = err.what();
-                return AI_FAILURE;
-            }
-            return AI_SUCCESS;
-        }
-    }
-
-    pimpl->mError = std::string("Found no exporter to handle this file format: ") + pFormatId;
-    ASSIMP_END_EXCEPTION_REGION(aiReturn);
-
-    return AI_FAILURE;
-}
-
-// ------------------------------------------------------------------------------------------------
-const char* Exporter::GetErrorString() const {
-	ai_assert(nullptr != pimpl);
-    return pimpl->mError.c_str();
-}
-
-// ------------------------------------------------------------------------------------------------
-void Exporter::FreeBlob() {
-	ai_assert(nullptr != pimpl);
-    delete pimpl->blob;
-    pimpl->blob = nullptr;
-
-    pimpl->mError = "";
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiExportDataBlob* Exporter::GetBlob() const {
-	ai_assert(nullptr != pimpl);
-	return pimpl->blob;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiExportDataBlob* Exporter::GetOrphanedBlob() const {
-	ai_assert(nullptr != pimpl);
-	const aiExportDataBlob *tmp = pimpl->blob;
-    pimpl->blob = nullptr;
-    return tmp;
-}
-
-// ------------------------------------------------------------------------------------------------
-size_t Exporter::GetExportFormatCount() const {
-	ai_assert(nullptr != pimpl);
-    return pimpl->mExporters.size();
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiExportFormatDesc* Exporter::GetExportFormatDescription( size_t index ) const {
-	ai_assert(nullptr != pimpl);
-	if (index >= GetExportFormatCount()) {
-        return nullptr;
-    }
-
-    // Return from static storage if the requested index is built-in.
-	if (index < pimpl->mExporters.size()) {
-		return &pimpl->mExporters[index].mDescription;
-    }
-
-    return &pimpl->mExporters[index].mDescription;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiReturn Exporter::RegisterExporter(const ExportFormatEntry& desc) {
-	ai_assert(nullptr != pimpl);
-	for (const ExportFormatEntry &e : pimpl->mExporters) {
-        if (!strcmp(e.mDescription.id,desc.mDescription.id)) {
-            return aiReturn_FAILURE;
-        }
-    }
-
-    pimpl->mExporters.push_back(desc);
-    return aiReturn_SUCCESS;
-}
-
-// ------------------------------------------------------------------------------------------------
-void Exporter::UnregisterExporter(const char* id) {
-	ai_assert(nullptr != pimpl);
-	for (std::vector<ExportFormatEntry>::iterator it = pimpl->mExporters.begin();
-            it != pimpl->mExporters.end(); ++it) {
-        if (!strcmp((*it).mDescription.id,id)) {
-            pimpl->mExporters.erase(it);
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-ExportProperties::ExportProperties() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-ExportProperties::ExportProperties(const ExportProperties &other)
-: mIntProperties(other.mIntProperties)
-, mFloatProperties(other.mFloatProperties)
-, mStringProperties(other.mStringProperties)
-, mMatrixProperties(other.mMatrixProperties)
-, mCallbackProperties(other.mCallbackProperties){
-    // empty
-}
-
-bool ExportProperties::SetPropertyCallback(const char *szName, const std::function<void *(void *)> &f) {
-    return SetGenericProperty<std::function<void *(void *)>>(mCallbackProperties, szName, f);
-}
-
-std::function<void *(void *)> ExportProperties::GetPropertyCallback(const char *szName) const {
-    return GetGenericProperty<std::function<void *(void *)>>(mCallbackProperties, szName, 0);
-}
-
-bool ExportProperties::HasPropertyCallback(const char *szName) const {
-    return HasGenericProperty<std::function<void *(void *)>>(mCallbackProperties, szName);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool ExportProperties::SetPropertyInteger(const char* szName, int iValue) {
-    return SetGenericProperty<int>(mIntProperties, szName,iValue);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool ExportProperties::SetPropertyFloat(const char* szName, ai_real iValue) {
-    return SetGenericProperty<ai_real>(mFloatProperties, szName,iValue);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool ExportProperties::SetPropertyString(const char* szName, const std::string& value) {
-    return SetGenericProperty<std::string>(mStringProperties, szName,value);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool ExportProperties::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
-    return SetGenericProperty<aiMatrix4x4>(mMatrixProperties, szName,value);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-int ExportProperties::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
-    return GetGenericProperty<int>(mIntProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-ai_real ExportProperties::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
-    return GetGenericProperty<ai_real>(mFloatProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-const std::string ExportProperties::GetPropertyString(const char* szName,
-        const std::string& iErrorReturn /*= ""*/) const {
-    return GetGenericProperty<std::string>(mStringProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Has a configuration property
-const aiMatrix4x4 ExportProperties::GetPropertyMatrix(const char* szName,
-        const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
-    return GetGenericProperty<aiMatrix4x4>(mMatrixProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Has a configuration property
-bool ExportProperties::HasPropertyInteger(const char* szName) const {
-    return HasGenericProperty<int>(mIntProperties, szName);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Has a configuration property
-bool ExportProperties::HasPropertyBool(const char* szName) const {
-    return HasGenericProperty<int>(mIntProperties, szName);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Has a configuration property
-bool ExportProperties::HasPropertyFloat(const char* szName) const {
-    return HasGenericProperty<ai_real>(mFloatProperties, szName);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Has a configuration property
-bool ExportProperties::HasPropertyString(const char* szName) const {
-    return HasGenericProperty<std::string>(mStringProperties, szName);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Has a configuration property
-bool ExportProperties::HasPropertyMatrix(const char* szName) const {
-    return HasGenericProperty<aiMatrix4x4>(mMatrixProperties, szName);
-}
-
-
-#endif // !ASSIMP_BUILD_NO_EXPORT
diff --git a/libs/assimp/code/Common/FileLogStream.h b/libs/assimp/code/Common/FileLogStream.h
deleted file mode 100644
index 3345414..0000000
--- a/libs/assimp/code/Common/FileLogStream.h
+++ /dev/null
@@ -1,100 +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.
-
-----------------------------------------------------------------------
-*/
-/** @file FileLofStream.h
-*/
-#ifndef ASSIMP_FILELOGSTREAM_H_INC
-#define ASSIMP_FILELOGSTREAM_H_INC
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/LogStream.hpp>
-
-namespace Assimp {
-
-// ----------------------------------------------------------------------------------
-/** @class  FileLogStream
- *  @brief  Logstream to write into a file.
- */
-class FileLogStream : public LogStream {
-public:
-    FileLogStream(const char *file, IOSystem *io = nullptr);
-    ~FileLogStream();
-    void write(const char *message);
-
-private:
-    IOStream *m_pStream;
-};
-
-// ----------------------------------------------------------------------------------
-//  Constructor
-inline FileLogStream::FileLogStream(const char *file, IOSystem *io) :
-        m_pStream(nullptr) {
-    if (!file || 0 == *file)
-        return;
-
-    // If no IOSystem is specified: take a default one
-    if (!io) {
-        DefaultIOSystem FileSystem;
-        m_pStream = FileSystem.Open(file, "wt");
-    } else
-        m_pStream = io->Open(file, "wt");
-}
-
-// ----------------------------------------------------------------------------------
-//  Destructor
-inline FileLogStream::~FileLogStream() {
-    // The virtual d'tor should destroy the underlying file
-    delete m_pStream;
-}
-
-// ----------------------------------------------------------------------------------
-//  Write method
-inline void FileLogStream::write(const char *message) {
-    if (m_pStream != nullptr) {
-        m_pStream->Write(message, sizeof(char), ::strlen(message));
-        m_pStream->Flush();
-    }
-}
-
-// ----------------------------------------------------------------------------------
-} // namespace Assimp
-
-#endif // !! ASSIMP_FILELOGSTREAM_H_INC
diff --git a/libs/assimp/code/Common/FileSystemFilter.h b/libs/assimp/code/Common/FileSystemFilter.h
deleted file mode 100644
index 81576aa..0000000
--- a/libs/assimp/code/Common/FileSystemFilter.h
+++ /dev/null
@@ -1,346 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file FileSystemFilter.h
- *  Implements a filter system to filter calls to Exists() and Open()
- *  in order to improve the success rate of file opening ...
- */
-#pragma once
-#ifndef AI_FILESYSTEMFILTER_H_INC
-#define AI_FILESYSTEMFILTER_H_INC
-
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/fast_atof.h>
-#include <assimp/ParsingUtils.h>
-
-namespace Assimp    {
-
-inline bool IsHex(char s) {
-    return (s>='0' && s<='9') || (s>='a' && s<='f') || (s>='A' && s<='F');
-}
-
-// ---------------------------------------------------------------------------
-/** File system filter
- */
-class FileSystemFilter : public IOSystem
-{
-public:
-    /** Constructor. */
-    FileSystemFilter(const std::string& file, IOSystem* old)
-    : mWrapped  (old)
-    , mSrc_file(file)
-    , mSep(mWrapped->getOsSeparator()) {
-        ai_assert(nullptr != mWrapped);
-
-        // Determine base directory
-        mBase = mSrc_file;
-        std::string::size_type ss2;
-        if (std::string::npos != (ss2 = mBase.find_last_of("\\/")))  {
-            mBase.erase(ss2,mBase.length()-ss2);
-        } else {
-            mBase = std::string();
-        }
-
-        // make sure the directory is terminated properly
-        char s;
-
-        if ( mBase.empty() ) {
-            mBase = ".";
-            mBase += getOsSeparator();
-        } else if ((s = *(mBase.end()-1)) != '\\' && s != '/') {
-            mBase += getOsSeparator();
-        }
-
-        DefaultLogger::get()->info("Import root directory is \'", mBase, "\'");
-    }
-
-    /** Destructor. */
-    ~FileSystemFilter() {
-        // empty
-    }
-
-    // -------------------------------------------------------------------
-    /** Tests for the existence of a file at the given path. */
-    bool Exists( const char* pFile) const {
-        ai_assert( nullptr != mWrapped );
-
-        std::string tmp = pFile;
-
-        // Currently this IOSystem is also used to open THE ONE FILE.
-        if (tmp != mSrc_file)    {
-            BuildPath(tmp);
-            Cleanup(tmp);
-        }
-
-        return mWrapped->Exists(tmp);
-    }
-
-    // -------------------------------------------------------------------
-    /** Returns the directory separator. */
-    char getOsSeparator() const {
-        return mSep;
-    }
-
-    // -------------------------------------------------------------------
-    /** Open a new file with a given path. */
-    IOStream* Open( const char* pFile, const char* pMode = "rb") {
-        ai_assert( nullptr != mWrapped );
-        if ( nullptr == pFile || nullptr == pMode ) {
-            return nullptr;
-        }
-
-        ai_assert( nullptr != pFile );
-        ai_assert( nullptr != pMode );
-
-        // First try the unchanged path
-        IOStream* s = mWrapped->Open(pFile,pMode);
-
-        if (nullptr == s) {
-            std::string tmp = pFile;
-
-            // Try to convert between absolute and relative paths
-            BuildPath(tmp);
-            s = mWrapped->Open(tmp,pMode);
-
-            if (nullptr == s) {
-                // Finally, look for typical issues with paths
-                // and try to correct them. This is our last
-                // resort.
-                tmp = pFile;
-                Cleanup(tmp);
-                BuildPath(tmp);
-                s = mWrapped->Open(tmp,pMode);
-            }
-        }
-
-        return s;
-    }
-
-    // -------------------------------------------------------------------
-    /** Closes the given file and releases all resources associated with it. */
-    void Close( IOStream* pFile) {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->Close(pFile);
-    }
-
-    // -------------------------------------------------------------------
-    /** Compare two paths */
-    bool ComparePaths (const char* one, const char* second) const {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->ComparePaths (one,second);
-    }
-
-    // -------------------------------------------------------------------
-    /** Pushes a new directory onto the directory stack. */
-    bool PushDirectory(const std::string &path ) {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->PushDirectory(path);
-    }
-
-    // -------------------------------------------------------------------
-    /** Returns the top directory from the stack. */
-    const std::string &CurrentDirectory() const {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->CurrentDirectory();
-    }
-
-    // -------------------------------------------------------------------
-    /** Returns the number of directories stored on the stack. */
-    size_t StackSize() const {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->StackSize();
-    }
-
-    // -------------------------------------------------------------------
-    /** Pops the top directory from the stack. */
-    bool PopDirectory() {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->PopDirectory();
-    }
-
-    // -------------------------------------------------------------------
-    /** Creates an new directory at the given path. */
-    bool CreateDirectory(const std::string &path) {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->CreateDirectory(path);
-    }
-
-    // -------------------------------------------------------------------
-    /** Will change the current directory to the given path. */
-    bool ChangeDirectory(const std::string &path) {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->ChangeDirectory(path);
-    }
-
-    // -------------------------------------------------------------------
-    /** Delete file. */
-    bool DeleteFile(const std::string &file) {
-        ai_assert( nullptr != mWrapped );
-        return mWrapped->DeleteFile(file);
-    }
-
-private:
-    // -------------------------------------------------------------------
-    /** Build a valid path from a given relative or absolute path.
-     */
-    void BuildPath (std::string& in) const {
-        ai_assert( nullptr != mWrapped );
-        // if we can already access the file, great.
-        if (in.length() < 3 || mWrapped->Exists(in)) {
-            return;
-        }
-
-        // Determine whether this is a relative path (Windows-specific - most assets are packaged on Windows).
-        if (in[1] != ':') {
-
-            // append base path and try
-            const std::string tmp = mBase + in;
-            if (mWrapped->Exists(tmp)) {
-                in = tmp;
-                return;
-            }
-        }
-
-        // Chop of the file name and look in the model directory, if
-        // this fails try all sub paths of the given path, i.e.
-        // if the given path is foo/bar/something.lwo, try
-        // <base>/something.lwo
-        // <base>/bar/something.lwo
-        // <base>/foo/bar/something.lwo
-        std::string::size_type pos = in.rfind('/');
-        if (std::string::npos == pos) {
-            pos = in.rfind('\\');
-        }
-
-        if (std::string::npos != pos)   {
-            std::string tmp;
-            std::string::size_type last_dirsep = std::string::npos;
-
-            while(true) {
-                tmp = mBase;
-                tmp += mSep;
-
-                std::string::size_type dirsep = in.rfind('/', last_dirsep);
-                if (std::string::npos == dirsep) {
-                    dirsep = in.rfind('\\', last_dirsep);
-                }
-
-                if (std::string::npos == dirsep || dirsep == 0) {
-                    // we did try this already.
-                    break;
-                }
-
-                last_dirsep = dirsep-1;
-
-                tmp += in.substr(dirsep+1, in.length()-pos);
-                if (mWrapped->Exists(tmp)) {
-                    in = tmp;
-                    return;
-                }
-            }
-        }
-
-        // hopefully the underlying file system has another few tricks to access this file ...
-    }
-
-    // -------------------------------------------------------------------
-    /** Cleanup the given path
-     */
-    void Cleanup (std::string& in) const {
-        if(in.empty()) {
-            return;
-        }
-
-        // Remove a very common issue when we're parsing file names: spaces at the
-        // beginning of the path.
-        char last = 0;
-        std::string::iterator it = in.begin();
-        while (IsSpaceOrNewLine( *it ))++it;
-        if (it != in.begin()) {
-            in.erase(in.begin(),it+1);
-        }
-
-        const char separator = getOsSeparator();
-        for (it = in.begin(); it != in.end(); ++it) {
-            int remaining = std::distance(in.end(), it);
-            // Exclude :// and \\, which remain untouched.
-            // https://sourceforge.net/tracker/?func=detail&aid=3031725&group_id=226462&atid=1067632
-            if (remaining >= 3 && !strncmp(&*it, "://", 3 )) {
-                it += 3;
-                continue;
-            }
-            if (it == in.begin() && remaining >= 2 && !strncmp(&*it, "\\\\", 2)) {
-                it += 2;
-                continue;
-            }
-
-            // Cleanup path delimiters
-            if (*it == '/' || (*it) == '\\') {
-                *it = separator;
-
-                // And we're removing double delimiters, frequent issue with
-                // incorrectly composited paths ...
-                if (last == *it) {
-                    it = in.erase(it);
-                    --it;
-                }
-            } else if (*it == '%' && in.end() - it > 2) {
-                // Hex sequence in URIs
-                if( IsHex((&*it)[0]) && IsHex((&*it)[1]) ) {
-                    *it = HexOctetToDecimal(&*it);
-                    it = in.erase(it+1,it+2);
-                    --it;
-                }
-            }
-
-            last = *it;
-        }
-    }
-
-private:
-    IOSystem *mWrapped;
-    std::string mSrc_file, mBase;
-    char mSep;
-};
-
-} //!ns Assimp
-
-#endif //AI_DEFAULTIOSYSTEM_H_INC
diff --git a/libs/assimp/code/Common/IFF.h b/libs/assimp/code/Common/IFF.h
deleted file mode 100644
index 91d7d48..0000000
--- a/libs/assimp/code/Common/IFF.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Definitions for the Interchange File Format (IFF)
-// Alexander Gessler, 2006
-// Adapted to Assimp August 2008
-
-#ifndef AI_IFF_H_INCLUDED
-#define AI_IFF_H_INCLUDED
-
-#include <assimp/ByteSwapper.h>
-
-namespace Assimp    {
-namespace IFF       {
-
-/////////////////////////////////////////////////////////////////////////////////
-//! Describes an IFF chunk header
-/////////////////////////////////////////////////////////////////////////////////
-struct ChunkHeader
-{
-    //! Type of the chunk header - FourCC
-    uint32_t type;
-
-    //! Length of the chunk data, in bytes
-    uint32_t length;
-};
-
-
-/////////////////////////////////////////////////////////////////////////////////
-//! Describes an IFF sub chunk header
-/////////////////////////////////////////////////////////////////////////////////
-struct SubChunkHeader
-{
-    //! Type of the chunk header - FourCC
-    uint32_t type;
-
-    //! Length of the chunk data, in bytes
-    uint16_t length;
-};
-
-
-#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \
-    ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d)))
-
-
-#define AI_IFF_FOURCC_FORM AI_IFF_FOURCC('F','O','R','M')
-
-
-/////////////////////////////////////////////////////////////////////////////////
-//! Load a chunk header
-//! @param outFile Pointer to the file data - points to the chunk data afterwards
-//! @return Copy of the chunk header
-/////////////////////////////////////////////////////////////////////////////////
-inline ChunkHeader LoadChunk(uint8_t*& outFile)
-{
-    ChunkHeader head;
-    ::memcpy(&head.type, outFile, 4);
-    outFile += 4;
-    ::memcpy(&head.length, outFile, 4);
-    outFile += 4;
-    AI_LSWAP4(head.length);
-    AI_LSWAP4(head.type);
-    return head;
-}
-
-/////////////////////////////////////////////////////////////////////////////////
-//! Load a sub chunk header
-//! @param outFile Pointer to the file data - points to the chunk data afterwards
-//! @return Copy of the sub chunk header
-/////////////////////////////////////////////////////////////////////////////////
-inline SubChunkHeader LoadSubChunk(uint8_t*& outFile)
-{
-    SubChunkHeader head;
-    ::memcpy(&head.type, outFile, 4);
-    outFile += 4;
-    ::memcpy(&head.length, outFile, 2);
-    outFile += 2;
-    AI_LSWAP2(head.length);
-    AI_LSWAP4(head.type);
-    return head;
-}
-
-/////////////////////////////////////////////////////////////////////////////////
-//! Read the file header and return the type of the file and its size
-//! @param outFile Pointer to the file data. The buffer must at
-//!   least be 12 bytes large.
-//! @param fileType Receives the type of the file
-//! @return 0 if everything was OK, otherwise an error message
-/////////////////////////////////////////////////////////////////////////////////
-inline const char* ReadHeader(uint8_t* outFile, uint32_t& fileType)
-{
-    ChunkHeader head = LoadChunk(outFile);
-    if(AI_IFF_FOURCC_FORM != head.type)
-    {
-        return "The file is not an IFF file: FORM chunk is missing";
-    }
-    ::memcpy(&fileType, outFile, 4);
-    AI_LSWAP4(fileType);
-    return 0;
-}
-
-
-}}
-
-#endif // !! AI_IFF_H_INCLUDED
diff --git a/libs/assimp/code/Common/IOSystem.cpp b/libs/assimp/code/Common/IOSystem.cpp
deleted file mode 100644
index 1e63827..0000000
--- a/libs/assimp/code/Common/IOSystem.cpp
+++ /dev/null
@@ -1,53 +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.
----------------------------------------------------------------------------
-*/
-/** @file Default implementation of IOSystem using the standard C file functions */
-
-#include <assimp/IOSystem.hpp>
-
-using namespace Assimp;
-
-const std::string &IOSystem::CurrentDirectory() const {
-    if ( m_pathStack.empty() ) {
-        static const std::string Dummy = std::string();
-        return Dummy;
-    }
-    return m_pathStack[ m_pathStack.size()-1 ];
-}
diff --git a/libs/assimp/code/Common/Importer.cpp b/libs/assimp/code/Common/Importer.cpp
deleted file mode 100644
index 52b6097..0000000
--- a/libs/assimp/code/Common/Importer.cpp
+++ /dev/null
@@ -1,1287 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file  Importer.cpp
- *  @brief Implementation of the CPP-API class #Importer
- */
-
-#include <assimp/version.h>
-#include <assimp/config.h>
-#include <assimp/importerdesc.h>
-
-// ------------------------------------------------------------------------------------------------
-/* Uncomment this line to prevent Assimp from catching unknown exceptions.
- *
- * Note that any Exception except DeadlyImportError may lead to
- * undefined behaviour -> loaders could remain in an unusable state and
- * further imports with the same Importer instance could fail/crash/burn ...
- */
-// ------------------------------------------------------------------------------------------------
-#ifndef ASSIMP_BUILD_DEBUG
-#   define ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Internal headers
-// ------------------------------------------------------------------------------------------------
-#include "Common/Importer.h"
-#include "Common/BaseProcess.h"
-#include "Common/DefaultProgressHandler.h"
-#include "PostProcessing/ProcessHelper.h"
-#include "Common/ScenePreprocessor.h"
-#include "Common/ScenePrivate.h"
-
-#include <assimp/BaseImporter.h>
-#include <assimp/GenericProperty.h>
-#include <assimp/MemoryIOWrapper.h>
-#include <assimp/Profiler.h>
-#include <assimp/TinyFormatter.h>
-#include <assimp/Exceptional.h>
-#include <assimp/Profiler.h>
-#include <assimp/commonMetaData.h>
-
-#include <exception>
-#include <set>
-#include <memory>
-#include <cctype>
-
-#include <assimp/DefaultIOStream.h>
-#include <assimp/DefaultIOSystem.h>
-
-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-#   include "PostProcessing/ValidateDataStructure.h"
-#endif
-
-using namespace Assimp::Profiling;
-using namespace Assimp::Formatter;
-
-namespace Assimp {
-    // ImporterRegistry.cpp
-    void GetImporterInstanceList(std::vector< BaseImporter* >& out);
-	void DeleteImporterInstanceList(std::vector< BaseImporter* >& out);
-
-    // PostStepRegistry.cpp
-    void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
-}
-
-using namespace Assimp;
-using namespace Assimp::Intern;
-
-// ------------------------------------------------------------------------------------------------
-// Intern::AllocateFromAssimpHeap serves as abstract base class. It overrides
-// new and delete (and their array counterparts) of public API classes (e.g. Logger) to
-// utilize our DLL heap.
-// See http://www.gotw.ca/publications/mill15.htm
-// ------------------------------------------------------------------------------------------------
-void* AllocateFromAssimpHeap::operator new ( size_t num_bytes)  {
-    return ::operator new(num_bytes);
-}
-
-void* AllocateFromAssimpHeap::operator new ( size_t num_bytes, const std::nothrow_t& ) throw()  {
-    try {
-        return AllocateFromAssimpHeap::operator new( num_bytes );
-    }
-    catch( ... )    {
-        return nullptr;
-    }
-}
-
-void AllocateFromAssimpHeap::operator delete ( void* data)  {
-    return ::operator delete(data);
-}
-
-void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes)    {
-    return ::operator new[](num_bytes);
-}
-
-void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw() {
-    try {
-        return AllocateFromAssimpHeap::operator new[]( num_bytes );
-    } catch( ... )    {
-        return nullptr;
-    }
-}
-
-void AllocateFromAssimpHeap::operator delete[] ( void* data)    {
-    return ::operator delete[](data);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Importer constructor.
-Importer::Importer()
- : pimpl( new ImporterPimpl ) {
-    pimpl->mScene = nullptr;
-    pimpl->mErrorString = std::string();
-
-    // Allocate a default IO handler
-    pimpl->mIOHandler = new DefaultIOSystem;
-    pimpl->mIsDefaultHandler = true;
-    pimpl->bExtraVerbose     = false; // disable extra verbose mode by default
-
-    pimpl->mProgressHandler = new DefaultProgressHandler();
-    pimpl->mIsDefaultProgressHandler = true;
-
-    GetImporterInstanceList(pimpl->mImporter);
-    GetPostProcessingStepInstanceList(pimpl->mPostProcessingSteps);
-
-    // Allocate a SharedPostProcessInfo object and store pointers to it in all post-process steps in the list.
-    pimpl->mPPShared = new SharedPostProcessInfo();
-    for (std::vector<BaseProcess*>::iterator it =  pimpl->mPostProcessingSteps.begin();
-        it != pimpl->mPostProcessingSteps.end();
-        ++it)   {
-
-        (*it)->SetSharedData(pimpl->mPPShared);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor of Importer
-Importer::~Importer() {
-    // Delete all import plugins
-	DeleteImporterInstanceList(pimpl->mImporter);
-
-    // Delete all post-processing plug-ins
-    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); ++a ) {
-        delete pimpl->mPostProcessingSteps[a];
-    }
-
-    // Delete the assigned IO and progress handler
-    delete pimpl->mIOHandler;
-    delete pimpl->mProgressHandler;
-
-    // Kill imported scene. Destructor's should do that recursively
-    delete pimpl->mScene;
-
-    // Delete shared post-processing data
-    delete pimpl->mPPShared;
-
-    // and finally the pimpl itself
-    delete pimpl;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Register a custom post-processing step
-aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
-    ai_assert( nullptr != pImp );
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-        pimpl->mPostProcessingSteps.push_back(pImp);
-        ASSIMP_LOG_INFO("Registering custom post-processing step");
-
-    ASSIMP_END_EXCEPTION_REGION(aiReturn);
-    return AI_SUCCESS;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Register a custom loader plugin
-aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
-    ai_assert(nullptr != pImp);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // --------------------------------------------------------------------
-    // Check whether we would have two loaders for the same file extension
-    // This is absolutely OK, but we should warn the developer of the new
-    // loader that his code will probably never be called if the first
-    // loader is a bit too lazy in his file checking.
-    // --------------------------------------------------------------------
-    std::set<std::string> st;
-    std::string baked;
-    pImp->GetExtensionList(st);
-
-    for(std::set<std::string>::const_iterator it = st.begin(); it != st.end(); ++it) {
-
-#ifdef ASSIMP_BUILD_DEBUG
-        if (IsExtensionSupported(*it)) {
-            ASSIMP_LOG_WARN("The file extension ", *it, " is already in use");
-        }
-#endif
-        baked += *it;
-    }
-
-    // add the loader
-    pimpl->mImporter.push_back(pImp);
-    ASSIMP_LOG_INFO("Registering custom importer for these file extensions: ", baked);
-    ASSIMP_END_EXCEPTION_REGION(aiReturn);
-
-    return AI_SUCCESS;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Unregister a custom loader plugin
-aiReturn Importer::UnregisterLoader(BaseImporter* pImp) {
-    if(!pImp) {
-        // unregistering a nullptr importer is no problem for us ... really!
-        return AI_SUCCESS;
-    }
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    std::vector<BaseImporter*>::iterator it = std::find(pimpl->mImporter.begin(),
-        pimpl->mImporter.end(),pImp);
-
-    if (it != pimpl->mImporter.end())   {
-        pimpl->mImporter.erase(it);
-        ASSIMP_LOG_INFO("Unregistering custom importer: ");
-        return AI_SUCCESS;
-    }
-    ASSIMP_LOG_WARN("Unable to remove custom importer: I can't find you ...");
-    ASSIMP_END_EXCEPTION_REGION(aiReturn);
-
-    return AI_FAILURE;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Unregister a custom loader plugin
-aiReturn Importer::UnregisterPPStep(BaseProcess* pImp) {
-    if(!pImp) {
-        // unregistering a nullptr ppstep is no problem for us ... really!
-        return AI_SUCCESS;
-    }
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    std::vector<BaseProcess*>::iterator it = std::find(pimpl->mPostProcessingSteps.begin(),
-        pimpl->mPostProcessingSteps.end(),pImp);
-
-    if (it != pimpl->mPostProcessingSteps.end())    {
-        pimpl->mPostProcessingSteps.erase(it);
-        ASSIMP_LOG_INFO("Unregistering custom post-processing step");
-        return AI_SUCCESS;
-    }
-    ASSIMP_LOG_WARN("Unable to remove custom post-processing step: I can't find you ..");
-    ASSIMP_END_EXCEPTION_REGION(aiReturn);
-
-    return AI_FAILURE;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Supplies a custom IO handler to the importer to open and access files.
-void Importer::SetIOHandler( IOSystem* pIOHandler) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    // If the new handler is zero, allocate a default IO implementation.
-    if (!pIOHandler) {
-        // Release pointer in the possession of the caller
-        pimpl->mIOHandler = new DefaultIOSystem();
-        pimpl->mIsDefaultHandler = true;
-    } else if (pimpl->mIOHandler != pIOHandler) { // Otherwise register the custom handler
-        delete pimpl->mIOHandler;
-        pimpl->mIOHandler = pIOHandler;
-        pimpl->mIsDefaultHandler = false;
-    }
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the currently set IO handler
-IOSystem* Importer::GetIOHandler() const {
-    ai_assert(nullptr != pimpl);
-
-    return pimpl->mIOHandler;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Check whether a custom IO handler is currently set
-bool Importer::IsDefaultIOHandler() const {
-    ai_assert(nullptr != pimpl);
-
-    return pimpl->mIsDefaultHandler;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Supplies a custom progress handler to get regular callbacks during importing
-void Importer::SetProgressHandler(ProgressHandler* pHandler) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // If the new handler is zero, allocate a default implementation.
-    if (!pHandler) {
-        // Release pointer in the possession of the caller
-        pimpl->mProgressHandler = new DefaultProgressHandler();
-        pimpl->mIsDefaultProgressHandler = true;
-    } else if (pimpl->mProgressHandler != pHandler) { // Otherwise register the custom handler
-        delete pimpl->mProgressHandler;
-        pimpl->mProgressHandler = pHandler;
-        pimpl->mIsDefaultProgressHandler = false;
-    }
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the currently set progress handler
-ProgressHandler* Importer::GetProgressHandler() const {
-    ai_assert(nullptr != pimpl);
-
-    return pimpl->mProgressHandler;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Check whether a custom progress handler is currently set
-bool Importer::IsDefaultProgressHandler() const {
-    ai_assert(nullptr != pimpl);
-
-    return pimpl->mIsDefaultProgressHandler;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Validate post process step flags
-bool _ValidateFlags(unsigned int pFlags) {
-    if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals)   {
-        ASSIMP_LOG_ERROR("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible");
-        return false;
-    }
-    if (pFlags & aiProcess_OptimizeGraph && pFlags & aiProcess_PreTransformVertices)    {
-        ASSIMP_LOG_ERROR("#aiProcess_OptimizeGraph and #aiProcess_PreTransformVertices are incompatible");
-        return false;
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Free the current scene
-void Importer::FreeScene( ) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    delete pimpl->mScene;
-    pimpl->mScene = nullptr;
-
-    pimpl->mErrorString = std::string();
-    pimpl->mException = std::exception_ptr();
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the current error string, if any
-const char* Importer::GetErrorString() const {
-    ai_assert(nullptr != pimpl);
-
-    // Must remain valid as long as ReadFile() or FreeFile() are not called
-    return pimpl->mErrorString.c_str();
-}
-
-const std::exception_ptr& Importer::GetException() const {
-    ai_assert(nullptr != pimpl);
-
-    // Must remain valid as long as ReadFile() or FreeFile() are not called
-    return pimpl->mException;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Enable extra-verbose mode
-void Importer::SetExtraVerbose(bool bDo) {
-    ai_assert(nullptr != pimpl);
-
-    pimpl->bExtraVerbose = bDo;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the current scene
-const aiScene* Importer::GetScene() const {
-    ai_assert(nullptr != pimpl);
-
-    return pimpl->mScene;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Orphan the current scene and return it.
-aiScene* Importer::GetOrphanedScene() {
-    ai_assert(nullptr != pimpl);
-
-    aiScene* s = pimpl->mScene;
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    pimpl->mScene = nullptr;
-
-    pimpl->mErrorString = std::string();
-    pimpl->mException = std::exception_ptr();
-    ASSIMP_END_EXCEPTION_REGION(aiScene*);
-
-    return s;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Validate post-processing flags
-bool Importer::ValidateFlags(unsigned int pFlags) const {
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    // run basic checks for mutually exclusive flags
-    if(!_ValidateFlags(pFlags)) {
-        return false;
-    }
-
-    // ValidateDS does not anymore occur in the pp list, it plays an awesome extra role ...
-#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-    if (pFlags & aiProcess_ValidateDataStructure) {
-        return false;
-    }
-#endif
-    pFlags &= ~aiProcess_ValidateDataStructure;
-
-    // Now iterate through all bits which are set in the flags and check whether we find at least
-    // one pp plugin which handles it.
-    for (unsigned int mask = 1; mask < (1u << (sizeof(unsigned int)*8-1));mask <<= 1) {
-
-        if (pFlags & mask) {
-
-            bool have = false;
-            for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)   {
-                if (pimpl->mPostProcessingSteps[a]-> IsActive(mask) ) {
-
-                    have = true;
-                    break;
-                }
-            }
-            if (!have) {
-                return false;
-            }
-        }
-    }
-    ASSIMP_END_EXCEPTION_REGION(bool);
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
-    size_t pLength,
-    unsigned int pFlags,
-    const char* pHint /*= ""*/) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    if (!pHint) {
-        pHint = "";
-    }
-
-    if (!pBuffer || !pLength || strlen(pHint) > MaxLenHint ) {
-        pimpl->mErrorString = "Invalid parameters passed to ReadFileFromMemory()";
-        return nullptr;
-    }
-
-    // prevent deletion of the previous IOHandler
-    IOSystem* io = pimpl->mIOHandler;
-    pimpl->mIOHandler = nullptr;
-
-    SetIOHandler(new MemoryIOSystem((const uint8_t*)pBuffer,pLength,io));
-
-    // read the file and recover the previous IOSystem
-    static const size_t BufSize(Importer::MaxLenHint + 28);
-    char fbuff[BufSize];
-    ai_snprintf(fbuff, BufSize, "%s.%s",AI_MEMORYIO_MAGIC_FILENAME,pHint);
-
-    ReadFile(fbuff,pFlags);
-    SetIOHandler(io);
-
-    ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException);
-    return pimpl->mScene;
-}
-
-// ------------------------------------------------------------------------------------------------
-void WriteLogOpening(const std::string& file) {
-
-    ASSIMP_LOG_INFO("Load ", file);
-
-    // print a full version dump. This is nice because we don't
-    // need to ask the authors of incoming bug reports for
-    // the library version they're using - a log dump is
-    // sufficient.
-    const unsigned int flags = aiGetCompileFlags();
-    std::stringstream stream;
-    stream << "Assimp " << aiGetVersionMajor() << "." << aiGetVersionMinor() << "." << aiGetVersionRevision() << " "
-#if defined(ASSIMP_BUILD_ARCHITECTURE)
-           << ASSIMP_BUILD_ARCHITECTURE
-#elif defined(_M_IX86) || defined(__x86_32__) || defined(__i386__)
-           << "x86"
-#elif defined(_M_X64) || defined(__x86_64__)
-           << "amd64"
-#elif defined(_M_IA64) || defined(__ia64__)
-           << "itanium"
-#elif defined(__ppc__) || defined(__powerpc__)
-           << "ppc32"
-#elif defined(__powerpc64__)
-           << "ppc64"
-#elif defined(__arm__)
-           << "arm"
-#else
-           << "<unknown architecture>"
-#endif
-           << " "
-#if defined(ASSIMP_BUILD_COMPILER)
-           << (ASSIMP_BUILD_COMPILER)
-#elif defined(_MSC_VER)
-           << "msvc"
-#elif defined(__GNUC__)
-           << "gcc"
-#elif defined(__clang__)
-           << "clang"
-#elif defined(__EMSCRIPTEN__)
-           << "emscripten"
-#elif defined(__MINGW32__)
-           << "MinGW-w64 32bit"
-#elif defined(__MINGW64__)
-           << "MinGW-w64 64bit"
-#else
-           << "<unknown compiler>"
-#endif
-
-#ifdef ASSIMP_BUILD_DEBUG
-           << " debug"
-#endif
-
-           << (flags & ASSIMP_CFLAGS_NOBOOST ? " noboost" : "")
-           << (flags & ASSIMP_CFLAGS_SHARED ? " shared" : "")
-           << (flags & ASSIMP_CFLAGS_SINGLETHREADED ? " singlethreaded" : "")
-           << (flags & ASSIMP_CFLAGS_DOUBLE_SUPPORT ? " double : " : "single : ");
-
-    ASSIMP_LOG_DEBUG(stream.str());
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the given file and returns its contents if successful.
-const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    const std::string pFile(_pFile);
-
-    // ----------------------------------------------------------------------
-    // Put a large try block around everything to catch all std::exception's
-    // that might be thrown by STL containers or by new().
-    // ImportErrorException's are throw by ourselves and caught elsewhere.
-    //-----------------------------------------------------------------------
-
-    WriteLogOpening(pFile);
-
-#ifdef ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-    try
-#endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-    {
-        // Check whether this Importer instance has already loaded
-        // a scene. In this case we need to delete the old one
-        if (pimpl->mScene)  {
-
-            ASSIMP_LOG_DEBUG("(Deleting previous scene)");
-            FreeScene();
-        }
-
-        // First check if the file is accessible at all
-        if( !pimpl->mIOHandler->Exists( pFile)) {
-
-            pimpl->mErrorString = "Unable to open file \"" + pFile + "\".";
-            ASSIMP_LOG_ERROR(pimpl->mErrorString);
-            return nullptr;
-        }
-
-        std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME, 0) ? new Profiler() : nullptr);
-        if (profiler) {
-            profiler->BeginRegion("total");
-        }
-
-        // Find an worker class which can handle the file extension.
-        // Multiple importers may be able to handle the same extension (.xml!); gather them all.
-        SetPropertyInteger("importerIndex", -1);
-        struct ImporterAndIndex {
-            BaseImporter * importer;
-            unsigned int   index;
-        };
-        std::vector<ImporterAndIndex> possibleImporters;
-        for (unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
-
-            // Every importer has a list of supported extensions.
-            std::set<std::string> extensions;
-            pimpl->mImporter[a]->GetExtensionList(extensions);
-
-            // CAUTION: Do not just search for the extension!
-            // GetExtension() returns the part after the *last* dot, but some extensions have dots
-            // inside them, e.g. ogre.mesh.xml. Compare the entire end of the string.
-            for (std::set<std::string>::const_iterator it = extensions.cbegin(); it != extensions.cend(); ++it) {
-
-                // Yay for C++<20 not having std::string::ends_with()
-                std::string extension = "." + *it;
-                if (extension.length() <= pFile.length()) {
-                    // Possible optimization: Fetch the lowercase filename!
-                    if (0 == ASSIMP_stricmp(pFile.c_str() + pFile.length() - extension.length(), extension.c_str())) {
-                        ImporterAndIndex candidate = { pimpl->mImporter[a], a };
-                        possibleImporters.push_back(candidate);
-                        break;
-                    }
-                }
-
-            }
-
-        }
-
-        // If just one importer supports this extension, pick it and close the case.
-        BaseImporter* imp = nullptr;
-        if (1 == possibleImporters.size()) {
-            imp = possibleImporters[0].importer;
-            SetPropertyInteger("importerIndex", possibleImporters[0].index);
-        }
-        // If multiple importers claim this file extension, ask them to look at the actual file data to decide.
-        // This can happen e.g. with XML (COLLADA vs. Irrlicht).
-        else {
-            for (std::vector<ImporterAndIndex>::const_iterator it = possibleImporters.begin(); it < possibleImporters.end(); ++it) {
-                BaseImporter & importer = *it->importer;
-
-                ASSIMP_LOG_INFO("Found a possible importer: " + std::string(importer.GetInfo()->mName) + "; trying signature-based detection");
-                if (importer.CanRead( pFile, pimpl->mIOHandler, true)) {
-                    imp = &importer;
-                    SetPropertyInteger("importerIndex", it->index);
-                    break;
-                }
-
-            }
-
-        }
-
-        if (!imp)   {
-            // not so bad yet ... try format auto detection.
-            ASSIMP_LOG_INFO("File extension not known, trying signature-based detection");
-            for( unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
-                if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) {
-                    imp = pimpl->mImporter[a];
-                    SetPropertyInteger("importerIndex", a);
-                    break;
-                }
-            }
-            // Put a proper error message if no suitable importer was found
-            if( !imp)   {
-                pimpl->mErrorString = "No suitable reader found for the file format of file \"" + pFile + "\".";
-                ASSIMP_LOG_ERROR(pimpl->mErrorString);
-                return nullptr;
-            }
-        }
-
-        // Get file size for progress handler
-        IOStream * fileIO = pimpl->mIOHandler->Open( pFile );
-        uint32_t fileSize = 0;
-        if (fileIO)
-        {
-            fileSize = static_cast<uint32_t>(fileIO->FileSize());
-            pimpl->mIOHandler->Close( fileIO );
-        }
-
-        // Dispatch the reading to the worker class for this format
-        const aiImporterDesc *desc( imp->GetInfo() );
-        std::string ext( "unknown" );
-        if ( nullptr != desc ) {
-            ext = desc->mName;
-        }
-        ASSIMP_LOG_INFO("Found a matching importer for this file format: ", ext, "." );
-        pimpl->mProgressHandler->UpdateFileRead( 0, fileSize );
-
-        if (profiler) {
-            profiler->BeginRegion("import");
-        }
-
-        pimpl->mScene = imp->ReadFile( this, pFile, pimpl->mIOHandler);
-        pimpl->mProgressHandler->UpdateFileRead( fileSize, fileSize );
-
-        if (profiler) {
-            profiler->EndRegion("import");
-        }
-
-        SetPropertyString("sourceFilePath", pFile);
-
-        // If successful, apply all active post processing steps to the imported data
-        if( pimpl->mScene)  {
-            if (!pimpl->mScene->mMetaData || !pimpl->mScene->mMetaData->HasKey(AI_METADATA_SOURCE_FORMAT)) {
-                if (!pimpl->mScene->mMetaData) {
-                    pimpl->mScene->mMetaData = new aiMetadata;
-                }
-                pimpl->mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT, aiString(ext));
-            }
-
-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-            // The ValidateDS process is an exception. It is executed first, even before ScenePreprocessor is called.
-            if (pFlags & aiProcess_ValidateDataStructure) {
-                ValidateDSProcess ds;
-                ds.ExecuteOnScene (this);
-                if (!pimpl->mScene) {
-                    return nullptr;
-                }
-            }
-#endif // no validation
-
-            // Preprocess the scene and prepare it for post-processing
-            if (profiler) {
-                profiler->BeginRegion("preprocess");
-            }
-
-            ScenePreprocessor pre(pimpl->mScene);
-            pre.ProcessScene();
-
-            if (profiler) {
-                profiler->EndRegion("preprocess");
-            }
-
-            // Ensure that the validation process won't be called twice
-            ApplyPostProcessing(pFlags & (~aiProcess_ValidateDataStructure));
-        }
-        // if failed, extract the error string
-        else if( !pimpl->mScene) {
-            pimpl->mErrorString = imp->GetErrorText();
-            pimpl->mException = imp->GetException();
-        }
-
-        // clear any data allocated by post-process steps
-        pimpl->mPPShared->Clean();
-
-        if (profiler) {
-            profiler->EndRegion("total");
-        }
-    }
-#ifdef ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-    catch (std::exception &e) {
-#if (defined _MSC_VER) &&   (defined _CPPRTTI)
-        // if we have RTTI get the full name of the exception that occurred
-        pimpl->mErrorString = std::string(typeid( e ).name()) + ": " + e.what();
-#else
-        pimpl->mErrorString = std::string("std::exception: ") + e.what();
-#endif
-
-        ASSIMP_LOG_ERROR(pimpl->mErrorString);
-        delete pimpl->mScene; pimpl->mScene = nullptr;
-    }
-#endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-
-    // either successful or failure - the pointer expresses it anyways
-    ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException);
-
-    return pimpl->mScene;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Apply post-processing to the currently bound scene
-const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    // Return immediately if no scene is active
-    if (!pimpl->mScene) {
-        return nullptr;
-    }
-
-    // If no flags are given, return the current scene with no further action
-    if (!pFlags) {
-        return pimpl->mScene;
-    }
-
-    // In debug builds: run basic flag validation
-    ai_assert(_ValidateFlags(pFlags));
-    ASSIMP_LOG_INFO("Entering post processing pipeline");
-
-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-    // The ValidateDS process plays an exceptional role. It isn't contained in the global
-    // list of post-processing steps, so we need to call it manually.
-    if (pFlags & aiProcess_ValidateDataStructure) {
-        ValidateDSProcess ds;
-        ds.ExecuteOnScene (this);
-        if (!pimpl->mScene) {
-            return nullptr;
-        }
-    }
-#endif // no validation
-#ifdef ASSIMP_BUILD_DEBUG
-    if (pimpl->bExtraVerbose)
-    {
-#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-        ASSIMP_LOG_ERROR("Verbose Import is not available due to build settings");
-#endif  // no validation
-        pFlags |= aiProcess_ValidateDataStructure;
-    }
-#else
-    if (pimpl->bExtraVerbose) {
-        ASSIMP_LOG_WARN("Not a debug build, ignoring extra verbose setting");
-    }
-#endif // ! DEBUG
-
-    std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME, 0) ? new Profiler() : nullptr);
-    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)   {
-        BaseProcess* process = pimpl->mPostProcessingSteps[a];
-        pimpl->mProgressHandler->UpdatePostProcess(static_cast<int>(a), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
-        if( process->IsActive( pFlags)) {
-            if (profiler) {
-                profiler->BeginRegion("postprocess");
-            }
-
-            process->ExecuteOnScene ( this );
-
-            if (profiler) {
-                profiler->EndRegion("postprocess");
-            }
-        }
-        if( !pimpl->mScene) {
-            break;
-        }
-#ifdef ASSIMP_BUILD_DEBUG
-
-#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-        continue;
-#endif  // no validation
-
-        // If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
-        if (pimpl->bExtraVerbose)   {
-            ASSIMP_LOG_DEBUG("Verbose Import: re-validating data structures");
-
-            ValidateDSProcess ds;
-            ds.ExecuteOnScene (this);
-            if( !pimpl->mScene) {
-                ASSIMP_LOG_ERROR("Verbose Import: failed to re-validate data structures");
-                break;
-            }
-        }
-#endif // ! DEBUG
-    }
-    pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()),
-        static_cast<int>(pimpl->mPostProcessingSteps.size()) );
-
-    // update private scene flags
-    if( pimpl->mScene ) {
-      ScenePriv(pimpl->mScene)->mPPStepsApplied |= pFlags;
-    }
-
-    // clear any data allocated by post-process steps
-    pimpl->mPPShared->Clean();
-    ASSIMP_LOG_INFO("Leaving post processing pipeline");
-
-    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
-
-    return pimpl->mScene;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // Return immediately if no scene is active
-    if ( nullptr == pimpl->mScene ) {
-        return nullptr;
-    }
-
-    // If no flags are given, return the current scene with no further action
-    if (nullptr == rootProcess) {
-        return pimpl->mScene;
-    }
-
-    // In debug builds: run basic flag validation
-    ASSIMP_LOG_INFO( "Entering customized post processing pipeline" );
-
-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-    // The ValidateDS process plays an exceptional role. It isn't contained in the global
-    // list of post-processing steps, so we need to call it manually.
-    if ( requestValidation )
-    {
-        ValidateDSProcess ds;
-        ds.ExecuteOnScene( this );
-        if ( !pimpl->mScene ) {
-            return nullptr;
-        }
-    }
-#endif // no validation
-#ifdef ASSIMP_BUILD_DEBUG
-    if ( pimpl->bExtraVerbose )
-    {
-#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-        ASSIMP_LOG_ERROR( "Verbose Import is not available due to build settings" );
-#endif  // no validation
-    }
-#else
-    if ( pimpl->bExtraVerbose ) {
-        ASSIMP_LOG_WARN( "Not a debug build, ignoring extra verbose setting" );
-    }
-#endif // ! DEBUG
-
-    std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME, 0) ? new Profiler() : nullptr);
-
-    if ( profiler ) {
-        profiler->BeginRegion( "postprocess" );
-    }
-
-    rootProcess->ExecuteOnScene( this );
-
-    if ( profiler ) {
-        profiler->EndRegion( "postprocess" );
-    }
-
-    // If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
-    if ( pimpl->bExtraVerbose || requestValidation  ) {
-        ASSIMP_LOG_DEBUG( "Verbose Import: revalidating data structures" );
-
-        ValidateDSProcess ds;
-        ds.ExecuteOnScene( this );
-        if ( !pimpl->mScene ) {
-            ASSIMP_LOG_ERROR( "Verbose Import: failed to revalidate data structures" );
-        }
-    }
-
-    // clear any data allocated by post-process steps
-    pimpl->mPPShared->Clean();
-    ASSIMP_LOG_INFO( "Leaving customized post processing pipeline" );
-
-    ASSIMP_END_EXCEPTION_REGION( const aiScene* );
-
-    return pimpl->mScene;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Helper function to check whether an extension is supported by ASSIMP
-bool Importer::IsExtensionSupported(const char* szExtension) const {
-    return nullptr != GetImporter(szExtension);
-}
-
-// ------------------------------------------------------------------------------------------------
-size_t Importer::GetImporterCount() const {
-    ai_assert(nullptr != pimpl);
-
-    return pimpl->mImporter.size();
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
-    ai_assert(nullptr != pimpl);
-
-    if (index >= pimpl->mImporter.size()) {
-        return nullptr;
-    }
-    return pimpl->mImporter[index]->GetInfo();
-}
-
-
-// ------------------------------------------------------------------------------------------------
-BaseImporter* Importer::GetImporter (size_t index) const {
-    ai_assert(nullptr != pimpl);
-
-    if (index >= pimpl->mImporter.size()) {
-        return nullptr;
-    }
-    return pimpl->mImporter[index];
-}
-
-// ------------------------------------------------------------------------------------------------
-// Find a loader plugin for a given file extension
-BaseImporter* Importer::GetImporter (const char* szExtension) const {
-    ai_assert(nullptr != pimpl);
-
-    return GetImporter(GetImporterIndex(szExtension));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Find a loader plugin for a given file extension
-size_t Importer::GetImporterIndex (const char* szExtension) const {
-    ai_assert(nullptr != pimpl);
-    ai_assert(nullptr != szExtension);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-
-    // skip over wild-card and dot characters at string head --
-    for ( ; *szExtension == '*' || *szExtension == '.'; ++szExtension );
-
-    std::string ext(szExtension);
-    if (ext.empty()) {
-        return static_cast<size_t>(-1);
-    }
-    ext = ai_tolower(ext);
-    std::set<std::string> str;
-    for (std::vector<BaseImporter*>::const_iterator i =  pimpl->mImporter.begin();i != pimpl->mImporter.end();++i)  {
-        str.clear();
-
-        (*i)->GetExtensionList(str);
-        for (std::set<std::string>::const_iterator it = str.begin(); it != str.end(); ++it) {
-            if (ext == *it) {
-                return std::distance(static_cast< std::vector<BaseImporter*>::const_iterator >(pimpl->mImporter.begin()), i);
-            }
-        }
-    }
-    ASSIMP_END_EXCEPTION_REGION(size_t);
-    return static_cast<size_t>(-1);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Helper function to build a list of all file extensions supported by ASSIMP
-void Importer::GetExtensionList(aiString& szOut) const {
-    ai_assert(nullptr != pimpl);
-
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-    std::set<std::string> str;
-    for (std::vector<BaseImporter*>::const_iterator i =  pimpl->mImporter.begin();i != pimpl->mImporter.end();++i)  {
-        (*i)->GetExtensionList(str);
-    }
-
-	// List can be empty
-	if( !str.empty() ) {
-		for (std::set<std::string>::const_iterator it = str.begin();; ) {
-			szOut.Append("*.");
-			szOut.Append((*it).c_str());
-
-			if (++it == str.end()) {
-				break;
-			}
-			szOut.Append(";");
-		}
-	}
-    ASSIMP_END_EXCEPTION_REGION(void);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool Importer::SetPropertyInteger(const char* szName, int iValue) {
-    ai_assert(nullptr != pimpl);
-
-    bool existing;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-        existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
-    ASSIMP_END_EXCEPTION_REGION(bool);
-    return existing;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
-    ai_assert(nullptr != pimpl);
-
-    bool existing;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-        existing = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue);
-    ASSIMP_END_EXCEPTION_REGION(bool);
-    return existing;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool Importer::SetPropertyString(const char* szName, const std::string& value) {
-    ai_assert(nullptr != pimpl);
-
-    bool existing;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-        existing = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);
-    ASSIMP_END_EXCEPTION_REGION(bool);
-    return existing;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
-    ai_assert(nullptr != pimpl);
-
-    bool existing;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-        existing = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
-    ASSIMP_END_EXCEPTION_REGION(bool);
-    return existing;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Set a configuration property
-bool Importer::SetPropertyPointer(const char* szName, void* value) {
-    ai_assert(nullptr != pimpl);
-    
-    bool existing;
-    ASSIMP_BEGIN_EXCEPTION_REGION();
-        existing = SetGenericProperty<void*>(pimpl->mPointerProperties, szName,value);
-    ASSIMP_END_EXCEPTION_REGION(bool);
-    return existing;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
-    ai_assert(nullptr != pimpl);
-
-    return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
-    ai_assert(nullptr != pimpl);
-
-    return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
-    ai_assert(nullptr != pimpl);
-
-    return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
-    ai_assert(nullptr != pimpl);
-
-    return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a configuration property
-void* Importer::GetPropertyPointer(const char* szName, void* iErrorReturn /*= nullptr*/) const {
-    ai_assert(nullptr != pimpl);
-    
-    return GetGenericProperty<void*>(pimpl->mPointerProperties,szName,iErrorReturn);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the memory requirements of a single node
-inline
-void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
-    if ( nullptr == pcNode ) {
-        return;
-    }
-    iScene += sizeof(aiNode);
-    iScene += sizeof(unsigned int) * pcNode->mNumMeshes;
-    iScene += sizeof(void*) * pcNode->mNumChildren;
-
-    for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
-        AddNodeWeight(iScene,pcNode->mChildren[i]);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the memory requirements of the scene
-void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
-    ai_assert(nullptr != pimpl);
-
-    in = aiMemoryInfo();
-    aiScene* mScene = pimpl->mScene;
-
-    // return if we have no scene loaded
-    if (!mScene)
-        return;
-
-    in.total = sizeof(aiScene);
-
-    // add all meshes
-    for (unsigned int i = 0; i < mScene->mNumMeshes;++i) {
-        in.meshes += sizeof(aiMesh);
-        if (mScene->mMeshes[i]->HasPositions()) {
-            in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
-        }
-
-        if (mScene->mMeshes[i]->HasNormals()) {
-            in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
-        }
-
-        if (mScene->mMeshes[i]->HasTangentsAndBitangents()) {
-            in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices * 2;
-        }
-
-        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS;++a) {
-            if (mScene->mMeshes[i]->HasVertexColors(a)) {
-                in.meshes += sizeof(aiColor4D) * mScene->mMeshes[i]->mNumVertices;
-            } else {
-                break;
-            }
-        }
-        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a) {
-            if (mScene->mMeshes[i]->HasTextureCoords(a)) {
-                in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
-            } else {
-                break;
-            }
-        }
-        if (mScene->mMeshes[i]->HasBones()) {
-            in.meshes += sizeof(void*) * mScene->mMeshes[i]->mNumBones;
-            for (unsigned int p = 0; p < mScene->mMeshes[i]->mNumBones;++p) {
-                in.meshes += sizeof(aiBone);
-                in.meshes += mScene->mMeshes[i]->mBones[p]->mNumWeights * sizeof(aiVertexWeight);
-            }
-        }
-        in.meshes += (sizeof(aiFace) + 3 * sizeof(unsigned int))*mScene->mMeshes[i]->mNumFaces;
-    }
-    in.total += in.meshes;
-
-    // add all embedded textures
-    for (unsigned int i = 0; i < mScene->mNumTextures;++i) {
-        const aiTexture* pc = mScene->mTextures[i];
-        in.textures += sizeof(aiTexture);
-        if (pc->mHeight) {
-            in.textures += 4 * pc->mHeight * pc->mWidth;
-        } else {
-            in.textures += pc->mWidth;
-        }
-    }
-    in.total += in.textures;
-
-    // add all animations
-    for (unsigned int i = 0; i < mScene->mNumAnimations;++i) {
-        const aiAnimation* pc = mScene->mAnimations[i];
-        in.animations += sizeof(aiAnimation);
-
-        // add all bone anims
-        for (unsigned int a = 0; a < pc->mNumChannels; ++a) {
-            const aiNodeAnim* pc2 = pc->mChannels[a];
-            in.animations += sizeof(aiNodeAnim);
-            in.animations += pc2->mNumPositionKeys * sizeof(aiVectorKey);
-            in.animations += pc2->mNumScalingKeys * sizeof(aiVectorKey);
-            in.animations += pc2->mNumRotationKeys * sizeof(aiQuatKey);
-        }
-    }
-    in.total += in.animations;
-
-    // add all cameras and all lights
-    in.total += in.cameras = sizeof(aiCamera) *  mScene->mNumCameras;
-    in.total += in.lights  = sizeof(aiLight)  *  mScene->mNumLights;
-
-    // add all nodes
-    AddNodeWeight(in.nodes,mScene->mRootNode);
-    in.total += in.nodes;
-
-    // add all materials
-    for (unsigned int i = 0; i < mScene->mNumMaterials;++i) {
-        const aiMaterial* pc = mScene->mMaterials[i];
-        in.materials += sizeof(aiMaterial);
-        in.materials += pc->mNumAllocated * sizeof(void*);
-
-        for (unsigned int a = 0; a < pc->mNumProperties;++a) {
-            in.materials += pc->mProperties[a]->mDataLength;
-        }
-    }
-
-    in.total += in.materials;
-}
diff --git a/libs/assimp/code/Common/Importer.h b/libs/assimp/code/Common/Importer.h
deleted file mode 100644
index ab7e3a6..0000000
--- a/libs/assimp/code/Common/Importer.h
+++ /dev/null
@@ -1,250 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Importer.h mostly internal stuff for use by #Assimp::Importer */
-#pragma once
-#ifndef INCLUDED_AI_IMPORTER_H
-#define INCLUDED_AI_IMPORTER_H
-
-#include <exception>
-#include <map>
-#include <vector>
-#include <string>
-#include <assimp/matrix4x4.h>
-
-struct aiScene;
-
-namespace Assimp    {
-    class ProgressHandler;
-    class IOSystem;
-    class BaseImporter;
-    class BaseProcess;
-    class SharedPostProcessInfo;
-
-
-//! @cond never
-// ---------------------------------------------------------------------------
-/** @brief Internal PIMPL implementation for Assimp::Importer
- *
- *  Using this idiom here allows us to drop the dependency from
- *  std::vector and std::map in the public headers. Furthermore we are dropping
- *  any STL interface problems caused by mismatching STL settings. All
- *  size calculation are now done by us, not the app heap. */
-class ImporterPimpl {
-public:
-    // Data type to store the key hash
-    typedef unsigned int KeyType;
-
-    // typedefs for our configuration maps.
-    typedef std::map<KeyType, int> IntPropertyMap;
-    typedef std::map<KeyType, ai_real> FloatPropertyMap;
-    typedef std::map<KeyType, std::string> StringPropertyMap;
-    typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
-    typedef std::map<KeyType, void*> PointerPropertyMap;
-
-    /** IO handler to use for all file accesses. */
-    IOSystem* mIOHandler;
-    bool mIsDefaultHandler;
-
-    /** Progress handler for feedback. */
-    ProgressHandler* mProgressHandler;
-    bool mIsDefaultProgressHandler;
-
-    /** Format-specific importer worker objects - one for each format we can read.*/
-    std::vector< BaseImporter* > mImporter;
-
-    /** Post processing steps we can apply at the imported data. */
-    std::vector< BaseProcess* > mPostProcessingSteps;
-
-    /** The imported data, if ReadFile() was successful, nullptr otherwise. */
-    aiScene* mScene;
-
-    /** The error description, if there was one. In the case of an exception,
-     *  mException will carry the full details. */
-    std::string mErrorString;
-
-    /** Any exception which occurred */
-    std::exception_ptr mException;
-
-    /** List of integer properties */
-    IntPropertyMap mIntProperties;
-
-    /** List of floating-point properties */
-    FloatPropertyMap mFloatProperties;
-
-    /** List of string properties */
-    StringPropertyMap mStringProperties;
-
-    /** List of Matrix properties */
-    MatrixPropertyMap mMatrixProperties;
-
-    /** List of pointer properties */
-    PointerPropertyMap mPointerProperties;
-
-    /** Used for testing - extra verbose mode causes the ValidateDataStructure-Step
-     *  to be executed before and after every single post-process step */
-    bool bExtraVerbose;
-
-    /** Used by post-process steps to share data */
-    SharedPostProcessInfo* mPPShared;
-
-    /// The default class constructor.
-    ImporterPimpl() AI_NO_EXCEPT;
-};
-
-inline
-ImporterPimpl::ImporterPimpl() AI_NO_EXCEPT :
-        mIOHandler( nullptr ),
-        mIsDefaultHandler( false ),
-        mProgressHandler( nullptr ),
-        mIsDefaultProgressHandler( false ),
-        mImporter(),
-        mPostProcessingSteps(),
-        mScene( nullptr ),
-        mErrorString(),
-        mException(),
-        mIntProperties(),
-        mFloatProperties(),
-        mStringProperties(),
-        mMatrixProperties(),
-        mPointerProperties(),
-        bExtraVerbose( false ),
-        mPPShared( nullptr ) {
-    // empty
-}
-//! @endcond
-
-struct BatchData;
-
-// ---------------------------------------------------------------------------
-/** FOR IMPORTER PLUGINS ONLY: A helper class to the pleasure of importers
- *  that need to load many external meshes recursively.
- *
- *  The class uses several threads to load these meshes (or at least it
- *  could, this has not yet been implemented at the moment).
- *
- *  @note The class may not be used by more than one thread*/
-class ASSIMP_API BatchLoader {
-public:
-    //! @cond never
-    // -------------------------------------------------------------------
-    /** Wraps a full list of configuration properties for an importer.
-     *  Properties can be set using SetGenericProperty */
-    struct PropertyMap {
-        ImporterPimpl::IntPropertyMap     ints;
-        ImporterPimpl::FloatPropertyMap   floats;
-        ImporterPimpl::StringPropertyMap  strings;
-        ImporterPimpl::MatrixPropertyMap  matrices;
-
-        bool operator == (const PropertyMap& prop) const {
-            // fixme: really isocpp? gcc complains
-            return ints == prop.ints && floats == prop.floats && strings == prop.strings && matrices == prop.matrices;
-        }
-
-        bool empty () const {
-            return ints.empty() && floats.empty() && strings.empty() && matrices.empty();
-        }
-    };
-    //! @endcond
-
-    // -------------------------------------------------------------------
-    /** Construct a batch loader from a given IO system to be used
-     *  to access external files
-     */
-    explicit BatchLoader(IOSystem* pIO, bool validate = false );
-
-    // -------------------------------------------------------------------
-    /** The class destructor.
-     */
-    ~BatchLoader();
-
-    // -------------------------------------------------------------------
-    /** Sets the validation step. True for enable validation during postprocess.
-     *  @param  enable  True for validation.
-     */
-    void setValidation( bool enabled );
-
-    // -------------------------------------------------------------------
-    /** Returns the current validation step.
-     *  @return The current validation step.
-     */
-    bool getValidation() const;
-
-    // -------------------------------------------------------------------
-    /** Add a new file to the list of files to be loaded.
-     *  @param file File to be loaded
-     *  @param steps Post-processing steps to be executed on the file
-     *  @param map Optional configuration properties
-     *  @return 'Load request channel' - an unique ID that can later
-     *    be used to access the imported file data.
-     *  @see GetImport */
-    unsigned int AddLoadRequest (
-        const std::string& file,
-        unsigned int steps = 0,
-            const PropertyMap *map = nullptr
-        );
-
-    // -------------------------------------------------------------------
-    /** Get an imported scene.
-     *  This polls the import from the internal request list.
-     *  If an import is requested several times, this function
-     *  can be called several times, too.
-     *
-     *  @param which LRWC returned by AddLoadRequest().
-     *  @return nullptr if there is no scene with this file name
-     *  in the queue of the scene hasn't been loaded yet. */
-    aiScene* GetImport(
-        unsigned int which
-        );
-
-    // -------------------------------------------------------------------
-    /** Waits until all scenes have been loaded. This returns
-     *  immediately if no scenes are queued.*/
-    void LoadAll();
-
-private:
-    // No need to have that in the public API ...
-    BatchData *m_data;
-};
-
-} // Namespace Assimp
-
-#endif // INCLUDED_AI_IMPORTER_H
diff --git a/libs/assimp/code/Common/ImporterRegistry.cpp b/libs/assimp/code/Common/ImporterRegistry.cpp
deleted file mode 100644
index 78c02d9..0000000
--- a/libs/assimp/code/Common/ImporterRegistry.cpp
+++ /dev/null
@@ -1,393 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file ImporterRegistry.cpp
-
-Central registry for all importers available. Do not edit this file
-directly (unless you are adding new loaders), instead use the
-corresponding preprocessor flag to selectively disable formats.
-*/
-
-#include <assimp/anim.h>
-#include <assimp/BaseImporter.h>
-#include <vector>
-#include <cstdlib>
-
-// ------------------------------------------------------------------------------------------------
-// Importers
-// (include_new_importers_here)
-// ------------------------------------------------------------------------------------------------
-#ifndef ASSIMP_BUILD_NO_X_IMPORTER
-#include "AssetLib/X/XFileImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-#include "AssetLib/AMF/AMFImporter.hpp"
-#endif
-#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
-#include "AssetLib/3DS/3DSLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
-#include "AssetLib/MD3/MD3Loader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
-#include "AssetLib/MDL/MDLLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_MD2_IMPORTER
-#include "AssetLib/MD2/MD2Loader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
-#include "AssetLib/Ply/PlyLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_ASE_IMPORTER
-#include "AssetLib/ASE/ASELoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
-#include "AssetLib/Obj/ObjFileImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
-#include "AssetLib/HMP/HMPLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_SMD_IMPORTER
-#include "AssetLib/SMD/SMDLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_MDC_IMPORTER
-#include "AssetLib/MDC/MDCLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_MD5_IMPORTER
-#include "AssetLib/MD5/MD5Loader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_STL_IMPORTER
-#include "AssetLib/STL/STLLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
-#include "AssetLib/LWO/LWOLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
-#include "AssetLib/DXF/DXFLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_NFF_IMPORTER
-#include "AssetLib/NFF/NFFLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
-#include "AssetLib/Raw/RawLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_SIB_IMPORTER
-#include "AssetLib/SIB/SIBImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_OFF_IMPORTER
-#include "AssetLib/OFF/OFFLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_AC_IMPORTER
-#include "AssetLib/AC/ACLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
-#include "AssetLib/BVH/BVHLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
-#include "AssetLib/Irr/IRRMeshLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
-#include "AssetLib/Irr/IRRLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
-#include "AssetLib/Q3D/Q3DLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
-#include "AssetLib/B3D/B3DImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
-#include "AssetLib/Collada/ColladaLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
-#include "AssetLib/Terragen/TerragenLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_CSM_IMPORTER
-#include "AssetLib/CSM/CSMLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_3D_IMPORTER
-#include "AssetLib/Unreal/UnrealLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_LWS_IMPORTER
-#include "AssetLib/LWS/LWSLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
-#include "AssetLib/Ogre/OgreImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
-#include "AssetLib/OpenGEX/OpenGEXImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_MS3D_IMPORTER
-#include "AssetLib/MS3D/MS3DLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_COB_IMPORTER
-#include "AssetLib/COB/COBLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
-#include "AssetLib/Blender/BlenderLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-#include "AssetLib/Q3BSP/Q3BSPFileImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_NDO_IMPORTER
-#include "AssetLib/NDO/NDOLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "AssetLib/IFC/IFCLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_XGL_IMPORTER
-#include "AssetLib/XGL/XGLLoader.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
-#include "AssetLib/FBX/FBXImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
-#include "AssetLib/Assbin/AssbinLoader.h"
-#endif
-#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_IMPORTER)
-#include "AssetLib/glTF/glTFImporter.h"
-#endif
-#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_IMPORTER)
-#include "AssetLib/glTF2/glTF2Importer.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_C4D_IMPORTER
-#include "AssetLib/C4D/C4DImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
-#include "AssetLib/3MF/D3MFImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-#include "AssetLib/X3D/X3DImporter.hpp"
-#endif
-#ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-#include "AssetLib/MMD/MMDImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
-#include "AssetLib/M3D/M3DImporter.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_IQM_IMPORTER
-#include "AssetLib/IQM/IQMImporter.h"
-#endif
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-void GetImporterInstanceList(std::vector<BaseImporter *> &out) {
-
-    // Some importers may be unimplemented or otherwise unsuitable for general use
-    // in their current state. Devs can set ASSIMP_ENABLE_DEV_IMPORTERS in their
-    // local environment to enable them, otherwise they're left out of the registry.
-    const char *envStr = std::getenv("ASSIMP_ENABLE_DEV_IMPORTERS");
-    bool devImportersEnabled = envStr && strcmp(envStr, "0");
-
-    // Ensure no unused var warnings if all uses are #ifndef'd away below:
-    (void)devImportersEnabled;
-
-    // ----------------------------------------------------------------------------
-    // Add an instance of each worker class here
-    // (register_new_importers_here)
-    // ----------------------------------------------------------------------------
-    out.reserve(64);
-#if (!defined ASSIMP_BUILD_NO_X_IMPORTER)
-    out.push_back(new XFileImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_OBJ_IMPORTER)
-    out.push_back(new ObjFileImporter());
-#endif
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-    out.push_back(new AMFImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
-    out.push_back(new Discreet3DSImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_M3D_IMPORTER)
-    out.push_back(new M3DImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_MD3_IMPORTER)
-    out.push_back(new MD3Importer());
-#endif
-#if (!defined ASSIMP_BUILD_NO_MD2_IMPORTER)
-    out.push_back(new MD2Importer());
-#endif
-#if (!defined ASSIMP_BUILD_NO_PLY_IMPORTER)
-    out.push_back(new PLYImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_MDL_IMPORTER)
-    out.push_back(new MDLImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_ASE_IMPORTER)
-#if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
-    out.push_back(new ASEImporter());
-#endif
-#endif
-#if (!defined ASSIMP_BUILD_NO_HMP_IMPORTER)
-    out.push_back(new HMPImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_SMD_IMPORTER)
-    out.push_back(new SMDImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_MDC_IMPORTER)
-    out.push_back(new MDCImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_MD5_IMPORTER)
-    out.push_back(new MD5Importer());
-#endif
-#if (!defined ASSIMP_BUILD_NO_STL_IMPORTER)
-    out.push_back(new STLImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER)
-    out.push_back(new LWOImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_DXF_IMPORTER)
-    out.push_back(new DXFImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_NFF_IMPORTER)
-    out.push_back(new NFFImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_RAW_IMPORTER)
-    out.push_back(new RAWImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_SIB_IMPORTER)
-    out.push_back(new SIBImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_OFF_IMPORTER)
-    out.push_back(new OFFImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_AC_IMPORTER)
-    out.push_back(new AC3DImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_BVH_IMPORTER)
-    out.push_back(new BVHLoader());
-#endif
-#if (!defined ASSIMP_BUILD_NO_IRRMESH_IMPORTER)
-    out.push_back(new IRRMeshImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_IRR_IMPORTER)
-    out.push_back(new IRRImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_Q3D_IMPORTER)
-    out.push_back(new Q3DImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_B3D_IMPORTER)
-    out.push_back(new B3DImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_COLLADA_IMPORTER)
-    out.push_back(new ColladaLoader());
-#endif
-#if (!defined ASSIMP_BUILD_NO_TERRAGEN_IMPORTER)
-    out.push_back(new TerragenImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_CSM_IMPORTER)
-    out.push_back(new CSMImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_3D_IMPORTER)
-    out.push_back(new UnrealImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_LWS_IMPORTER)
-    out.push_back(new LWSImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_OGRE_IMPORTER)
-    out.push_back(new Ogre::OgreImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_OPENGEX_IMPORTER)
-    out.push_back(new OpenGEX::OpenGEXImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_MS3D_IMPORTER)
-    out.push_back(new MS3DImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_COB_IMPORTER)
-    out.push_back(new COBImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_BLEND_IMPORTER)
-    out.push_back(new BlenderImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_Q3BSP_IMPORTER)
-    out.push_back(new Q3BSPFileImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_NDO_IMPORTER)
-    out.push_back(new NDOImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_IFC_IMPORTER)
-    out.push_back(new IFCImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_XGL_IMPORTER)
-    out.push_back(new XGLImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FBX_IMPORTER)
-    out.push_back(new FBXImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_ASSBIN_IMPORTER)
-    out.push_back(new AssbinImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_GLTF_IMPORTER && !defined ASSIMP_BUILD_NO_GLTF1_IMPORTER)
-    out.push_back(new glTFImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_GLTF_IMPORTER && !defined ASSIMP_BUILD_NO_GLTF2_IMPORTER)
-    out.push_back(new glTF2Importer());
-#endif
-#if (!defined ASSIMP_BUILD_NO_C4D_IMPORTER)
-    out.push_back(new C4DImporter());
-#endif
-#if (!defined ASSIMP_BUILD_NO_3MF_IMPORTER)
-    out.push_back(new D3MFImporter());
-#endif
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-    out.push_back(new X3DImporter());
-#endif
-#ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-    out.push_back(new MMDImporter());
-#endif
-#ifndef ASSIMP_BUILD_NO_IQM_IMPORTER
-    out.push_back(new IQMImporter());
-#endif
-    //#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-    //    out.push_back(new StepFile::StepFileImporter());
-    //#endif
-}
-
-/** will delete all registered importers. */
-void DeleteImporterInstanceList(std::vector<BaseImporter *> &deleteList) {
-    for (size_t i = 0; i < deleteList.size(); ++i) {
-        delete deleteList[i];
-        deleteList[i] = nullptr;
-    } //for
-}
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/PolyTools.h b/libs/assimp/code/Common/PolyTools.h
deleted file mode 100644
index 11f6273..0000000
--- a/libs/assimp/code/Common/PolyTools.h
+++ /dev/null
@@ -1,226 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file PolyTools.h, various utilities for our dealings with arbitrary polygons */
-
-#pragma once
-#ifndef AI_POLYTOOLS_H_INCLUDED
-#define AI_POLYTOOLS_H_INCLUDED
-
-#include <assimp/material.h>
-#include <assimp/ai_assert.h>
-
-namespace Assimp {
-
-// -------------------------------------------------------------------------------
-/** Compute the signed area of a triangle.
- *  The function accepts an unconstrained template parameter for use with
- *  both aiVector3D and aiVector2D, but generally ignores the third coordinate.*/
-template <typename T>
-inline double GetArea2D(const T& v1, const T& v2, const T& v3) {
-    return 0.5 * (v1.x * ((double)v3.y - v2.y) + v2.x * ((double)v1.y - v3.y) + v3.x * ((double)v2.y - v1.y));
-}
-
-// -------------------------------------------------------------------------------
-/** Test if a given point p2 is on the left side of the line formed by p0-p1.
- *  The function accepts an unconstrained template parameter for use with
- *  both aiVector3D and aiVector2D, but generally ignores the third coordinate.*/
-template <typename T>
-inline bool OnLeftSideOfLine2D(const T& p0, const T& p1,const T& p2) {
-    return GetArea2D(p0,p2,p1) > 0;
-}
-
-// -------------------------------------------------------------------------------
-/** Test if a given point is inside a given triangle in R2.
- * The function accepts an unconstrained template parameter for use with
- *  both aiVector3D and aiVector2D, but generally ignores the third coordinate.*/
-template <typename T>
-inline bool PointInTriangle2D(const T& p0, const T& p1,const T& p2, const T& pp) {
-    // Point in triangle test using baryzentric coordinates
-    const aiVector2D v0 = p1 - p0;
-    const aiVector2D v1 = p2 - p0;
-    const aiVector2D v2 = pp - p0;
-
-    double dot00 = v0 * v0;
-    double dot11 = v1 * v1;
-    const double dot01 = v0 * v1;
-    const double dot02 = v0 * v2;
-    const double dot12 = v1 * v2;
-    const double denom = dot00 * dot11 - dot01 * dot01;
-    if (denom == 0.0) {
-        return false;
-    }
-    
-    const double invDenom = 1.0 / denom;
-    dot11 = (dot11 * dot02 - dot01 * dot12) * invDenom;
-    dot00 = (dot00 * dot12 - dot01 * dot02) * invDenom;
-
-    return (dot11 > 0) && (dot00 > 0) && (dot11 + dot00 < 1);
-}
-
-
-// -------------------------------------------------------------------------------
-/** Check whether the winding order of a given polygon is counter-clockwise.
- *  The function accepts an unconstrained template parameter, but is intended
- *  to be used only with aiVector2D and aiVector3D (z axis is ignored, only
- *  x and y are taken into account).
- * @note Code taken from http://cgm.cs.mcgill.ca/~godfried/teaching/cg-projects/97/Ian/applet1.html and translated to C++
- */
-template <typename T>
-inline bool IsCCW(T* in, size_t npoints) {
-    double aa, bb, cc, b, c, theta;
-    double convex_turn;
-    double convex_sum = 0;
-
-    ai_assert(npoints >= 3);
-
-    for (size_t i = 0; i < npoints - 2; i++) {
-        aa = ((in[i+2].x - in[i].x) * (in[i+2].x - in[i].x)) +
-            ((-in[i+2].y + in[i].y) * (-in[i+2].y + in[i].y));
-
-        bb = ((in[i+1].x - in[i].x) * (in[i+1].x - in[i].x)) +
-            ((-in[i+1].y + in[i].y) * (-in[i+1].y + in[i].y));
-
-        cc = ((in[i+2].x - in[i+1].x) *
-            (in[i+2].x - in[i+1].x)) +
-            ((-in[i+2].y + in[i+1].y) *
-            (-in[i+2].y + in[i+1].y));
-
-        b = std::sqrt(bb);
-        c = std::sqrt(cc);
-        theta = std::acos((bb + cc - aa) / (2 * b * c));
-
-        if (OnLeftSideOfLine2D(in[i],in[i+2],in[i+1])) {
-            //  if (convex(in[i].x, in[i].y,
-            //      in[i+1].x, in[i+1].y,
-            //      in[i+2].x, in[i+2].y)) {
-            convex_turn = AI_MATH_PI_F - theta;
-            convex_sum += convex_turn;
-        } else {
-            convex_sum -= AI_MATH_PI_F - theta;
-        }
-    }
-    aa = ((in[1].x - in[npoints-2].x) *
-        (in[1].x - in[npoints-2].x)) +
-        ((-in[1].y + in[npoints-2].y) *
-        (-in[1].y + in[npoints-2].y));
-
-    bb = ((in[0].x - in[npoints-2].x) *
-        (in[0].x - in[npoints-2].x)) +
-        ((-in[0].y + in[npoints-2].y) *
-        (-in[0].y + in[npoints-2].y));
-
-    cc = ((in[1].x - in[0].x) * (in[1].x - in[0].x)) +
-        ((-in[1].y + in[0].y) * (-in[1].y + in[0].y));
-
-    b = std::sqrt(bb);
-    c = std::sqrt(cc);
-    theta = std::acos((bb + cc - aa) / (2 * b * c));
-
-    //if (convex(in[npoints-2].x, in[npoints-2].y,
-    //  in[0].x, in[0].y,
-    //  in[1].x, in[1].y)) {
-    if (OnLeftSideOfLine2D(in[npoints-2],in[1],in[0])) {
-        convex_turn = AI_MATH_PI_F - theta;
-        convex_sum += convex_turn;
-    } else {
-        convex_sum -= AI_MATH_PI_F - theta;
-    }
-
-    return convex_sum >= (2 * AI_MATH_PI_F);
-}
-
-// -------------------------------------------------------------------------------
-/** Compute the normal of an arbitrary polygon in R3.
- *
- *  The code is based on Newell's formula, that is a polygons normal is the ratio
- *  of its area when projected onto the three coordinate axes.
- *
- *  @param out Receives the output normal
- *  @param num Number of input vertices
- *  @param x X data source. x[ofs_x*n] is the n'th element.
- *  @param y Y data source. y[ofs_y*n] is the y'th element
- *  @param z Z data source. z[ofs_z*n] is the z'th element
- *
- *  @note The data arrays must have storage for at least num+2 elements. Using
- *  this method is much faster than the 'other' NewellNormal()
- */
-template <int ofs_x, int ofs_y, int ofs_z, typename TReal>
-inline void NewellNormal (aiVector3t<TReal>& out, int num, TReal* x, TReal* y, TReal* z) {
-    // Duplicate the first two vertices at the end
-    x[(num+0)*ofs_x] = x[0];
-    x[(num+1)*ofs_x] = x[ofs_x];
-
-    y[(num+0)*ofs_y] = y[0];
-    y[(num+1)*ofs_y] = y[ofs_y];
-
-    z[(num+0)*ofs_z] = z[0];
-    z[(num+1)*ofs_z] = z[ofs_z];
-
-    TReal sum_xy = 0.0, sum_yz = 0.0, sum_zx = 0.0;
-
-    TReal *xptr = x +ofs_x, *xlow = x, *xhigh = x + ofs_x*2;
-    TReal *yptr = y +ofs_y, *ylow = y, *yhigh = y + ofs_y*2;
-    TReal *zptr = z +ofs_z, *zlow = z, *zhigh = z + ofs_z*2;
-
-    for (int tmp=0; tmp < num; tmp++) {
-        sum_xy += (*xptr) * ( (*yhigh) - (*ylow) );
-        sum_yz += (*yptr) * ( (*zhigh) - (*zlow) );
-        sum_zx += (*zptr) * ( (*xhigh) - (*xlow) );
-
-        xptr  += ofs_x;
-        xlow  += ofs_x;
-        xhigh += ofs_x;
-
-        yptr  += ofs_y;
-        ylow  += ofs_y;
-        yhigh += ofs_y;
-
-        zptr  += ofs_z;
-        zlow  += ofs_z;
-        zhigh += ofs_z;
-    }
-    out = aiVector3t<TReal>(sum_yz,sum_zx,sum_xy);
-}
-
-} // ! namespace Assimp
-
-#endif // AI_POLYTOOLS_H_INCLUDED
diff --git a/libs/assimp/code/Common/PostStepRegistry.cpp b/libs/assimp/code/Common/PostStepRegistry.cpp
deleted file mode 100644
index de4f390..0000000
--- a/libs/assimp/code/Common/PostStepRegistry.cpp
+++ /dev/null
@@ -1,265 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file ImporterRegistry.cpp
-
-Central registry for all postprocessing steps available. Do not edit this file
-directly (unless you are adding new steps), instead use the
-corresponding preprocessor flag to selectively disable steps.
-*/
-
-#include "PostProcessing/ProcessHelper.h"
-
-#ifndef ASSIMP_BUILD_NO_CALCTANGENTS_PROCESS
-#   include "PostProcessing/CalcTangentsProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_JOINVERTICES_PROCESS
-#   include "PostProcessing/JoinVerticesProcess.h"
-#endif
-#if !(defined ASSIMP_BUILD_NO_MAKELEFTHANDED_PROCESS && defined ASSIMP_BUILD_NO_FLIPUVS_PROCESS && defined ASSIMP_BUILD_NO_FLIPWINDINGORDER_PROCESS)
-#   include "PostProcessing/ConvertToLHProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_TRIANGULATE_PROCESS
-#   include "PostProcessing/TriangulateProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_DROPFACENORMALS_PROCESS
-#   include "PostProcessing/DropFaceNormalsProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS
-#   include "PostProcessing/GenFaceNormalsProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_GENVERTEXNORMALS_PROCESS
-#   include "PostProcessing/GenVertexNormalsProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_REMOVEVC_PROCESS
-#   include "PostProcessing/RemoveVCProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_SPLITLARGEMESHES_PROCESS
-#   include "PostProcessing/SplitLargeMeshes.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_PRETRANSFORMVERTICES_PROCESS
-#   include "PostProcessing/PretransformVertices.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_LIMITBONEWEIGHTS_PROCESS
-#   include "PostProcessing/LimitBoneWeightsProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
-#   include "PostProcessing/ValidateDataStructure.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_IMPROVECACHELOCALITY_PROCESS
-#   include "PostProcessing/ImproveCacheLocality.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_FIXINFACINGNORMALS_PROCESS
-#   include "PostProcessing/FixNormalsStep.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_REMOVE_REDUNDANTMATERIALS_PROCESS
-#   include "PostProcessing/RemoveRedundantMaterials.h"
-#endif
-#if (!defined ASSIMP_BUILD_NO_EMBEDTEXTURES_PROCESS)
-#   include "PostProcessing/EmbedTexturesProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
-#   include "PostProcessing/FindInvalidDataProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_FINDDEGENERATES_PROCESS
-#   include "PostProcessing/FindDegenerates.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_SORTBYPTYPE_PROCESS
-#   include "PostProcessing/SortByPTypeProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_GENUVCOORDS_PROCESS
-#   include "PostProcessing/ComputeUVMappingProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_TRANSFORMTEXCOORDS_PROCESS
-#   include "PostProcessing/TextureTransform.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_FINDINSTANCES_PROCESS
-#   include "PostProcessing/FindInstancesProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_OPTIMIZEMESHES_PROCESS
-#   include "PostProcessing/OptimizeMeshes.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
-#   include "PostProcessing/OptimizeGraph.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS
-#   include "PostProcessing/SplitByBoneCountProcess.h"
-#endif
-#ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS
-#   include "PostProcessing/DeboneProcess.h"
-#endif
-#if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS)
-#   include "PostProcessing/ScaleProcess.h"
-#endif
-#if (!defined ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS)
-#   include "PostProcessing/ArmaturePopulate.h"
-#endif
-#if (!defined ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS)
-#   include "PostProcessing/GenBoundingBoxesProcess.h"
-#endif
-
-
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out)
-{
-    // ----------------------------------------------------------------------------
-    // Add an instance of each post processing step here in the order
-    // of sequence it is executed. Steps that are added here are not
-    // validated - as RegisterPPStep() does - all dependencies must be given.
-    // ----------------------------------------------------------------------------
-    out.reserve(31);
-#if (!defined ASSIMP_BUILD_NO_MAKELEFTHANDED_PROCESS)
-    out.push_back( new MakeLeftHandedProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FLIPUVS_PROCESS)
-    out.push_back( new FlipUVsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FLIPWINDINGORDER_PROCESS)
-    out.push_back( new FlipWindingOrderProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_REMOVEVC_PROCESS)
-    out.push_back( new RemoveVCProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_REMOVE_REDUNDANTMATERIALS_PROCESS)
-    out.push_back( new RemoveRedundantMatsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_EMBEDTEXTURES_PROCESS)
-    out.push_back( new EmbedTexturesProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FINDINSTANCES_PROCESS)
-    out.push_back( new FindInstancesProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS)
-    out.push_back( new OptimizeGraphProcess());
-#endif
-#ifndef ASSIMP_BUILD_NO_GENUVCOORDS_PROCESS
-    out.push_back( new ComputeUVMappingProcess());
-#endif
-#ifndef ASSIMP_BUILD_NO_TRANSFORMTEXCOORDS_PROCESS
-    out.push_back( new TextureTransformStep());
-#endif
-#if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS)
-    out.push_back( new ScaleProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS)
-    out.push_back( new ArmaturePopulate());
-#endif
-#if (!defined ASSIMP_BUILD_NO_PRETRANSFORMVERTICES_PROCESS)
-    out.push_back( new PretransformVertices());
-#endif
-#if (!defined ASSIMP_BUILD_NO_TRIANGULATE_PROCESS)
-    out.push_back( new TriangulateProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FINDDEGENERATES_PROCESS)
-    //find degenerates should run after triangulation (to sort out small
-    //generated triangles) but before sort by p types (in case there are lines
-    //and points generated and inserted into a mesh)
-    out.push_back( new FindDegeneratesProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_SORTBYPTYPE_PROCESS)
-    out.push_back( new SortByPTypeProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS)
-    out.push_back( new FindInvalidDataProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_OPTIMIZEMESHES_PROCESS)
-    out.push_back( new OptimizeMeshesProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_FIXINFACINGNORMALS_PROCESS)
-    out.push_back( new FixInfacingNormalsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS)
-    out.push_back( new SplitByBoneCountProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_SPLITLARGEMESHES_PROCESS)
-    out.push_back( new SplitLargeMeshesProcess_Triangle());
-#endif
-#if (!defined ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS)
-    out.push_back( new DropFaceNormalsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS)
-    out.push_back( new GenFaceNormalsProcess());
-#endif
-    // .........................................................................
-    // DON'T change the order of these five ..
-    // XXX this is actually a design weakness that dates back to the time
-    // when Importer would maintain the postprocessing step list exclusively.
-    // Now that others access it too, we need a better solution.
-    out.push_back( new ComputeSpatialSortProcess());
-    // .........................................................................
-
-#if (!defined ASSIMP_BUILD_NO_GENVERTEXNORMALS_PROCESS)
-    out.push_back( new GenVertexNormalsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_CALCTANGENTS_PROCESS)
-    out.push_back( new CalcTangentsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_JOINVERTICES_PROCESS)
-    out.push_back( new JoinVerticesProcess());
-#endif
-
-    // .........................................................................
-    out.push_back( new DestroySpatialSortProcess());
-    // .........................................................................
-
-#if (!defined ASSIMP_BUILD_NO_SPLITLARGEMESHES_PROCESS)
-    out.push_back( new SplitLargeMeshesProcess_Vertex());
-#endif
-#if (!defined ASSIMP_BUILD_NO_DEBONE_PROCESS)
-    out.push_back( new DeboneProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_LIMITBONEWEIGHTS_PROCESS)
-    out.push_back( new LimitBoneWeightsProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_IMPROVECACHELOCALITY_PROCESS)
-    out.push_back( new ImproveCacheLocalityProcess());
-#endif
-#if (!defined ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS)
-    out.push_back(new GenBoundingBoxesProcess);
-#endif
-}
-
-}
diff --git a/libs/assimp/code/Common/RemoveComments.cpp b/libs/assimp/code/Common/RemoveComments.cpp
deleted file mode 100644
index 4fae21c..0000000
--- a/libs/assimp/code/Common/RemoveComments.cpp
+++ /dev/null
@@ -1,121 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** 
- *  @file  RemoveComments.cpp
- *  @brief Defines the CommentRemover utility class
- */
-
-#include <assimp/RemoveComments.h>
-#include <assimp/ParsingUtils.h>
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-// Remove line comments from a file
-void CommentRemover::RemoveLineComments(const char* szComment, char* szBuffer, char chReplacement /* = ' ' */) {
-    // validate parameters
-    ai_assert(nullptr != szComment);
-    ai_assert(nullptr != szBuffer);
-    ai_assert(*szComment);
-
-    size_t len = strlen(szComment);
-    const size_t lenBuffer = strlen(szBuffer);
-    if (len > lenBuffer) {
-        len = lenBuffer;
-    }
-
-    for(size_t i = 0; i < lenBuffer; i++) {
-        // skip over quotes
-        if (szBuffer[i] == '\"' || szBuffer[i] == '\'')
-            while (++i < lenBuffer && szBuffer[i] != '\"' && szBuffer[i] != '\'');
-
-        if(lenBuffer - i < len) {
-            break;
-        }
-
-        if (!strncmp(szBuffer + i,szComment,len)) {
-            while (i < lenBuffer && !IsLineEnd(szBuffer[i])) {
-                szBuffer[i++] = chReplacement;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Remove multi-line comments from a file
-void CommentRemover::RemoveMultiLineComments(const char* szCommentStart,
-        const char* szCommentEnd,char* szBuffer,
-        char chReplacement) {
-    // validate parameters
-    ai_assert(nullptr != szCommentStart);
-    ai_assert(nullptr != szCommentEnd);
-    ai_assert(nullptr != szBuffer);
-    ai_assert(*szCommentStart);
-    ai_assert(*szCommentEnd);
-
-    const size_t len  = strlen(szCommentEnd);
-    const size_t len2 = strlen(szCommentStart);
-
-    while (*szBuffer)   {
-        // skip over quotes
-        if (*szBuffer == '\"' || *szBuffer == '\'') {
-            while (*szBuffer++ && *szBuffer != '\"' && *szBuffer != '\'');
-        }
-
-        if (!strncmp(szBuffer,szCommentStart,len2))  {
-            while (*szBuffer) {
-                if (!::strncmp(szBuffer,szCommentEnd,len)) {
-                    for (unsigned int i = 0; i < len;++i) {
-                        *szBuffer++ = chReplacement;
-                    }
-
-                    break;
-                }
-                *szBuffer++ = chReplacement;
-            }
-            continue;
-        }
-        ++szBuffer;
-    }
-}
-
-} // !! Assimp
diff --git a/libs/assimp/code/Common/SGSpatialSort.cpp b/libs/assimp/code/Common/SGSpatialSort.cpp
deleted file mode 100644
index 0d16d6f..0000000
--- a/libs/assimp/code/Common/SGSpatialSort.cpp
+++ /dev/null
@@ -1,168 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the helper class to quickly find
-vertices close to a given position. Special implementation for
-the 3ds loader handling smooth groups correctly  */
-
-#include <assimp/SGSpatialSort.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-SGSpatialSort::SGSpatialSort()
-{
-    // define the reference plane. We choose some arbitrary vector away from all basic axes
-    // in the hope that no model spreads all its vertices along this plane.
-    mPlaneNormal.Set( 0.8523f, 0.34321f, 0.5736f);
-    mPlaneNormal.Normalize();
-}
-// ------------------------------------------------------------------------------------------------
-// Destructor
-SGSpatialSort::~SGSpatialSort()
-{
-    // nothing to do here, everything destructs automatically
-}
-// ------------------------------------------------------------------------------------------------
-void SGSpatialSort::Add(const aiVector3D& vPosition, unsigned int index,
-    unsigned int smoothingGroup)
-{
-    // store position by index and distance
-    float distance = vPosition * mPlaneNormal;
-    mPositions.push_back( Entry( index, vPosition,
-        distance, smoothingGroup));
-}
-// ------------------------------------------------------------------------------------------------
-void SGSpatialSort::Prepare()
-{
-    // now sort the array ascending by distance.
-    std::sort( this->mPositions.begin(), this->mPositions.end());
-}
-// ------------------------------------------------------------------------------------------------
-// Returns an iterator for all positions close to the given position.
-void SGSpatialSort::FindPositions( const aiVector3D& pPosition,
-    uint32_t pSG,
-    float pRadius,
-    std::vector<unsigned int>& poResults,
-    bool exactMatch /*= false*/) const
-{
-    float dist = pPosition * mPlaneNormal;
-    float minDist = dist - pRadius, maxDist = dist + pRadius;
-
-    // clear the array
-    poResults.clear();
-
-    // quick check for positions outside the range
-    if( mPositions.empty() )
-        return;
-    if( maxDist < mPositions.front().mDistance)
-        return;
-    if( minDist > mPositions.back().mDistance)
-        return;
-
-    // do a binary search for the minimal distance to start the iteration there
-    unsigned int index = (unsigned int)mPositions.size() / 2;
-    unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4;
-    while( binaryStepSize > 1)
-    {
-        if( mPositions[index].mDistance < minDist)
-            index += binaryStepSize;
-        else
-            index -= binaryStepSize;
-
-        binaryStepSize /= 2;
-    }
-
-    // depending on the direction of the last step we need to single step a bit back or forth
-    // to find the actual beginning element of the range
-    while( index > 0 && mPositions[index].mDistance > minDist)
-        index--;
-    while( index < (mPositions.size() - 1) && mPositions[index].mDistance < minDist)
-        index++;
-
-    // Mow start iterating from there until the first position lays outside of the distance range.
-    // Add all positions inside the distance range within the given radius to the result array
-
-    float squareEpsilon = pRadius * pRadius;
-    std::vector<Entry>::const_iterator it  = mPositions.begin() + index;
-    std::vector<Entry>::const_iterator end = mPositions.end();
-
-    if (exactMatch)
-    {
-        while( it->mDistance < maxDist)
-        {
-            if((it->mPosition - pPosition).SquareLength() < squareEpsilon && it->mSmoothGroups == pSG)
-            {
-                poResults.push_back( it->mIndex);
-            }
-            ++it;
-            if( end == it )break;
-        }
-    }
-    else
-    {
-        // if the given smoothing group is 0, we'll return all surrounding vertices
-        if (!pSG)
-        {
-            while( it->mDistance < maxDist)
-            {
-                if((it->mPosition - pPosition).SquareLength() < squareEpsilon)
-                    poResults.push_back( it->mIndex);
-                ++it;
-                if( end == it)break;
-            }
-        }
-        else while( it->mDistance < maxDist)
-        {
-            if((it->mPosition - pPosition).SquareLength() < squareEpsilon &&
-                (it->mSmoothGroups & pSG || !it->mSmoothGroups))
-            {
-                poResults.push_back( it->mIndex);
-            }
-            ++it;
-            if( end == it)break;
-        }
-    }
-}
-
-
diff --git a/libs/assimp/code/Common/SceneCombiner.cpp b/libs/assimp/code/Common/SceneCombiner.cpp
deleted file mode 100644
index 2c2539e..0000000
--- a/libs/assimp/code/Common/SceneCombiner.cpp
+++ /dev/null
@@ -1,1375 +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.
-
-----------------------------------------------------------------------
-*/
-
-// TODO: refactor entire file to get rid of the "flat-copy" first approach
-// to copying structures. This easily breaks in the most unintuitive way
-// possible as new fields are added to assimp structures.
-
-// ----------------------------------------------------------------------------
-/**
-  * @file Implements Assimp::SceneCombiner. This is a smart utility
-  *       class that combines multiple scenes, meshes, ... into one. Currently
-  *       these utilities are used by the IRR and LWS loaders and the
-  *       OptimizeGraph step.
-  */
-// ----------------------------------------------------------------------------
-#include "ScenePrivate.h"
-#include "time.h"
-#include <assimp/Hash.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/StringUtils.h>
-#include <assimp/fast_atof.h>
-#include <assimp/mesh.h>
-#include <assimp/metadata.h>
-#include <assimp/scene.h>
-#include <stdio.h>
-#include <assimp/DefaultLogger.hpp>
-
-namespace Assimp {
-
-#if (__GNUC__ >= 8 && __GNUC_MINOR__ >= 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wclass-memaccess"
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Add a prefix to a string
-inline void PrefixString(aiString &string, const char *prefix, unsigned int len) {
-    // If the string is already prefixed, we won't prefix it a second time
-    if (string.length >= 1 && string.data[0] == '$')
-        return;
-
-    if (len + string.length >= MAXLEN - 1) {
-        ASSIMP_LOG_VERBOSE_DEBUG("Can't add an unique prefix because the string is too long");
-        ai_assert(false);
-        return;
-    }
-
-    // Add the prefix
-    ::memmove(string.data + len, string.data, string.length + 1);
-    ::memcpy(string.data, prefix, len);
-
-    // And update the string's length
-    string.length += len;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Add node identifiers to a hashing set
-void SceneCombiner::AddNodeHashes(aiNode *node, std::set<unsigned int> &hashes) {
-    // Add node name to hashing set if it is non-empty - empty nodes are allowed
-    // and they can't have any anims assigned so its absolutely safe to duplicate them.
-    if (node->mName.length) {
-        hashes.insert(SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length)));
-    }
-
-    // Process all children recursively
-    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-        AddNodeHashes(node->mChildren[i], hashes);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Add a name prefix to all nodes in a hierarchy
-void SceneCombiner::AddNodePrefixes(aiNode *node, const char *prefix, unsigned int len) {
-    ai_assert(nullptr != prefix);
-
-    PrefixString(node->mName, prefix, len);
-
-    // Process all children recursively
-    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-        AddNodePrefixes(node->mChildren[i], prefix, len);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Search for matching names
-bool SceneCombiner::FindNameMatch(const aiString &name, std::vector<SceneHelper> &input, unsigned int cur) {
-    const unsigned int hash = SuperFastHash(name.data, static_cast<uint32_t>(name.length));
-
-    // Check whether we find a positive match in one of the given sets
-    for (unsigned int i = 0; i < input.size(); ++i) {
-        if (cur != i && input[i].hashes.find(hash) != input[i].hashes.end()) {
-            return true;
-        }
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Add a name prefix to all nodes in a hierarchy if a hash match is found
-void SceneCombiner::AddNodePrefixesChecked(aiNode *node, const char *prefix, unsigned int len,
-        std::vector<SceneHelper> &input, unsigned int cur) {
-    ai_assert(nullptr != prefix);
-
-    const unsigned int hash = SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length));
-
-    // Check whether we find a positive match in one of the given sets
-    for (unsigned int i = 0; i < input.size(); ++i) {
-        if (cur != i && input[i].hashes.find(hash) != input[i].hashes.end()) {
-            PrefixString(node->mName, prefix, len);
-            break;
-        }
-    }
-
-    // Process all children recursively
-    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-        AddNodePrefixesChecked(node->mChildren[i], prefix, len, input, cur);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Add an offset to all mesh indices in a node graph
-void SceneCombiner::OffsetNodeMeshIndices(aiNode *node, unsigned int offset) {
-    for (unsigned int i = 0; i < node->mNumMeshes; ++i)
-        node->mMeshes[i] += offset;
-
-    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-        OffsetNodeMeshIndices(node->mChildren[i], offset);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Merges two scenes. Currently only used by the LWS loader.
-void SceneCombiner::MergeScenes(aiScene **_dest, std::vector<aiScene *> &src, unsigned int flags) {
-    if (nullptr == _dest) {
-        return;
-    }
-
-    // if _dest points to nullptr allocate a new scene. Otherwise clear the old and reuse it
-    if (src.empty()) {
-        if (*_dest) {
-            (*_dest)->~aiScene();
-            SceneCombiner::CopySceneFlat(_dest, src[0]);
-        } else
-            *_dest = src[0];
-        return;
-    }
-    if (*_dest) {
-        (*_dest)->~aiScene();
-        new (*_dest) aiScene();
-    } else
-        *_dest = new aiScene();
-
-    // Create a dummy scene to serve as master for the others
-    aiScene *master = new aiScene();
-    master->mRootNode = new aiNode();
-    master->mRootNode->mName.Set("<MergeRoot>");
-
-    std::vector<AttachmentInfo> srcList(src.size());
-    for (unsigned int i = 0; i < srcList.size(); ++i) {
-        srcList[i] = AttachmentInfo(src[i], master->mRootNode);
-    }
-
-    // 'master' will be deleted afterwards
-    MergeScenes(_dest, master, srcList, flags);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::AttachToGraph(aiNode *attach, std::vector<NodeAttachmentInfo> &srcList) {
-    unsigned int cnt;
-    for (cnt = 0; cnt < attach->mNumChildren; ++cnt) {
-        AttachToGraph(attach->mChildren[cnt], srcList);
-    }
-
-    cnt = 0;
-    for (std::vector<NodeAttachmentInfo>::iterator it = srcList.begin();
-            it != srcList.end(); ++it) {
-        if ((*it).attachToNode == attach && !(*it).resolved)
-            ++cnt;
-    }
-
-    if (cnt) {
-        aiNode **n = new aiNode *[cnt + attach->mNumChildren];
-        if (attach->mNumChildren) {
-            ::memcpy(n, attach->mChildren, sizeof(void *) * attach->mNumChildren);
-            delete[] attach->mChildren;
-        }
-        attach->mChildren = n;
-
-        n += attach->mNumChildren;
-        attach->mNumChildren += cnt;
-
-        for (unsigned int i = 0; i < srcList.size(); ++i) {
-            NodeAttachmentInfo &att = srcList[i];
-            if (att.attachToNode == attach && !att.resolved) {
-                *n = att.node;
-                (**n).mParent = attach;
-                ++n;
-
-                // mark this attachment as resolved
-                att.resolved = true;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::AttachToGraph(aiScene *master, std::vector<NodeAttachmentInfo> &src) {
-    ai_assert(nullptr != master);
-
-    AttachToGraph(master->mRootNode, src);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<AttachmentInfo> &srcList, unsigned int flags) {
-    if (nullptr == _dest) {
-        return;
-    }
-
-    // if _dest points to nullptr allocate a new scene. Otherwise clear the old and reuse it
-    if (srcList.empty()) {
-        if (*_dest) {
-            SceneCombiner::CopySceneFlat(_dest, master);
-        } else
-            *_dest = master;
-        return;
-    }
-    if (*_dest) {
-        (*_dest)->~aiScene();
-        new (*_dest) aiScene();
-    } else
-        *_dest = new aiScene();
-
-    aiScene *dest = *_dest;
-
-    std::vector<SceneHelper> src(srcList.size() + 1);
-    src[0].scene = master;
-    for (unsigned int i = 0; i < srcList.size(); ++i) {
-        src[i + 1] = SceneHelper(srcList[i].scene);
-    }
-
-    // this helper array specifies which scenes are duplicates of others
-    std::vector<unsigned int> duplicates(src.size(), UINT_MAX);
-
-    // this helper array is used as lookup table several times
-    std::vector<unsigned int> offset(src.size());
-
-    // Find duplicate scenes
-    for (unsigned int i = 0; i < src.size(); ++i) {
-        if (duplicates[i] != i && duplicates[i] != UINT_MAX) {
-            continue;
-        }
-
-        duplicates[i] = i;
-        for (unsigned int a = i + 1; a < src.size(); ++a) {
-            if (src[i].scene == src[a].scene) {
-                duplicates[a] = i;
-            }
-        }
-    }
-
-    // Generate unique names for all named stuff?
-    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
-#if 0
-        // Construct a proper random number generator
-        boost::mt19937 rng(  );
-        boost::uniform_int<> dist(1u,1 << 24u);
-        boost::variate_generator<boost::mt19937&, boost::uniform_int<> > rndGen(rng, dist);
-#endif
-        for (unsigned int i = 1; i < src.size(); ++i) {
-            //if (i != duplicates[i])
-            //{
-            //  // duplicate scenes share the same UID
-            //  ::strcpy( src[i].id, src[duplicates[i]].id );
-            //  src[i].idlen = src[duplicates[i]].idlen;
-
-            //  continue;
-            //}
-
-            src[i].idlen = ai_snprintf(src[i].id, 32, "$%.6X$_", i);
-
-            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-
-                // Compute hashes for all identifiers in this scene and store them
-                // in a sorted table (for convenience I'm using std::set). We hash
-                // just the node and animation channel names, all identifiers except
-                // the material names should be caught by doing this.
-                AddNodeHashes(src[i]->mRootNode, src[i].hashes);
-
-                for (unsigned int a = 0; a < src[i]->mNumAnimations; ++a) {
-                    aiAnimation *anim = src[i]->mAnimations[a];
-                    src[i].hashes.insert(SuperFastHash(anim->mName.data, static_cast<uint32_t>(anim->mName.length)));
-                }
-            }
-        }
-    }
-
-    unsigned int cnt;
-
-    // First find out how large the respective output arrays must be
-    for (unsigned int n = 0; n < src.size(); ++n) {
-        SceneHelper *cur = &src[n];
-
-        if (n == duplicates[n] || flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY) {
-            dest->mNumTextures += (*cur)->mNumTextures;
-            dest->mNumMaterials += (*cur)->mNumMaterials;
-            dest->mNumMeshes += (*cur)->mNumMeshes;
-        }
-
-        dest->mNumLights += (*cur)->mNumLights;
-        dest->mNumCameras += (*cur)->mNumCameras;
-        dest->mNumAnimations += (*cur)->mNumAnimations;
-
-        // Combine the flags of all scenes
-        // We need to process them flag-by-flag here to get correct results
-        // dest->mFlags ; //|= (*cur)->mFlags;
-        if ((*cur)->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
-            dest->mFlags |= AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
-        }
-    }
-
-    // generate the output texture list + an offset table for all texture indices
-    if (dest->mNumTextures) {
-        aiTexture **pip = dest->mTextures = new aiTexture *[dest->mNumTextures];
-        cnt = 0;
-        for (unsigned int n = 0; n < src.size(); ++n) {
-            SceneHelper *cur = &src[n];
-            for (unsigned int i = 0; i < (*cur)->mNumTextures; ++i) {
-                if (n != duplicates[n]) {
-                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
-                        Copy(pip, (*cur)->mTextures[i]);
-
-                    else
-                        continue;
-                } else
-                    *pip = (*cur)->mTextures[i];
-                ++pip;
-            }
-
-            offset[n] = cnt;
-            cnt = (unsigned int)(pip - dest->mTextures);
-        }
-    }
-
-    // generate the output material list + an offset table for all material indices
-    if (dest->mNumMaterials) {
-        aiMaterial **pip = dest->mMaterials = new aiMaterial *[dest->mNumMaterials];
-        cnt = 0;
-        for (unsigned int n = 0; n < src.size(); ++n) {
-            SceneHelper *cur = &src[n];
-            for (unsigned int i = 0; i < (*cur)->mNumMaterials; ++i) {
-                if (n != duplicates[n]) {
-                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
-                        Copy(pip, (*cur)->mMaterials[i]);
-
-                    else
-                        continue;
-                } else
-                    *pip = (*cur)->mMaterials[i];
-
-                if ((*cur)->mNumTextures != dest->mNumTextures) {
-                    // We need to update all texture indices of the mesh. So we need to search for
-                    // a material property called '$tex.file'
-
-                    for (unsigned int a = 0; a < (*pip)->mNumProperties; ++a) {
-                        aiMaterialProperty *prop = (*pip)->mProperties[a];
-                        if (!strncmp(prop->mKey.data, "$tex.file", 9)) {
-                            // Check whether this texture is an embedded texture.
-                            // In this case the property looks like this: *<n>,
-                            // where n is the index of the texture.
-                            // Copy here because we overwrite the string data in-place and the buffer inside of aiString
-                            // will be a lie if we just reinterpret from prop->mData. The size of mData is not guaranteed to be
-                            // MAXLEN in size.
-                            aiString s(*(aiString *)prop->mData);
-                            if ('*' == s.data[0]) {
-                                // Offset the index and write it back ..
-                                const unsigned int idx = strtoul10(&s.data[1]) + offset[n];
-                                const unsigned int oldLen = s.length;
-
-                                s.length = 1 + ASSIMP_itoa10(&s.data[1], sizeof(s.data) - 1, idx);
-
-                                // The string changed in size so we need to reallocate the buffer for the property.
-                                if (oldLen < s.length) {
-                                    prop->mDataLength += s.length - oldLen;
-                                    delete[] prop->mData;
-                                    prop->mData = new char[prop->mDataLength];
-                                }
-
-                                memcpy(prop->mData, static_cast<void*>(&s), prop->mDataLength);
-                            }
-                        }
-
-                        // Need to generate new, unique material names?
-                        else if (!::strcmp(prop->mKey.data, "$mat.name") && flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) {
-                            aiString *pcSrc = (aiString *)prop->mData;
-                            PrefixString(*pcSrc, (*cur).id, (*cur).idlen);
-                        }
-                    }
-                }
-                ++pip;
-            }
-
-            offset[n] = cnt;
-            cnt = (unsigned int)(pip - dest->mMaterials);
-        }
-    }
-
-    // generate the output mesh list + again an offset table for all mesh indices
-    if (dest->mNumMeshes) {
-        aiMesh **pip = dest->mMeshes = new aiMesh *[dest->mNumMeshes];
-        cnt = 0;
-        for (unsigned int n = 0; n < src.size(); ++n) {
-            SceneHelper *cur = &src[n];
-            for (unsigned int i = 0; i < (*cur)->mNumMeshes; ++i) {
-                if (n != duplicates[n]) {
-                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
-                        Copy(pip, (*cur)->mMeshes[i]);
-
-                    else
-                        continue;
-                } else
-                    *pip = (*cur)->mMeshes[i];
-
-                // update the material index of the mesh
-                (*pip)->mMaterialIndex += offset[n];
-                ++pip;
-            }
-
-            // reuse the offset array - store now the mesh offset in it
-            offset[n] = cnt;
-            cnt = (unsigned int)(pip - dest->mMeshes);
-        }
-    }
-
-    std::vector<NodeAttachmentInfo> nodes;
-    nodes.reserve(srcList.size());
-
-    // ----------------------------------------------------------------------------
-    // Now generate the output node graph. We need to make those
-    // names in the graph that are referenced by anims or lights
-    // or cameras unique. So we add a prefix to them ... $<rand>_
-    // We could also use a counter, but using a random value allows us to
-    // use just one prefix if we are joining multiple scene hierarchies recursively.
-    // Chances are quite good we don't collide, so we try that ...
-    // ----------------------------------------------------------------------------
-
-    // Allocate space for light sources, cameras and animations
-    aiLight **ppLights = dest->mLights = (dest->mNumLights ? new aiLight *[dest->mNumLights] : nullptr);
-
-    aiCamera **ppCameras = dest->mCameras = (dest->mNumCameras ? new aiCamera *[dest->mNumCameras] : nullptr);
-
-    aiAnimation **ppAnims = dest->mAnimations = (dest->mNumAnimations ? new aiAnimation *[dest->mNumAnimations] : nullptr);
-
-    for (int n = static_cast<int>(src.size() - 1); n >= 0; --n) /* !!! important !!! */
-    {
-        SceneHelper *cur = &src[n];
-        aiNode *node;
-
-        // To offset or not to offset, this is the question
-        if (n != (int)duplicates[n]) {
-            // Get full scene-graph copy
-            Copy(&node, (*cur)->mRootNode);
-            OffsetNodeMeshIndices(node, offset[duplicates[n]]);
-
-            if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY) {
-                // (note:) they are already 'offseted' by offset[duplicates[n]]
-                OffsetNodeMeshIndices(node, offset[n] - offset[duplicates[n]]);
-            }
-        } else // if (n == duplicates[n])
-        {
-            node = (*cur)->mRootNode;
-            OffsetNodeMeshIndices(node, offset[n]);
-        }
-        if (n) // src[0] is the master node
-            nodes.push_back(NodeAttachmentInfo(node, srcList[n - 1].attachToNode, n));
-
-        // add name prefixes?
-        if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
-
-            // or the whole scenegraph
-            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                AddNodePrefixesChecked(node, (*cur).id, (*cur).idlen, src, n);
-            } else
-                AddNodePrefixes(node, (*cur).id, (*cur).idlen);
-
-            // meshes
-            for (unsigned int i = 0; i < (*cur)->mNumMeshes; ++i) {
-                aiMesh *mesh = (*cur)->mMeshes[i];
-
-                // rename all bones
-                for (unsigned int a = 0; a < mesh->mNumBones; ++a) {
-                    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                        if (!FindNameMatch(mesh->mBones[a]->mName, src, n))
-                            continue;
-                    }
-                    PrefixString(mesh->mBones[a]->mName, (*cur).id, (*cur).idlen);
-                }
-            }
-        }
-
-        // --------------------------------------------------------------------
-        // Copy light sources
-        for (unsigned int i = 0; i < (*cur)->mNumLights; ++i, ++ppLights) {
-            if (n != (int)duplicates[n]) // duplicate scene?
-            {
-                Copy(ppLights, (*cur)->mLights[i]);
-            } else
-                *ppLights = (*cur)->mLights[i];
-
-            // Add name prefixes?
-            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
-                if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                    if (!FindNameMatch((*ppLights)->mName, src, n))
-                        continue;
-                }
-
-                PrefixString((*ppLights)->mName, (*cur).id, (*cur).idlen);
-            }
-        }
-
-        // --------------------------------------------------------------------
-        // Copy cameras
-        for (unsigned int i = 0; i < (*cur)->mNumCameras; ++i, ++ppCameras) {
-            if (n != (int)duplicates[n]) // duplicate scene?
-            {
-                Copy(ppCameras, (*cur)->mCameras[i]);
-            } else
-                *ppCameras = (*cur)->mCameras[i];
-
-            // Add name prefixes?
-            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
-                if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                    if (!FindNameMatch((*ppCameras)->mName, src, n))
-                        continue;
-                }
-
-                PrefixString((*ppCameras)->mName, (*cur).id, (*cur).idlen);
-            }
-        }
-
-        // --------------------------------------------------------------------
-        // Copy animations
-        for (unsigned int i = 0; i < (*cur)->mNumAnimations; ++i, ++ppAnims) {
-            if (n != (int)duplicates[n]) // duplicate scene?
-            {
-                Copy(ppAnims, (*cur)->mAnimations[i]);
-            } else
-                *ppAnims = (*cur)->mAnimations[i];
-
-            // Add name prefixes?
-            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
-                if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                    if (!FindNameMatch((*ppAnims)->mName, src, n))
-                        continue;
-                }
-
-                PrefixString((*ppAnims)->mName, (*cur).id, (*cur).idlen);
-
-                // don't forget to update all node animation channels
-                for (unsigned int a = 0; a < (*ppAnims)->mNumChannels; ++a) {
-                    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                        if (!FindNameMatch((*ppAnims)->mChannels[a]->mNodeName, src, n))
-                            continue;
-                    }
-
-                    PrefixString((*ppAnims)->mChannels[a]->mNodeName, (*cur).id, (*cur).idlen);
-                }
-            }
-        }
-    }
-
-    // Now build the output graph
-    AttachToGraph(master, nodes);
-    dest->mRootNode = master->mRootNode;
-
-    // Check whether we succeeded at building the output graph
-    for (std::vector<NodeAttachmentInfo>::iterator it = nodes.begin();
-            it != nodes.end(); ++it) {
-        if (!(*it).resolved) {
-            if (flags & AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS) {
-                // search for this attachment point in all other imported scenes, too.
-                for (unsigned int n = 0; n < src.size(); ++n) {
-                    if (n != (*it).src_idx) {
-                        AttachToGraph(src[n].scene, nodes);
-                        if ((*it).resolved)
-                            break;
-                    }
-                }
-            }
-            if (!(*it).resolved) {
-                ASSIMP_LOG_ERROR("SceneCombiner: Failed to resolve attachment ", (*it).node->mName.data,
-                        " ", (*it).attachToNode->mName.data);
-            }
-        }
-    }
-
-    // now delete all input scenes. Make sure duplicate scenes aren't
-    // deleted more than one time
-    for (unsigned int n = 0; n < src.size(); ++n) {
-        if (n != duplicates[n]) // duplicate scene?
-            continue;
-
-        aiScene *deleteMe = src[n].scene;
-
-        // We need to delete the arrays before the destructor is called -
-        // we are reusing the array members
-        delete[] deleteMe->mMeshes;
-        deleteMe->mMeshes = nullptr;
-        delete[] deleteMe->mCameras;
-        deleteMe->mCameras = nullptr;
-        delete[] deleteMe->mLights;
-        deleteMe->mLights = nullptr;
-        delete[] deleteMe->mMaterials;
-        deleteMe->mMaterials = nullptr;
-        delete[] deleteMe->mAnimations;
-        deleteMe->mAnimations = nullptr;
-        delete[] deleteMe->mTextures;
-        deleteMe->mTextures = nullptr;
-
-        deleteMe->mRootNode = nullptr;
-
-        // Now we can safely delete the scene
-        delete deleteMe;
-    }
-
-    // Check flags
-    if (!dest->mNumMeshes || !dest->mNumMaterials) {
-        dest->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-    }
-
-    // We're finished
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a list of unique bones
-void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash> &asBones,
-        std::vector<aiMesh *>::const_iterator it,
-        std::vector<aiMesh *>::const_iterator end) {
-    unsigned int iOffset = 0;
-    for (; it != end; ++it) {
-        for (unsigned int l = 0; l < (*it)->mNumBones; ++l) {
-            aiBone *p = (*it)->mBones[l];
-            uint32_t itml = SuperFastHash(p->mName.data, (unsigned int)p->mName.length);
-
-            std::list<BoneWithHash>::iterator it2 = asBones.begin();
-            std::list<BoneWithHash>::iterator end2 = asBones.end();
-
-            for (; it2 != end2; ++it2) {
-                if ((*it2).first == itml) {
-                    (*it2).pSrcBones.push_back(BoneSrcIndex(p, iOffset));
-                    break;
-                }
-            }
-            if (end2 == it2) {
-                // need to begin a new bone entry
-                asBones.push_back(BoneWithHash());
-                BoneWithHash &btz = asBones.back();
-
-                // setup members
-                btz.first = itml;
-                btz.second = &p->mName;
-                btz.pSrcBones.push_back(BoneSrcIndex(p, iOffset));
-            }
-        }
-        iOffset += (*it)->mNumVertices;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Merge a list of bones
-void SceneCombiner::MergeBones(aiMesh *out, std::vector<aiMesh *>::const_iterator it,
-        std::vector<aiMesh *>::const_iterator end) {
-    if (nullptr == out || out->mNumBones == 0) {
-        return;
-    }
-
-    // find we need to build an unique list of all bones.
-    // we work with hashes to make the comparisons MUCH faster,
-    // at least if we have many bones.
-    std::list<BoneWithHash> asBones;
-    BuildUniqueBoneList(asBones, it, end);
-
-    // now create the output bones
-    out->mNumBones = 0;
-    out->mBones = new aiBone *[asBones.size()];
-
-    for (std::list<BoneWithHash>::const_iterator boneIt = asBones.begin(), boneEnd = asBones.end(); boneIt != boneEnd; ++boneIt) {
-        // Allocate a bone and setup it's name
-        aiBone *pc = out->mBones[out->mNumBones++] = new aiBone();
-        pc->mName = aiString(*(boneIt->second));
-
-        std::vector<BoneSrcIndex>::const_iterator wend = boneIt->pSrcBones.end();
-
-        // Loop through all bones to be joined for this bone
-        for (std::vector<BoneSrcIndex>::const_iterator wmit = boneIt->pSrcBones.begin(); wmit != wend; ++wmit) {
-            pc->mNumWeights += (*wmit).first->mNumWeights;
-
-            // NOTE: different offset matrices for bones with equal names
-            // are - at the moment - not handled correctly.
-            if (wmit != boneIt->pSrcBones.begin() && pc->mOffsetMatrix != wmit->first->mOffsetMatrix) {
-                ASSIMP_LOG_WARN("Bones with equal names but different offset matrices can't be joined at the moment");
-                continue;
-            }
-            pc->mOffsetMatrix = wmit->first->mOffsetMatrix;
-        }
-
-        // Allocate the vertex weight array
-        aiVertexWeight *avw = pc->mWeights = new aiVertexWeight[pc->mNumWeights];
-
-        // And copy the final weights - adjust the vertex IDs by the
-        // face index offset of the corresponding mesh.
-        for (std::vector<BoneSrcIndex>::const_iterator wmit = (*boneIt).pSrcBones.begin(); wmit != (*boneIt).pSrcBones.end(); ++wmit) {
-            if (wmit == wend) {
-                break;
-            }
-
-            aiBone *pip = (*wmit).first;
-            for (unsigned int mp = 0; mp < pip->mNumWeights; ++mp, ++avw) {
-                const aiVertexWeight &vfi = pip->mWeights[mp];
-                avw->mWeight = vfi.mWeight;
-                avw->mVertexId = vfi.mVertexId + (*wmit).second;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Merge a list of meshes
-void SceneCombiner::MergeMeshes(aiMesh **_out, unsigned int /*flags*/,
-        std::vector<aiMesh *>::const_iterator begin,
-        std::vector<aiMesh *>::const_iterator end) {
-    if (nullptr == _out) {
-        return;
-    }
-
-    if (begin == end) {
-        *_out = nullptr; // no meshes ...
-        return;
-    }
-
-    // Allocate the output mesh
-    aiMesh *out = *_out = new aiMesh();
-    out->mMaterialIndex = (*begin)->mMaterialIndex;
-
-    std::string name;
-    // Find out how much output storage we'll need
-    for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-        const char *meshName((*it)->mName.C_Str());
-        name += std::string(meshName);
-        if (it != end - 1) {
-            name += ".";
-        }
-        out->mNumVertices += (*it)->mNumVertices;
-        out->mNumFaces += (*it)->mNumFaces;
-        out->mNumBones += (*it)->mNumBones;
-
-        // combine primitive type flags
-        out->mPrimitiveTypes |= (*it)->mPrimitiveTypes;
-    }
-    out->mName.Set(name.c_str());
-
-    if (out->mNumVertices) {
-        aiVector3D *pv2;
-
-        // copy vertex positions
-        if ((**begin).HasPositions()) {
-
-            pv2 = out->mVertices = new aiVector3D[out->mNumVertices];
-            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-                if ((*it)->mVertices) {
-                    ::memcpy(pv2, (*it)->mVertices, (*it)->mNumVertices * sizeof(aiVector3D));
-                } else
-                    ASSIMP_LOG_WARN("JoinMeshes: Positions expected but input mesh contains no positions");
-                pv2 += (*it)->mNumVertices;
-            }
-        }
-        // copy normals
-        if ((**begin).HasNormals()) {
-
-            pv2 = out->mNormals = new aiVector3D[out->mNumVertices];
-            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-                if ((*it)->mNormals) {
-                    ::memcpy(pv2, (*it)->mNormals, (*it)->mNumVertices * sizeof(aiVector3D));
-                } else {
-                    ASSIMP_LOG_WARN("JoinMeshes: Normals expected but input mesh contains no normals");
-                }
-                pv2 += (*it)->mNumVertices;
-            }
-        }
-        // copy tangents and bi-tangents
-        if ((**begin).HasTangentsAndBitangents()) {
-
-            pv2 = out->mTangents = new aiVector3D[out->mNumVertices];
-            aiVector3D *pv2b = out->mBitangents = new aiVector3D[out->mNumVertices];
-
-            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-                if ((*it)->mTangents) {
-                    ::memcpy(pv2, (*it)->mTangents, (*it)->mNumVertices * sizeof(aiVector3D));
-                    ::memcpy(pv2b, (*it)->mBitangents, (*it)->mNumVertices * sizeof(aiVector3D));
-                } else {
-                    ASSIMP_LOG_WARN("JoinMeshes: Tangents expected but input mesh contains no tangents");
-                }
-                pv2 += (*it)->mNumVertices;
-                pv2b += (*it)->mNumVertices;
-            }
-        }
-        // copy texture coordinates
-        unsigned int n = 0;
-        while ((**begin).HasTextureCoords(n)) {
-            out->mNumUVComponents[n] = (*begin)->mNumUVComponents[n];
-
-            pv2 = out->mTextureCoords[n] = new aiVector3D[out->mNumVertices];
-            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-                if ((*it)->mTextureCoords[n]) {
-                    ::memcpy(pv2, (*it)->mTextureCoords[n], (*it)->mNumVertices * sizeof(aiVector3D));
-                } else {
-                    ASSIMP_LOG_WARN("JoinMeshes: UVs expected but input mesh contains no UVs");
-                }
-                pv2 += (*it)->mNumVertices;
-            }
-            ++n;
-        }
-        // copy vertex colors
-        n = 0;
-        while ((**begin).HasVertexColors(n)) {
-            aiColor4D *pVec2 = out->mColors[n] = new aiColor4D[out->mNumVertices];
-            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-                if ((*it)->mColors[n]) {
-                    ::memcpy(pVec2, (*it)->mColors[n], (*it)->mNumVertices * sizeof(aiColor4D));
-                } else {
-                    ASSIMP_LOG_WARN("JoinMeshes: VCs expected but input mesh contains no VCs");
-                }
-                pVec2 += (*it)->mNumVertices;
-            }
-            ++n;
-        }
-    }
-
-    if (out->mNumFaces) // just for safety
-    {
-        // copy faces
-        out->mFaces = new aiFace[out->mNumFaces];
-        aiFace *pf2 = out->mFaces;
-
-        unsigned int ofs = 0;
-        for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
-            for (unsigned int m = 0; m < (*it)->mNumFaces; ++m, ++pf2) {
-                aiFace &face = (*it)->mFaces[m];
-                pf2->mNumIndices = face.mNumIndices;
-                pf2->mIndices = face.mIndices;
-
-                if (ofs) {
-                    // add the offset to the vertex
-                    for (unsigned int q = 0; q < face.mNumIndices; ++q) {
-                        face.mIndices[q] += ofs;
-                    }
-                }
-                face.mIndices = nullptr;
-            }
-            ofs += (*it)->mNumVertices;
-        }
-    }
-
-    // bones - as this is quite lengthy, I moved the code to a separate function
-    if (out->mNumBones)
-        MergeBones(out, begin, end);
-
-    // delete all source meshes
-    for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it)
-        delete *it;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::MergeMaterials(aiMaterial **dest,
-        std::vector<aiMaterial *>::const_iterator begin,
-        std::vector<aiMaterial *>::const_iterator end) {
-    if (nullptr == dest) {
-        return;
-    }
-
-    if (begin == end) {
-        *dest = nullptr; // no materials ...
-        return;
-    }
-
-    // Allocate the output material
-    aiMaterial *out = *dest = new aiMaterial();
-
-    // Get the maximal number of properties
-    unsigned int size = 0;
-    for (std::vector<aiMaterial *>::const_iterator it = begin; it != end; ++it) {
-        size += (*it)->mNumProperties;
-    }
-
-    out->Clear();
-    delete[] out->mProperties;
-
-    out->mNumAllocated = size;
-    out->mNumProperties = 0;
-    out->mProperties = new aiMaterialProperty *[out->mNumAllocated];
-
-    for (std::vector<aiMaterial *>::const_iterator it = begin; it != end; ++it) {
-        for (unsigned int i = 0; i < (*it)->mNumProperties; ++i) {
-            aiMaterialProperty *sprop = (*it)->mProperties[i];
-
-            // Test if we already have a matching property
-            const aiMaterialProperty *prop_exist;
-            if (aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mSemantic, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
-                // If not, we add it to the new material
-                aiMaterialProperty *prop = out->mProperties[out->mNumProperties] = new aiMaterialProperty();
-
-                prop->mDataLength = sprop->mDataLength;
-                prop->mData = new char[prop->mDataLength];
-                ::memcpy(prop->mData, sprop->mData, prop->mDataLength);
-
-                prop->mIndex = sprop->mIndex;
-                prop->mSemantic = sprop->mSemantic;
-                prop->mKey = sprop->mKey;
-                prop->mType = sprop->mType;
-
-                out->mNumProperties++;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename Type>
-inline void CopyPtrArray(Type **&dest, const Type *const *src, ai_uint num) {
-    if (!num) {
-        dest = nullptr;
-        return;
-    }
-    dest = new Type *[num];
-    for (ai_uint i = 0; i < num; ++i) {
-        SceneCombiner::Copy(&dest[i], src[i]);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename Type>
-inline void GetArrayCopy(Type *&dest, ai_uint num) {
-    if (!dest) {
-        return;
-    }
-    Type *old = dest;
-
-    dest = new Type[num];
-    ::memcpy(dest, old, sizeof(Type) * num);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::CopySceneFlat(aiScene **_dest, const aiScene *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    // reuse the old scene or allocate a new?
-    if (*_dest) {
-        (*_dest)->~aiScene();
-        new (*_dest) aiScene();
-    } else {
-        *_dest = new aiScene();
-    }
-    CopyScene(_dest, src, false);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::CopyScene(aiScene **_dest, const aiScene *src, bool allocate) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    if (allocate) {
-        *_dest = new aiScene();
-    }
-    aiScene *dest = *_dest;
-    ai_assert(nullptr != dest);
-
-    // copy metadata
-    if (nullptr != src->mMetaData) {
-        dest->mMetaData = new aiMetadata(*src->mMetaData);
-    }
-
-    // copy animations
-    dest->mNumAnimations = src->mNumAnimations;
-    CopyPtrArray(dest->mAnimations, src->mAnimations,
-            dest->mNumAnimations);
-
-    // copy textures
-    dest->mNumTextures = src->mNumTextures;
-    CopyPtrArray(dest->mTextures, src->mTextures,
-            dest->mNumTextures);
-
-    // copy materials
-    dest->mNumMaterials = src->mNumMaterials;
-    CopyPtrArray(dest->mMaterials, src->mMaterials,
-            dest->mNumMaterials);
-
-    // copy lights
-    dest->mNumLights = src->mNumLights;
-    CopyPtrArray(dest->mLights, src->mLights,
-            dest->mNumLights);
-
-    // copy cameras
-    dest->mNumCameras = src->mNumCameras;
-    CopyPtrArray(dest->mCameras, src->mCameras,
-            dest->mNumCameras);
-
-    // copy meshes
-    dest->mNumMeshes = src->mNumMeshes;
-    CopyPtrArray(dest->mMeshes, src->mMeshes,
-            dest->mNumMeshes);
-
-    // now - copy the root node of the scene (deep copy, too)
-    Copy(&dest->mRootNode, src->mRootNode);
-
-    // and keep the flags ...
-    dest->mFlags = src->mFlags;
-
-    // source private data might be nullptr if the scene is user-allocated (i.e. for use with the export API)
-    if (dest->mPrivate != nullptr) {
-        ScenePriv(dest)->mPPStepsApplied = ScenePriv(src) ? ScenePriv(src)->mPPStepsApplied : 0;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiMesh **_dest, const aiMesh *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiMesh *dest = *_dest = new aiMesh();
-
-    // get a flat copy
-    *dest = *src;
-
-    // and reallocate all arrays
-    GetArrayCopy(dest->mVertices, dest->mNumVertices);
-    GetArrayCopy(dest->mNormals, dest->mNumVertices);
-    GetArrayCopy(dest->mTangents, dest->mNumVertices);
-    GetArrayCopy(dest->mBitangents, dest->mNumVertices);
-
-    unsigned int n = 0;
-    while (dest->HasTextureCoords(n)) {
-        GetArrayCopy(dest->mTextureCoords[n++], dest->mNumVertices);
-    }
-
-    n = 0;
-    while (dest->HasVertexColors(n)) {
-        GetArrayCopy(dest->mColors[n++], dest->mNumVertices);
-    }
-
-    // make a deep copy of all bones
-    CopyPtrArray(dest->mBones, dest->mBones, dest->mNumBones);
-
-    // make a deep copy of all faces
-    GetArrayCopy(dest->mFaces, dest->mNumFaces);
-    for (unsigned int i = 0; i < dest->mNumFaces; ++i) {
-        aiFace &f = dest->mFaces[i];
-        GetArrayCopy(f.mIndices, f.mNumIndices);
-    }
-
-    // make a deep copy of all blend shapes
-    CopyPtrArray(dest->mAnimMeshes, dest->mAnimMeshes, dest->mNumAnimMeshes);
-
-    // make a deep copy of all texture coordinate names
-    if (src->mTextureCoordsNames != nullptr) {
-        dest->mTextureCoordsNames = new aiString *[AI_MAX_NUMBER_OF_TEXTURECOORDS] {};
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-            Copy(&dest->mTextureCoordsNames[i], src->mTextureCoordsNames[i]);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiAnimMesh **_dest, const aiAnimMesh *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiAnimMesh *dest = *_dest = new aiAnimMesh();
-
-    // get a flat copy
-    *dest = *src;
-
-    // and reallocate all arrays
-    GetArrayCopy(dest->mVertices, dest->mNumVertices);
-    GetArrayCopy(dest->mNormals, dest->mNumVertices);
-    GetArrayCopy(dest->mTangents, dest->mNumVertices);
-    GetArrayCopy(dest->mBitangents, dest->mNumVertices);
-
-    unsigned int n = 0;
-    while (dest->HasTextureCoords(n))
-        GetArrayCopy(dest->mTextureCoords[n++], dest->mNumVertices);
-
-    n = 0;
-    while (dest->HasVertexColors(n))
-        GetArrayCopy(dest->mColors[n++], dest->mNumVertices);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiMaterial **_dest, const aiMaterial *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiMaterial *dest = (aiMaterial *)(*_dest = new aiMaterial());
-
-    dest->Clear();
-    delete[] dest->mProperties;
-
-    dest->mNumAllocated = src->mNumAllocated;
-    dest->mNumProperties = src->mNumProperties;
-    dest->mProperties = new aiMaterialProperty *[dest->mNumAllocated];
-
-    for (unsigned int i = 0; i < dest->mNumProperties; ++i) {
-        aiMaterialProperty *prop = dest->mProperties[i] = new aiMaterialProperty();
-        aiMaterialProperty *sprop = src->mProperties[i];
-
-        prop->mDataLength = sprop->mDataLength;
-        prop->mData = new char[prop->mDataLength];
-        ::memcpy(prop->mData, sprop->mData, prop->mDataLength);
-
-        prop->mIndex = sprop->mIndex;
-        prop->mSemantic = sprop->mSemantic;
-        prop->mKey = sprop->mKey;
-        prop->mType = sprop->mType;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiTexture **_dest, const aiTexture *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiTexture *dest = *_dest = new aiTexture();
-
-    // get a flat copy
-    *dest = *src;
-
-    // and reallocate all arrays. We must do it manually here
-    const char *old = (const char *)dest->pcData;
-    if (old) {
-        unsigned int cpy;
-        if (!dest->mHeight)
-            cpy = dest->mWidth;
-        else
-            cpy = dest->mHeight * dest->mWidth * sizeof(aiTexel);
-
-        if (!cpy) {
-            dest->pcData = nullptr;
-            return;
-        }
-        // the cast is legal, the aiTexel c'tor does nothing important
-        dest->pcData = (aiTexel *)new char[cpy];
-        ::memcpy(dest->pcData, old, cpy);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiAnimation **_dest, const aiAnimation *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiAnimation *dest = *_dest = new aiAnimation();
-
-    // get a flat copy
-    *dest = *src;
-
-    // and reallocate all arrays
-    CopyPtrArray(dest->mChannels, src->mChannels, dest->mNumChannels);
-    CopyPtrArray(dest->mMorphMeshChannels, src->mMorphMeshChannels, dest->mNumMorphMeshChannels);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiNodeAnim **_dest, const aiNodeAnim *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiNodeAnim *dest = *_dest = new aiNodeAnim();
-
-    // get a flat copy
-    *dest = *src;
-
-    // and reallocate all arrays
-    GetArrayCopy(dest->mPositionKeys, dest->mNumPositionKeys);
-    GetArrayCopy(dest->mScalingKeys, dest->mNumScalingKeys);
-    GetArrayCopy(dest->mRotationKeys, dest->mNumRotationKeys);
-}
-
-void SceneCombiner::Copy(aiMeshMorphAnim **_dest, const aiMeshMorphAnim *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiMeshMorphAnim *dest = *_dest = new aiMeshMorphAnim();
-
-    // get a flat copy
-    *dest = *src;
-
-    // and reallocate all arrays
-    GetArrayCopy(dest->mKeys, dest->mNumKeys);
-    for (ai_uint i = 0; i < dest->mNumKeys; ++i) {
-        dest->mKeys[i].mValues = new unsigned int[dest->mKeys[i].mNumValuesAndWeights];
-        dest->mKeys[i].mWeights = new double[dest->mKeys[i].mNumValuesAndWeights];
-        ::memcpy(dest->mKeys[i].mValues, src->mKeys[i].mValues, dest->mKeys[i].mNumValuesAndWeights * sizeof(unsigned int));
-        ::memcpy(dest->mKeys[i].mWeights, src->mKeys[i].mWeights, dest->mKeys[i].mNumValuesAndWeights * sizeof(double));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiCamera **_dest, const aiCamera *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiCamera *dest = *_dest = new aiCamera();
-
-    // get a flat copy, that's already OK
-    *dest = *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiLight **_dest, const aiLight *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiLight *dest = *_dest = new aiLight();
-
-    // get a flat copy, that's already OK
-    *dest = *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiBone **_dest, const aiBone *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiBone *dest = *_dest = new aiBone();
-
-    // get a flat copy
-    *dest = *src;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiNode **_dest, const aiNode *src) {
-    ai_assert(nullptr != _dest);
-    ai_assert(nullptr != src);
-
-    aiNode *dest = *_dest = new aiNode();
-
-    // get a flat copy
-    *dest = *src;
-
-    if (src->mMetaData) {
-        Copy(&dest->mMetaData, src->mMetaData);
-    }
-
-    // and reallocate all arrays
-    GetArrayCopy(dest->mMeshes, dest->mNumMeshes);
-    CopyPtrArray(dest->mChildren, src->mChildren, dest->mNumChildren);
-
-    // need to set the mParent fields to the created aiNode.
-    for (unsigned int i = 0; i < dest->mNumChildren; i++) {
-        dest->mChildren[i]->mParent = dest;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiMetadata **_dest, const aiMetadata *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    if (0 == src->mNumProperties) {
-        return;
-    }
-
-    aiMetadata *dest = *_dest = aiMetadata::Alloc(src->mNumProperties);
-    std::copy(src->mKeys, src->mKeys + src->mNumProperties, dest->mKeys);
-
-    for (unsigned int i = 0; i < src->mNumProperties; ++i) {
-        aiMetadataEntry &in = src->mValues[i];
-        aiMetadataEntry &out = dest->mValues[i];
-        out.mType = in.mType;
-        switch (dest->mValues[i].mType) {
-        case AI_BOOL:
-            out.mData = new bool(*static_cast<bool *>(in.mData));
-            break;
-        case AI_INT32:
-            out.mData = new int32_t(*static_cast<int32_t *>(in.mData));
-            break;
-        case AI_UINT64:
-            out.mData = new uint64_t(*static_cast<uint64_t *>(in.mData));
-            break;
-        case AI_FLOAT:
-            out.mData = new float(*static_cast<float *>(in.mData));
-            break;
-        case AI_DOUBLE:
-            out.mData = new double(*static_cast<double *>(in.mData));
-            break;
-        case AI_AISTRING:
-            out.mData = new aiString(*static_cast<aiString *>(in.mData));
-            break;
-        case AI_AIVECTOR3D:
-            out.mData = new aiVector3D(*static_cast<aiVector3D *>(in.mData));
-            break;
-        default:
-            ai_assert(false);
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiString **_dest, const aiString *src) {
-    if (nullptr == _dest || nullptr == src) {
-        return;
-    }
-
-    aiString *dest = *_dest = new aiString();
-
-    // get a flat copy
-    *dest = *src;
-}
-
-#if (__GNUC__ >= 8 && __GNUC_MINOR__ >= 0)
-#pragma GCC diagnostic pop
-#endif
-
-} // Namespace Assimp
diff --git a/libs/assimp/code/Common/ScenePreprocessor.cpp b/libs/assimp/code/Common/ScenePreprocessor.cpp
deleted file mode 100644
index 2ef291e..0000000
--- a/libs/assimp/code/Common/ScenePreprocessor.cpp
+++ /dev/null
@@ -1,285 +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 "ScenePreprocessor.h"
-#include <assimp/ai_assert.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-
-using namespace Assimp;
-
-// ---------------------------------------------------------------------------------------------
-void ScenePreprocessor::ProcessScene() {
-    ai_assert(scene != nullptr);
-
-    // Process all meshes
-    for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
-        if (nullptr == scene->mMeshes[i]) {
-            continue;
-        }
-        ProcessMesh(scene->mMeshes[i]);
-    }
-
-    // - nothing to do for nodes for the moment
-    // - nothing to do for textures for the moment
-    // - nothing to do for lights for the moment
-    // - nothing to do for cameras for the moment
-
-    // Process all animations
-    for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
-        if (nullptr == scene->mAnimations[i]) {
-            continue;
-        }
-        ProcessAnimation(scene->mAnimations[i]);
-    }
-
-    // Generate a default material if none was specified
-    if (!scene->mNumMaterials && scene->mNumMeshes) {
-        scene->mMaterials = new aiMaterial *[2];
-        aiMaterial *helper;
-
-        aiString name;
-
-        scene->mMaterials[scene->mNumMaterials] = helper = new aiMaterial();
-        aiColor3D clr(0.6f, 0.6f, 0.6f);
-        helper->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
-
-        // setup the default name to make this material identifiable
-        name.Set(AI_DEFAULT_MATERIAL_NAME);
-        helper->AddProperty(&name, AI_MATKEY_NAME);
-
-        ASSIMP_LOG_DEBUG("ScenePreprocessor: Adding default material \'" AI_DEFAULT_MATERIAL_NAME "\'");
-
-        for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
-            if (nullptr == scene->mMeshes[i]) {
-                continue;
-            }
-            scene->mMeshes[i]->mMaterialIndex = scene->mNumMaterials;
-        }
-
-        scene->mNumMaterials++;
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-void ScenePreprocessor::ProcessMesh(aiMesh *mesh) {
-    // If aiMesh::mNumUVComponents is *not* set assign the default value of 2
-    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-        if (!mesh->mTextureCoords[i]) {
-            mesh->mNumUVComponents[i] = 0;
-        } else {
-            if (!mesh->mNumUVComponents[i]) {
-                mesh->mNumUVComponents[i] = 2;
-            }
-
-            aiVector3D *p = mesh->mTextureCoords[i], *end = p + mesh->mNumVertices;
-
-            // Ensure unused components are zeroed. This will make 1D texture channels work
-            // as if they were 2D channels .. just in case an application doesn't handle
-            // this case
-            if (2 == mesh->mNumUVComponents[i]) {
-                for (; p != end; ++p) {
-                    p->z = 0.f;
-                }
-            } else if (1 == mesh->mNumUVComponents[i]) {
-                for (; p != end; ++p) {
-                    p->z = p->y = 0.f;
-                }
-            } else if (3 == mesh->mNumUVComponents[i]) {
-                // Really 3D coordinates? Check whether the third coordinate is != 0 for at least one element
-                for (; p != end; ++p) {
-                    if (p->z != 0) {
-                        break;
-                    }
-                }
-                if (p == end) {
-                    ASSIMP_LOG_WARN("ScenePreprocessor: UVs are declared to be 3D but they're obviously not. Reverting to 2D.");
-                    mesh->mNumUVComponents[i] = 2;
-                }
-            }
-        }
-    }
-
-    // If the information which primitive types are there in the
-    // mesh is currently not available, compute it.
-    if (!mesh->mPrimitiveTypes) {
-        for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
-            aiFace &face = mesh->mFaces[a];
-            switch (face.mNumIndices) {
-            case 3u:
-                mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                break;
-
-            case 2u:
-                mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                break;
-
-            case 1u:
-                mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                break;
-
-            default:
-                mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-                break;
-            }
-        }
-    }
-
-    // If tangents and normals are given but no bitangents compute them
-    if (mesh->mTangents && mesh->mNormals && !mesh->mBitangents) {
-        mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
-        for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-            mesh->mBitangents[i] = mesh->mNormals[i] ^ mesh->mTangents[i];
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-void ScenePreprocessor::ProcessAnimation(aiAnimation *anim) {
-    double first = 10e10, last = -10e10;
-    for (unsigned int i = 0; i < anim->mNumChannels; ++i) {
-        aiNodeAnim *channel = anim->mChannels[i];
-
-        //  If the exact duration of the animation is not given
-        //  compute it now.
-        if (anim->mDuration == -1.) {
-            // Position keys
-            for (unsigned int j = 0; j < channel->mNumPositionKeys; ++j) {
-                aiVectorKey &key = channel->mPositionKeys[j];
-                first = std::min(first, key.mTime);
-                last = std::max(last, key.mTime);
-            }
-
-            // Scaling keys
-            for (unsigned int j = 0; j < channel->mNumScalingKeys; ++j) {
-                aiVectorKey &key = channel->mScalingKeys[j];
-                first = std::min(first, key.mTime);
-                last = std::max(last, key.mTime);
-            }
-
-            // Rotation keys
-            for (unsigned int j = 0; j < channel->mNumRotationKeys; ++j) {
-                aiQuatKey &key = channel->mRotationKeys[j];
-                first = std::min(first, key.mTime);
-                last = std::max(last, key.mTime);
-            }
-        }
-
-        // Check whether the animation channel has no rotation
-        // or position tracks. In this case we generate a dummy
-        // track from the information we have in the transformation
-        // matrix of the corresponding node.
-        if (!channel->mNumRotationKeys || !channel->mNumPositionKeys || !channel->mNumScalingKeys) {
-            // Find the node that belongs to this animation
-            aiNode *node = scene->mRootNode->FindNode(channel->mNodeName);
-            if (node) // ValidateDS will complain later if 'node' is nullptr
-            {
-                // Decompose the transformation matrix of the node
-                aiVector3D scaling, position;
-                aiQuaternion rotation;
-
-                node->mTransformation.Decompose(scaling, rotation, position);
-
-                // No rotation keys? Generate a dummy track
-                if (!channel->mNumRotationKeys) {
-                    if (channel->mRotationKeys) {
-                        delete[] channel->mRotationKeys;
-                        channel->mRotationKeys = nullptr;
-                    }
-                    ai_assert(!channel->mRotationKeys);
-                    channel->mNumRotationKeys = 1;
-                    channel->mRotationKeys = new aiQuatKey[1];
-                    aiQuatKey &q = channel->mRotationKeys[0];
-
-                    q.mTime = 0.;
-                    q.mValue = rotation;
-
-                    ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Dummy rotation track has been generated");
-                } else {
-                    ai_assert(channel->mRotationKeys);
-                }
-
-                // No scaling keys? Generate a dummy track
-                if (!channel->mNumScalingKeys) {
-                    if (channel->mScalingKeys) {
-                        delete[] channel->mScalingKeys;
-                        channel->mScalingKeys = nullptr;
-                    }
-                    ai_assert(!channel->mScalingKeys);
-                    channel->mNumScalingKeys = 1;
-                    channel->mScalingKeys = new aiVectorKey[1];
-                    aiVectorKey &q = channel->mScalingKeys[0];
-
-                    q.mTime = 0.;
-                    q.mValue = scaling;
-
-                    ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Dummy scaling track has been generated");
-                } else {
-                    ai_assert(channel->mScalingKeys);
-                }
-
-                // No position keys? Generate a dummy track
-                if (!channel->mNumPositionKeys) {
-                    if (channel->mPositionKeys) {
-                        delete[] channel->mPositionKeys;
-                        channel->mPositionKeys = nullptr;
-                    }
-                    ai_assert(!channel->mPositionKeys);
-                    channel->mNumPositionKeys = 1;
-                    channel->mPositionKeys = new aiVectorKey[1];
-                    aiVectorKey &q = channel->mPositionKeys[0];
-
-                    q.mTime = 0.;
-                    q.mValue = position;
-
-                    ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Dummy position track has been generated");
-                } else {
-                    ai_assert(channel->mPositionKeys);
-                }
-            }
-        }
-    }
-
-    if (anim->mDuration == -1.) {
-        ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Setting animation duration");
-        anim->mDuration = last - std::min(first, 0.);
-    }
-}
diff --git a/libs/assimp/code/Common/ScenePreprocessor.h b/libs/assimp/code/Common/ScenePreprocessor.h
deleted file mode 100644
index 49e06ed..0000000
--- a/libs/assimp/code/Common/ScenePreprocessor.h
+++ /dev/null
@@ -1,118 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to search all meshes for
-  degenerated faces */
-#ifndef AI_SCENE_PREPROCESSOR_H_INC
-#define AI_SCENE_PREPROCESSOR_H_INC
-
-#include <assimp/defs.h>
-#include <stddef.h>
-
-struct aiScene;
-struct aiAnimation;
-struct aiMesh;
-
-class ScenePreprocessorTest;
-namespace Assimp {
-
-// ----------------------------------------------------------------------------------
-/** ScenePreprocessor: Preprocess a scene before any post-processing
- *  steps are executed.
- *
- *  The step computes data that needn't necessarily be provided by the
- *  importer, such as aiMesh::mPrimitiveTypes.
-*/
-// ----------------------------------------------------------------------------------
-class ASSIMP_API ScenePreprocessor {
-    // Make ourselves a friend of the corresponding test unit.
-    friend class ::ScenePreprocessorTest;
-
-public:
-    // ----------------------------------------------------------------
-    /** Default c'tpr. Use SetScene() to assign a scene to the object.
-     */
-    ScenePreprocessor() :
-            scene(nullptr) {}
-
-    /** Constructs the object and assigns a specific scene to it
-     */
-    ScenePreprocessor(aiScene *_scene) :
-            scene(_scene) {}
-
-    // ----------------------------------------------------------------
-    /** Assign a (new) scene to the object.
-     *
-     *  One 'SceneProcessor' can be used for multiple scenes.
-     *  Call ProcessScene to have the scene preprocessed.
-     *  @param sc Scene to be processed.
-     */
-    void SetScene(aiScene *sc) {
-        scene = sc;
-    }
-
-    // ----------------------------------------------------------------
-    /** Preprocess the current scene
-     */
-    void ProcessScene();
-
-protected:
-    // ----------------------------------------------------------------
-    /** Preprocess an animation in the scene
-     *  @param anim Anim to be preprocessed.
-     */
-    void ProcessAnimation(aiAnimation *anim);
-
-    // ----------------------------------------------------------------
-    /** Preprocess a mesh in the scene
-     *  @param mesh Mesh to be preprocessed.
-     */
-    void ProcessMesh(aiMesh *mesh);
-
-protected:
-    //! Scene we're currently working on
-    aiScene *scene;
-};
-
-} // namespace Assimp
-
-#endif // include guard
diff --git a/libs/assimp/code/Common/ScenePrivate.h b/libs/assimp/code/Common/ScenePrivate.h
deleted file mode 100644
index 3910db7..0000000
--- a/libs/assimp/code/Common/ScenePrivate.h
+++ /dev/null
@@ -1,105 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Stuff to deal with aiScene::mPrivate
- */
-#pragma once
-#ifndef AI_SCENEPRIVATE_H_INCLUDED
-#define AI_SCENEPRIVATE_H_INCLUDED
-
-#include <assimp/ai_assert.h>
-#include <assimp/scene.h>
-
-namespace Assimp {
-
-// Forward declarations
-class Importer;
-
-struct ScenePrivateData {
-    //  The struct constructor.
-    ScenePrivateData() AI_NO_EXCEPT;
-
-    // Importer that originally loaded the scene though the C-API
-    // If set, this object is owned by this private data instance.
-    Assimp::Importer* mOrigImporter;
-
-    // List of post-processing steps already applied to the scene.
-    unsigned int mPPStepsApplied;
-
-    // true if the scene is a copy made with aiCopyScene()
-    // or the corresponding C++ API. This means that user code
-    // may have made modifications to it, so mPPStepsApplied
-    // and mOrigImporter are no longer safe to rely on and only
-    // serve informative purposes.
-    bool mIsCopy;
-};
-
-inline
-ScenePrivateData::ScenePrivateData() AI_NO_EXCEPT
-: mOrigImporter( nullptr )
-, mPPStepsApplied( 0 )
-, mIsCopy( false ) {
-    // empty
-}
-
-// Access private data stored in the scene
-inline
-ScenePrivateData* ScenePriv(aiScene* in) {
-    ai_assert( nullptr != in );
-    if ( nullptr == in ) {
-        return nullptr;
-    }
-    return static_cast<ScenePrivateData*>(in->mPrivate);
-}
-
-inline
-const ScenePrivateData* ScenePriv(const aiScene* in) {
-    ai_assert( nullptr != in );
-    if ( nullptr == in ) {
-        return nullptr;
-    }
-    return static_cast<const ScenePrivateData*>(in->mPrivate);
-}
-
-} // Namespace Assimp
-
-#endif // AI_SCENEPRIVATE_H_INCLUDED
diff --git a/libs/assimp/code/Common/SkeletonMeshBuilder.cpp b/libs/assimp/code/Common/SkeletonMeshBuilder.cpp
deleted file mode 100644
index 5ea30d9..0000000
--- a/libs/assimp/code/Common/SkeletonMeshBuilder.cpp
+++ /dev/null
@@ -1,262 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  SkeletonMeshBuilder.cpp
- *  @brief Implementation of a little class to construct a dummy mesh for a skeleton
- */
-
-#include <assimp/SkeletonMeshBuilder.h>
-#include <assimp/scene.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// The constructor processes the given scene and adds a mesh there.
-SkeletonMeshBuilder::SkeletonMeshBuilder(aiScene *pScene, aiNode *root, bool bKnobsOnly) {
-    // nothing to do if there's mesh data already present at the scene
-    if (pScene->mNumMeshes > 0 || pScene->mRootNode == nullptr) {
-        return;
-    }
-
-    if (!root) {
-        root = pScene->mRootNode;
-    }
-
-    mKnobsOnly = bKnobsOnly;
-
-    // build some faces around each node
-    CreateGeometry(root);
-
-    // create a mesh to hold all the generated faces
-    pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh *[1];
-    pScene->mMeshes[0] = CreateMesh();
-    // and install it at the root node
-    root->mNumMeshes = 1;
-    root->mMeshes = new unsigned int[1];
-    root->mMeshes[0] = 0;
-
-    // create a dummy material for the mesh
-    if (pScene->mNumMaterials == 0) {
-        pScene->mNumMaterials = 1;
-        pScene->mMaterials = new aiMaterial *[1];
-        pScene->mMaterials[0] = CreateMaterial();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Recursively builds a simple mesh representation for the given node
-void SkeletonMeshBuilder::CreateGeometry(const aiNode *pNode) {
-    // add a joint entry for the node.
-    const unsigned int vertexStartIndex = static_cast<unsigned int>(mVertices.size());
-
-    // now build the geometry.
-    if (pNode->mNumChildren > 0 && !mKnobsOnly) {
-        // If the node has children, we build little pointers to each of them
-        for (unsigned int a = 0; a < pNode->mNumChildren; a++) {
-            // find a suitable coordinate system
-            const aiMatrix4x4 &childTransform = pNode->mChildren[a]->mTransformation;
-            aiVector3D childpos(childTransform.a4, childTransform.b4, childTransform.c4);
-            ai_real distanceToChild = childpos.Length();
-            if (distanceToChild < 0.0001)
-                continue;
-            aiVector3D up = aiVector3D(childpos).Normalize();
-
-            aiVector3D orth(1.0, 0.0, 0.0);
-            if (std::fabs(orth * up) > 0.99)
-                orth.Set(0.0, 1.0, 0.0);
-
-            aiVector3D front = (up ^ orth).Normalize();
-            aiVector3D side = (front ^ up).Normalize();
-
-            unsigned int localVertexStart = static_cast<unsigned int>(mVertices.size());
-            mVertices.push_back(-front * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(childpos);
-            mVertices.push_back(-side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(-side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(childpos);
-            mVertices.push_back(front * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(front * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(childpos);
-            mVertices.push_back(side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back(childpos);
-            mVertices.push_back(-front * distanceToChild * (ai_real)0.1);
-
-            mFaces.push_back(Face(localVertexStart + 0, localVertexStart + 1, localVertexStart + 2));
-            mFaces.push_back(Face(localVertexStart + 3, localVertexStart + 4, localVertexStart + 5));
-            mFaces.push_back(Face(localVertexStart + 6, localVertexStart + 7, localVertexStart + 8));
-            mFaces.push_back(Face(localVertexStart + 9, localVertexStart + 10, localVertexStart + 11));
-        }
-    } else {
-        // if the node has no children, it's an end node. Put a little knob there instead
-        aiVector3D ownpos(pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4);
-        ai_real sizeEstimate = ownpos.Length() * ai_real(0.18);
-
-        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
-        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
-        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
-        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
-
-        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
-        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
-        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
-        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
-        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
-        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
-
-        mFaces.push_back(Face(vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2));
-        mFaces.push_back(Face(vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5));
-        mFaces.push_back(Face(vertexStartIndex + 6, vertexStartIndex + 7, vertexStartIndex + 8));
-        mFaces.push_back(Face(vertexStartIndex + 9, vertexStartIndex + 10, vertexStartIndex + 11));
-        mFaces.push_back(Face(vertexStartIndex + 12, vertexStartIndex + 13, vertexStartIndex + 14));
-        mFaces.push_back(Face(vertexStartIndex + 15, vertexStartIndex + 16, vertexStartIndex + 17));
-        mFaces.push_back(Face(vertexStartIndex + 18, vertexStartIndex + 19, vertexStartIndex + 20));
-        mFaces.push_back(Face(vertexStartIndex + 21, vertexStartIndex + 22, vertexStartIndex + 23));
-    }
-
-    unsigned int numVertices = static_cast<unsigned int>(mVertices.size() - vertexStartIndex);
-    if (numVertices > 0) {
-        // create a bone affecting all the newly created vertices
-        aiBone *bone = new aiBone;
-        mBones.push_back(bone);
-        bone->mName = pNode->mName;
-
-        // calculate the bone offset matrix by concatenating the inverse transformations of all parents
-        bone->mOffsetMatrix = aiMatrix4x4(pNode->mTransformation).Inverse();
-        for (aiNode *parent = pNode->mParent; parent != nullptr; parent = parent->mParent)
-            bone->mOffsetMatrix = aiMatrix4x4(parent->mTransformation).Inverse() * bone->mOffsetMatrix;
-
-        // add all the vertices to the bone's influences
-        bone->mNumWeights = numVertices;
-        bone->mWeights = new aiVertexWeight[numVertices];
-        for (unsigned int a = 0; a < numVertices; a++)
-            bone->mWeights[a] = aiVertexWeight(vertexStartIndex + a, 1.0);
-
-        // HACK: (thom) transform all vertices to the bone's local space. Should be done before adding
-        // them to the array, but I'm tired now and I'm annoyed.
-        aiMatrix4x4 boneToMeshTransform = aiMatrix4x4(bone->mOffsetMatrix).Inverse();
-        for (unsigned int a = vertexStartIndex; a < mVertices.size(); a++)
-            mVertices[a] = boneToMeshTransform * mVertices[a];
-    }
-
-    // and finally recurse into the children list
-    for (unsigned int a = 0; a < pNode->mNumChildren; a++)
-        CreateGeometry(pNode->mChildren[a]);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Creates the mesh from the internally accumulated stuff and returns it.
-aiMesh *SkeletonMeshBuilder::CreateMesh() {
-    aiMesh *mesh = new aiMesh();
-
-    // add points
-    mesh->mNumVertices = static_cast<unsigned int>(mVertices.size());
-    mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-    std::copy(mVertices.begin(), mVertices.end(), mesh->mVertices);
-
-    mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-
-    // add faces
-    mesh->mNumFaces = static_cast<unsigned int>(mFaces.size());
-    mesh->mFaces = new aiFace[mesh->mNumFaces];
-    for (unsigned int a = 0; a < mesh->mNumFaces; a++) {
-        const Face &inface = mFaces[a];
-        aiFace &outface = mesh->mFaces[a];
-        outface.mNumIndices = 3;
-        outface.mIndices = new unsigned int[3];
-        outface.mIndices[0] = inface.mIndices[0];
-        outface.mIndices[1] = inface.mIndices[1];
-        outface.mIndices[2] = inface.mIndices[2];
-
-        // Compute per-face normals ... we don't want the bones to be smoothed ... they're built to visualize
-        // the skeleton, so it's good if there's a visual difference to the rest of the geometry
-        aiVector3D nor = ((mVertices[inface.mIndices[2]] - mVertices[inface.mIndices[0]]) ^
-                          (mVertices[inface.mIndices[1]] - mVertices[inface.mIndices[0]]));
-
-        if (nor.Length() < 1e-5) /* ensure that FindInvalidData won't remove us ...*/
-            nor = aiVector3D(1.0, 0.0, 0.0);
-
-        for (unsigned int n = 0; n < 3; ++n)
-            mesh->mNormals[inface.mIndices[n]] = nor;
-    }
-
-    // add the bones
-    mesh->mNumBones = static_cast<unsigned int>(mBones.size());
-    mesh->mBones = new aiBone *[mesh->mNumBones];
-    std::copy(mBones.begin(), mBones.end(), mesh->mBones);
-
-    // default
-    mesh->mMaterialIndex = 0;
-
-    return mesh;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Creates a dummy material and returns it.
-aiMaterial *SkeletonMeshBuilder::CreateMaterial() {
-    aiMaterial *matHelper = new aiMaterial;
-
-    // Name
-    aiString matName(std::string("SkeletonMaterial"));
-    matHelper->AddProperty(&matName, AI_MATKEY_NAME);
-
-    // Prevent backface culling
-    const int no_cull = 1;
-    matHelper->AddProperty(&no_cull, 1, AI_MATKEY_TWOSIDED);
-
-    return matHelper;
-}
diff --git a/libs/assimp/code/Common/SpatialSort.cpp b/libs/assimp/code/Common/SpatialSort.cpp
deleted file mode 100644
index 6103002..0000000
--- a/libs/assimp/code/Common/SpatialSort.cpp
+++ /dev/null
@@ -1,344 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the helper class to quickly find vertices close to a given position */
-
-#include <assimp/SpatialSort.h>
-#include <assimp/ai_assert.h>
-
-using namespace Assimp;
-
-// CHAR_BIT seems to be defined under MVSC, but not under GCC. Pray that the correct value is 8.
-#ifndef CHAR_BIT
-#define CHAR_BIT 8
-#endif
-
-const aiVector3D PlaneInit(0.8523f, 0.34321f, 0.5736f);
-
-// ------------------------------------------------------------------------------------------------
-// Constructs a spatially sorted representation from the given position array.
-// define the reference plane. We choose some arbitrary vector away from all basic axes
-// in the hope that no model spreads all its vertices along this plane.
-SpatialSort::SpatialSort(const aiVector3D *pPositions, unsigned int pNumPositions, unsigned int pElementOffset) :
-        mPlaneNormal(PlaneInit),
-        mFinalized(false) {
-    mPlaneNormal.Normalize();
-    Fill(pPositions, pNumPositions, pElementOffset);
-}
-
-// ------------------------------------------------------------------------------------------------
-SpatialSort::SpatialSort() :
-        mPlaneNormal(PlaneInit),
-        mFinalized(false) {
-    mPlaneNormal.Normalize();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor
-SpatialSort::~SpatialSort() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-void SpatialSort::Fill(const aiVector3D *pPositions, unsigned int pNumPositions,
-        unsigned int pElementOffset,
-        bool pFinalize /*= true */) {
-    mPositions.clear();
-    mFinalized = false;
-    Append(pPositions, pNumPositions, pElementOffset, pFinalize);
-    mFinalized = pFinalize;
-}
-
-// ------------------------------------------------------------------------------------------------
-ai_real SpatialSort::CalculateDistance(const aiVector3D &pPosition) const {
-    return (pPosition - mCentroid) * mPlaneNormal;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SpatialSort::Finalize() {
-    const ai_real scale = 1.0f / mPositions.size();
-    for (unsigned int i = 0; i < mPositions.size(); i++) {
-        mCentroid += scale * mPositions[i].mPosition; 
-    }
-    for (unsigned int i = 0; i < mPositions.size(); i++) {
-        mPositions[i].mDistance = CalculateDistance(mPositions[i].mPosition);
-    }
-    std::sort(mPositions.begin(), mPositions.end());
-    mFinalized = true;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SpatialSort::Append(const aiVector3D *pPositions, unsigned int pNumPositions,
-        unsigned int pElementOffset,
-        bool pFinalize /*= true */) {
-    ai_assert(!mFinalized && "You cannot add positions to the SpatialSort object after it has been finalized.");
-    // store references to all given positions along with their distance to the reference plane
-    const size_t initial = mPositions.size();
-    mPositions.reserve(initial + pNumPositions);
-    for (unsigned int a = 0; a < pNumPositions; a++) {
-        const char *tempPointer = reinterpret_cast<const char *>(pPositions);
-        const aiVector3D *vec = reinterpret_cast<const aiVector3D *>(tempPointer + a * pElementOffset);
-        mPositions.push_back(Entry(static_cast<unsigned int>(a + initial), *vec));
-    }
-
-    if (pFinalize) {
-        // now sort the array ascending by distance.
-        Finalize();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns an iterator for all positions close to the given position.
-void SpatialSort::FindPositions(const aiVector3D &pPosition,
-        ai_real pRadius, std::vector<unsigned int> &poResults) const {
-    ai_assert(mFinalized && "The SpatialSort object must be finalized before FindPositions can be called.");
-    const ai_real dist = CalculateDistance(pPosition);
-    const ai_real minDist = dist - pRadius, maxDist = dist + pRadius;
-
-    // clear the array
-    poResults.clear();
-
-    // quick check for positions outside the range
-    if (mPositions.size() == 0)
-        return;
-    if (maxDist < mPositions.front().mDistance)
-        return;
-    if (minDist > mPositions.back().mDistance)
-        return;
-
-    // do a binary search for the minimal distance to start the iteration there
-    unsigned int index = (unsigned int)mPositions.size() / 2;
-    unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4;
-    while (binaryStepSize > 1) {
-        if (mPositions[index].mDistance < minDist)
-            index += binaryStepSize;
-        else
-            index -= binaryStepSize;
-
-        binaryStepSize /= 2;
-    }
-
-    // depending on the direction of the last step we need to single step a bit back or forth
-    // to find the actual beginning element of the range
-    while (index > 0 && mPositions[index].mDistance > minDist)
-        index--;
-    while (index < (mPositions.size() - 1) && mPositions[index].mDistance < minDist)
-        index++;
-
-    // Mow start iterating from there until the first position lays outside of the distance range.
-    // Add all positions inside the distance range within the given radius to the result array
-    std::vector<Entry>::const_iterator it = mPositions.begin() + index;
-    const ai_real pSquared = pRadius * pRadius;
-    while (it->mDistance < maxDist) {
-        if ((it->mPosition - pPosition).SquareLength() < pSquared)
-            poResults.push_back(it->mIndex);
-        ++it;
-        if (it == mPositions.end())
-            break;
-    }
-
-    // that's it
-}
-
-namespace {
-
-// Binary, signed-integer representation of a single-precision floating-point value.
-// IEEE 754 says: "If two floating-point numbers in the same format are ordered then they are
-//  ordered the same way when their bits are reinterpreted as sign-magnitude integers."
-// This allows us to convert all floating-point numbers to signed integers of arbitrary size
-//  and then use them to work with ULPs (Units in the Last Place, for high-precision
-//  computations) or to compare them (integer comparisons are faster than floating-point
-//  comparisons on many platforms).
-typedef ai_int BinFloat;
-
-// --------------------------------------------------------------------------------------------
-// Converts the bit pattern of a floating-point number to its signed integer representation.
-BinFloat ToBinary(const ai_real &pValue) {
-
-    // If this assertion fails, signed int is not big enough to store a float on your platform.
-    //  Please correct the declaration of BinFloat a few lines above - but do it in a portable,
-    //  #ifdef'd manner!
-    static_assert(sizeof(BinFloat) >= sizeof(ai_real), "sizeof(BinFloat) >= sizeof(ai_real)");
-
-#if defined(_MSC_VER)
-    // If this assertion fails, Visual C++ has finally moved to ILP64. This means that this
-    //  code has just become legacy code! Find out the current value of _MSC_VER and modify
-    //  the #if above so it evaluates false on the current and all upcoming VC versions (or
-    //  on the current platform, if LP64 or LLP64 are still used on other platforms).
-    static_assert(sizeof(BinFloat) == sizeof(ai_real), "sizeof(BinFloat) == sizeof(ai_real)");
-
-    // This works best on Visual C++, but other compilers have their problems with it.
-    const BinFloat binValue = reinterpret_cast<BinFloat const &>(pValue);
-    //::memcpy(&binValue, &pValue, sizeof(pValue));
-    //return binValue;
-#else
-    // On many compilers, reinterpreting a float address as an integer causes aliasing
-    // problems. This is an ugly but more or less safe way of doing it.
-    union {
-        ai_real asFloat;
-        BinFloat asBin;
-    } conversion;
-    conversion.asBin = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float)
-    conversion.asFloat = pValue;
-    const BinFloat binValue = conversion.asBin;
-#endif
-
-    // floating-point numbers are of sign-magnitude format, so find out what signed number
-    //  representation we must convert negative values to.
-    // See http://en.wikipedia.org/wiki/Signed_number_representations.
-    const BinFloat mask = BinFloat(1) << (CHAR_BIT * sizeof(BinFloat) - 1);
-
-    // Two's complement?
-    const bool DefaultValue = ((-42 == (~42 + 1)) && (binValue & mask));
-    const bool OneComplement = ((-42 == ~42) && (binValue & mask));
-
-    if (DefaultValue)
-        return mask - binValue;
-    // One's complement?
-    else if (OneComplement)
-        return BinFloat(-0) - binValue;
-    // Sign-magnitude? -0 = 1000... binary
-    return binValue;
-}
-
-} // namespace
-
-// ------------------------------------------------------------------------------------------------
-// Fills an array with indices of all positions identical to the given position. In opposite to
-// FindPositions(), not an epsilon is used but a (very low) tolerance of four floating-point units.
-void SpatialSort::FindIdenticalPositions(const aiVector3D &pPosition, std::vector<unsigned int> &poResults) const {
-    ai_assert(mFinalized && "The SpatialSort object must be finalized before FindIdenticalPositions can be called.");
-    // Epsilons have a huge disadvantage: they are of constant precision, while floating-point
-    //  values are of log2 precision. If you apply e=0.01 to 100, the epsilon is rather small, but
-    //  if you apply it to 0.001, it is enormous.
-
-    // The best way to overcome this is the unit in the last place (ULP). A precision of 2 ULPs
-    //  tells us that a float does not differ more than 2 bits from the "real" value. ULPs are of
-    //  logarithmic precision - around 1, they are 1*(2^24) and around 10000, they are 0.00125.
-
-    // For standard C math, we can assume a precision of 0.5 ULPs according to IEEE 754. The
-    //  incoming vertex positions might have already been transformed, probably using rather
-    //  inaccurate SSE instructions, so we assume a tolerance of 4 ULPs to safely identify
-    //  identical vertex positions.
-    static const int toleranceInULPs = 4;
-    // An interesting point is that the inaccuracy grows linear with the number of operations:
-    //  multiplying to numbers, each inaccurate to four ULPs, results in an inaccuracy of four ULPs
-    //  plus 0.5 ULPs for the multiplication.
-    // To compute the distance to the plane, a dot product is needed - that is a multiplication and
-    //  an addition on each number.
-    static const int distanceToleranceInULPs = toleranceInULPs + 1;
-    // The squared distance between two 3D vectors is computed the same way, but with an additional
-    //  subtraction.
-    static const int distance3DToleranceInULPs = distanceToleranceInULPs + 1;
-
-    // Convert the plane distance to its signed integer representation so the ULPs tolerance can be
-    //  applied. For some reason, VC won't optimize two calls of the bit pattern conversion.
-    const BinFloat minDistBinary = ToBinary(CalculateDistance(pPosition)) - distanceToleranceInULPs;
-    const BinFloat maxDistBinary = minDistBinary + 2 * distanceToleranceInULPs;
-
-    // clear the array in this strange fashion because a simple clear() would also deallocate
-    // the array which we want to avoid
-    poResults.resize(0);
-
-    // do a binary search for the minimal distance to start the iteration there
-    unsigned int index = (unsigned int)mPositions.size() / 2;
-    unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4;
-    while (binaryStepSize > 1) {
-        // Ugly, but conditional jumps are faster with integers than with floats
-        if (minDistBinary > ToBinary(mPositions[index].mDistance))
-            index += binaryStepSize;
-        else
-            index -= binaryStepSize;
-
-        binaryStepSize /= 2;
-    }
-
-    // depending on the direction of the last step we need to single step a bit back or forth
-    // to find the actual beginning element of the range
-    while (index > 0 && minDistBinary < ToBinary(mPositions[index].mDistance))
-        index--;
-    while (index < (mPositions.size() - 1) && minDistBinary > ToBinary(mPositions[index].mDistance))
-        index++;
-
-    // Now start iterating from there until the first position lays outside of the distance range.
-    // Add all positions inside the distance range within the tolerance to the result array
-    std::vector<Entry>::const_iterator it = mPositions.begin() + index;
-    while (ToBinary(it->mDistance) < maxDistBinary) {
-        if (distance3DToleranceInULPs >= ToBinary((it->mPosition - pPosition).SquareLength()))
-            poResults.push_back(it->mIndex);
-        ++it;
-        if (it == mPositions.end())
-            break;
-    }
-
-    // that's it
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int> &fill, ai_real pRadius) const {
-    ai_assert(mFinalized && "The SpatialSort object must be finalized before GenerateMappingTable can be called.");
-    fill.resize(mPositions.size(), UINT_MAX);
-    ai_real dist, maxDist;
-
-    unsigned int t = 0;
-    const ai_real pSquared = pRadius * pRadius;
-    for (size_t i = 0; i < mPositions.size();) {
-        dist = (mPositions[i].mPosition - mCentroid) * mPlaneNormal;
-        maxDist = dist + pRadius;
-
-        fill[mPositions[i].mIndex] = t;
-        const aiVector3D &oldpos = mPositions[i].mPosition;
-        for (++i; i < fill.size() && mPositions[i].mDistance < maxDist && (mPositions[i].mPosition - oldpos).SquareLength() < pSquared; ++i) {
-            fill[mPositions[i].mIndex] = t;
-        }
-        ++t;
-    }
-
-#ifdef ASSIMP_BUILD_DEBUG
-
-    // debug invariant: mPositions[i].mIndex values must range from 0 to mPositions.size()-1
-    for (size_t i = 0; i < fill.size(); ++i) {
-        ai_assert(fill[i] < mPositions.size());
-    }
-
-#endif
-    return t;
-}
diff --git a/libs/assimp/code/Common/StandardShapes.cpp b/libs/assimp/code/Common/StandardShapes.cpp
deleted file mode 100644
index e94b5b9..0000000
--- a/libs/assimp/code/Common/StandardShapes.cpp
+++ /dev/null
@@ -1,479 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file   StandardShapes.cpp
- *  @brief  Implementation of the StandardShapes class
- *
- *  The primitive geometry data comes from
- *  http://geometrictools.com/Documentation/PlatonicSolids.pdf.
- */
-
-#include <assimp/StandardShapes.h>
-#include <assimp/StringComparison.h>
-#include <assimp/mesh.h>
-
-namespace Assimp {
-
-#define ADD_TRIANGLE(n0, n1, n2) \
-    positions.push_back(n0);     \
-    positions.push_back(n1);     \
-    positions.push_back(n2);
-
-#define ADD_PENTAGON(n0, n1, n2, n3, n4) \
-    if (polygons) {                      \
-        positions.push_back(n0);         \
-        positions.push_back(n1);         \
-        positions.push_back(n2);         \
-        positions.push_back(n3);         \
-        positions.push_back(n4);         \
-    } else {                             \
-        ADD_TRIANGLE(n0, n1, n2)         \
-        ADD_TRIANGLE(n0, n2, n3)         \
-        ADD_TRIANGLE(n0, n3, n4)         \
-    }
-
-#define ADD_QUAD(n0, n1, n2, n3) \
-    if (polygons) {              \
-        positions.push_back(n0); \
-        positions.push_back(n1); \
-        positions.push_back(n2); \
-        positions.push_back(n3); \
-    } else {                     \
-        ADD_TRIANGLE(n0, n1, n2) \
-        ADD_TRIANGLE(n0, n2, n3) \
-    }
-
-// ------------------------------------------------------------------------------------------------
-// Fast subdivision for a mesh whose verts have a magnitude of 1
-void Subdivide(std::vector<aiVector3D> &positions) {
-    // assume this to be constant - (fixme: must be 1.0? I think so)
-    const ai_real fl1 = positions[0].Length();
-
-    unsigned int origSize = (unsigned int)positions.size();
-    for (unsigned int i = 0; i < origSize; i += 3) {
-        aiVector3D &tv0 = positions[i];
-        aiVector3D &tv1 = positions[i + 1];
-        aiVector3D &tv2 = positions[i + 2];
-
-        aiVector3D a = tv0, b = tv1, c = tv2;
-        aiVector3D v1 = aiVector3D(a.x + b.x, a.y + b.y, a.z + b.z).Normalize() * fl1;
-        aiVector3D v2 = aiVector3D(a.x + c.x, a.y + c.y, a.z + c.z).Normalize() * fl1;
-        aiVector3D v3 = aiVector3D(b.x + c.x, b.y + c.y, b.z + c.z).Normalize() * fl1;
-
-        tv0 = v1;
-        tv1 = v3;
-        tv2 = v2; // overwrite the original
-        ADD_TRIANGLE(v1, v2, a);
-        ADD_TRIANGLE(v2, v3, c);
-        ADD_TRIANGLE(v3, v1, b);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Construct a mesh from given vertex positions
-aiMesh *StandardShapes::MakeMesh(const std::vector<aiVector3D> &positions,
-        unsigned int numIndices) {
-    if (positions.empty() || !numIndices) {
-        return nullptr;
-    }
-
-    // Determine which kinds of primitives the mesh consists of
-    aiMesh *out = new aiMesh();
-    switch (numIndices) {
-    case 1:
-        out->mPrimitiveTypes = aiPrimitiveType_POINT;
-        break;
-    case 2:
-        out->mPrimitiveTypes = aiPrimitiveType_LINE;
-        break;
-    case 3:
-        out->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-        break;
-    default:
-        out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
-        break;
-    };
-
-    out->mNumFaces = (unsigned int)positions.size() / numIndices;
-    out->mFaces = new aiFace[out->mNumFaces];
-    for (unsigned int i = 0, a = 0; i < out->mNumFaces; ++i) {
-        aiFace &f = out->mFaces[i];
-        f.mNumIndices = numIndices;
-        f.mIndices = new unsigned int[numIndices];
-        for (unsigned int j = 0; j < numIndices; ++j, ++a) {
-            f.mIndices[j] = a;
-        }
-    }
-    out->mNumVertices = (unsigned int)positions.size();
-    out->mVertices = new aiVector3D[out->mNumVertices];
-    ::memcpy(out->mVertices, &positions[0], out->mNumVertices * sizeof(aiVector3D));
-
-    return out;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Construct a mesh with a specific shape (callback)
-aiMesh *StandardShapes::MakeMesh(unsigned int (*GenerateFunc)(
-        std::vector<aiVector3D> &)) {
-    std::vector<aiVector3D> temp;
-    unsigned num = (*GenerateFunc)(temp);
-    return MakeMesh(temp, num);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Construct a mesh with a specific shape (callback)
-aiMesh *StandardShapes::MakeMesh(unsigned int (*GenerateFunc)(
-        std::vector<aiVector3D> &, bool)) {
-    std::vector<aiVector3D> temp;
-    unsigned num = (*GenerateFunc)(temp, true);
-    return MakeMesh(temp, num);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Construct a mesh with a specific shape (callback)
-aiMesh *StandardShapes::MakeMesh(unsigned int num, void (*GenerateFunc)(
-                                                           unsigned int, std::vector<aiVector3D> &)) {
-    std::vector<aiVector3D> temp;
-    (*GenerateFunc)(num, temp);
-    return MakeMesh(temp, 3);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build an incosahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeIcosahedron(std::vector<aiVector3D> &positions) {
-    positions.reserve(positions.size() + 60);
-
-    const ai_real t = (ai_real(1.0) + ai_real(2.236067977)) / ai_real(2.0);
-    const ai_real s = std::sqrt(ai_real(1.0) + t * t);
-
-    const aiVector3D v0 = aiVector3D(t, 1.0, 0.0) / s;
-    const aiVector3D v1 = aiVector3D(-t, 1.0, 0.0) / s;
-    const aiVector3D v2 = aiVector3D(t, -1.0, 0.0) / s;
-    const aiVector3D v3 = aiVector3D(-t, -1.0, 0.0) / s;
-    const aiVector3D v4 = aiVector3D(1.0, 0.0, t) / s;
-    const aiVector3D v5 = aiVector3D(1.0, 0.0, -t) / s;
-    const aiVector3D v6 = aiVector3D(-1.0, 0.0, t) / s;
-    const aiVector3D v7 = aiVector3D(-1.0, 0.0, -t) / s;
-    const aiVector3D v8 = aiVector3D(0.0, t, 1.0) / s;
-    const aiVector3D v9 = aiVector3D(0.0, -t, 1.0) / s;
-    const aiVector3D v10 = aiVector3D(0.0, t, -1.0) / s;
-    const aiVector3D v11 = aiVector3D(0.0, -t, -1.0) / s;
-
-    ADD_TRIANGLE(v0, v8, v4);
-    ADD_TRIANGLE(v0, v5, v10);
-    ADD_TRIANGLE(v2, v4, v9);
-    ADD_TRIANGLE(v2, v11, v5);
-
-    ADD_TRIANGLE(v1, v6, v8);
-    ADD_TRIANGLE(v1, v10, v7);
-    ADD_TRIANGLE(v3, v9, v6);
-    ADD_TRIANGLE(v3, v7, v11);
-
-    ADD_TRIANGLE(v0, v10, v8);
-    ADD_TRIANGLE(v1, v8, v10);
-    ADD_TRIANGLE(v2, v9, v11);
-    ADD_TRIANGLE(v3, v11, v9);
-
-    ADD_TRIANGLE(v4, v2, v0);
-    ADD_TRIANGLE(v5, v0, v2);
-    ADD_TRIANGLE(v6, v1, v3);
-    ADD_TRIANGLE(v7, v3, v1);
-
-    ADD_TRIANGLE(v8, v6, v4);
-    ADD_TRIANGLE(v9, v4, v6);
-    ADD_TRIANGLE(v10, v5, v7);
-    ADD_TRIANGLE(v11, v7, v5);
-    return 3;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a dodecahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeDodecahedron(std::vector<aiVector3D> &positions,
-        bool polygons /*= false*/) {
-    positions.reserve(positions.size() + 108);
-
-    const ai_real a = ai_real(1.0) / ai_real(1.7320508);
-    const ai_real b = std::sqrt((ai_real(3.0) - ai_real(2.23606797)) / ai_real(6.0));
-    const ai_real c = std::sqrt((ai_real(3.0) + ai_real(2.23606797f)) / ai_real(6.0));
-
-    const aiVector3D v0 = aiVector3D(a, a, a);
-    const aiVector3D v1 = aiVector3D(a, a, -a);
-    const aiVector3D v2 = aiVector3D(a, -a, a);
-    const aiVector3D v3 = aiVector3D(a, -a, -a);
-    const aiVector3D v4 = aiVector3D(-a, a, a);
-    const aiVector3D v5 = aiVector3D(-a, a, -a);
-    const aiVector3D v6 = aiVector3D(-a, -a, a);
-    const aiVector3D v7 = aiVector3D(-a, -a, -a);
-    const aiVector3D v8 = aiVector3D(b, c, 0.0);
-    const aiVector3D v9 = aiVector3D(-b, c, 0.0);
-    const aiVector3D v10 = aiVector3D(b, -c, 0.0);
-    const aiVector3D v11 = aiVector3D(-b, -c, 0.0);
-    const aiVector3D v12 = aiVector3D(c, 0.0, b);
-    const aiVector3D v13 = aiVector3D(c, 0.0, -b);
-    const aiVector3D v14 = aiVector3D(-c, 0.0, b);
-    const aiVector3D v15 = aiVector3D(-c, 0.0, -b);
-    const aiVector3D v16 = aiVector3D(0.0, b, c);
-    const aiVector3D v17 = aiVector3D(0.0, -b, c);
-    const aiVector3D v18 = aiVector3D(0.0, b, -c);
-    const aiVector3D v19 = aiVector3D(0.0, -b, -c);
-
-    ADD_PENTAGON(v0, v8, v9, v4, v16);
-    ADD_PENTAGON(v0, v12, v13, v1, v8);
-    ADD_PENTAGON(v0, v16, v17, v2, v12);
-    ADD_PENTAGON(v8, v1, v18, v5, v9);
-    ADD_PENTAGON(v12, v2, v10, v3, v13);
-    ADD_PENTAGON(v16, v4, v14, v6, v17);
-    ADD_PENTAGON(v9, v5, v15, v14, v4);
-
-    ADD_PENTAGON(v6, v11, v10, v2, v17);
-    ADD_PENTAGON(v3, v19, v18, v1, v13);
-    ADD_PENTAGON(v7, v15, v5, v18, v19);
-    ADD_PENTAGON(v7, v11, v6, v14, v15);
-    ADD_PENTAGON(v7, v19, v3, v10, v11);
-    return (polygons ? 5 : 3);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build an octahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeOctahedron(std::vector<aiVector3D> &positions) {
-    positions.reserve(positions.size() + 24);
-
-    const aiVector3D v0 = aiVector3D(1.0, 0.0, 0.0);
-    const aiVector3D v1 = aiVector3D(-1.0, 0.0, 0.0);
-    const aiVector3D v2 = aiVector3D(0.0, 1.0, 0.0);
-    const aiVector3D v3 = aiVector3D(0.0, -1.0, 0.0);
-    const aiVector3D v4 = aiVector3D(0.0, 0.0, 1.0);
-    const aiVector3D v5 = aiVector3D(0.0, 0.0, -1.0);
-
-    ADD_TRIANGLE(v4, v0, v2);
-    ADD_TRIANGLE(v4, v2, v1);
-    ADD_TRIANGLE(v4, v1, v3);
-    ADD_TRIANGLE(v4, v3, v0);
-
-    ADD_TRIANGLE(v5, v2, v0);
-    ADD_TRIANGLE(v5, v1, v2);
-    ADD_TRIANGLE(v5, v3, v1);
-    ADD_TRIANGLE(v5, v0, v3);
-    return 3;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a tetrahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeTetrahedron(std::vector<aiVector3D> &positions) {
-    positions.reserve(positions.size() + 9);
-
-    const ai_real invThree = ai_real(1.0) / ai_real(3.0);
-    const ai_real a = ai_real(1.41421) * invThree;
-    const ai_real b = ai_real(2.4494) * invThree;
-
-    const aiVector3D v0 = aiVector3D(0.0, 0.0, 1.0);
-    const aiVector3D v1 = aiVector3D(2 * a, 0, -invThree);
-    const aiVector3D v2 = aiVector3D(-a, b, -invThree);
-    const aiVector3D v3 = aiVector3D(-a, -b, -invThree);
-
-    ADD_TRIANGLE(v0, v1, v2);
-    ADD_TRIANGLE(v0, v2, v3);
-    ADD_TRIANGLE(v0, v3, v1);
-    ADD_TRIANGLE(v1, v3, v2);
-    return 3;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a hexahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeHexahedron(std::vector<aiVector3D> &positions,
-        bool polygons /*= false*/) {
-    positions.reserve(positions.size() + 36);
-    const ai_real length = ai_real(1.0) / ai_real(1.73205080);
-
-    const aiVector3D v0 = aiVector3D(-1.0, -1.0, -1.0) * length;
-    const aiVector3D v1 = aiVector3D(1.0, -1.0, -1.0) * length;
-    const aiVector3D v2 = aiVector3D(1.0, 1.0, -1.0) * length;
-    const aiVector3D v3 = aiVector3D(-1.0, 1.0, -1.0) * length;
-    const aiVector3D v4 = aiVector3D(-1.0, -1.0, 1.0) * length;
-    const aiVector3D v5 = aiVector3D(1.0, -1.0, 1.0) * length;
-    const aiVector3D v6 = aiVector3D(1.0, 1.0, 1.0) * length;
-    const aiVector3D v7 = aiVector3D(-1.0, 1.0, 1.0) * length;
-
-    ADD_QUAD(v0, v3, v2, v1);
-    ADD_QUAD(v0, v1, v5, v4);
-    ADD_QUAD(v0, v4, v7, v3);
-    ADD_QUAD(v6, v5, v1, v2);
-    ADD_QUAD(v6, v2, v3, v7);
-    ADD_QUAD(v6, v7, v4, v5);
-    return (polygons ? 4 : 3);
-}
-
-// Cleanup ...
-#undef ADD_TRIANGLE
-#undef ADD_QUAD
-#undef ADD_PENTAGON
-
-// ------------------------------------------------------------------------------------------------
-// Create a subdivision sphere
-void StandardShapes::MakeSphere(unsigned int tess,
-        std::vector<aiVector3D> &positions) {
-    // Reserve enough storage. Every subdivision
-    // splits each triangle in 4, the icosahedron consists of 60 verts
-    positions.reserve(positions.size() + 60 * integer_pow(4, tess));
-
-    // Construct an icosahedron to start with
-    MakeIcosahedron(positions);
-
-    // ... and subdivide it until the requested output
-    // tessellation is reached
-    for (unsigned int i = 0; i < tess; ++i)
-        Subdivide(positions);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a cone
-void StandardShapes::MakeCone(ai_real height, ai_real radius1,
-        ai_real radius2, unsigned int tess,
-        std::vector<aiVector3D> &positions, bool bOpen /*= false */) {
-    // Sorry, a cone with less than 3 segments makes ABSOLUTELY NO SENSE
-    if (tess < 3 || !height)
-        return;
-
-    size_t old = positions.size();
-
-    // No negative radii
-    radius1 = std::fabs(radius1);
-    radius2 = std::fabs(radius2);
-
-    ai_real halfHeight = height / ai_real(2.0);
-
-    // radius1 is always the smaller one
-    if (radius2 > radius1) {
-        std::swap(radius2, radius1);
-        halfHeight = -halfHeight;
-    } else
-        old = SIZE_MAX;
-
-    // Use a large epsilon to check whether the cone is pointy
-    if (radius1 < (radius2 - radius1) * 10e-3) radius1 = 0.0;
-
-    // We will need 3*2 verts per segment + 3*2 verts per segment
-    // if the cone is closed
-    const unsigned int mem = tess * 6 + (!bOpen ? tess * 3 * (radius1 ? 2 : 1) : 0);
-    positions.reserve(positions.size() + mem);
-
-    // Now construct all segments
-    const ai_real angle_delta = (ai_real)AI_MATH_TWO_PI / tess;
-    const ai_real angle_max = (ai_real)AI_MATH_TWO_PI;
-
-    ai_real s = 1.0; // std::cos(angle == 0);
-    ai_real t = 0.0; // std::sin(angle == 0);
-
-    for (ai_real angle = 0.0; angle < angle_max;) {
-        const aiVector3D v1 = aiVector3D(s * radius1, -halfHeight, t * radius1);
-        const aiVector3D v2 = aiVector3D(s * radius2, halfHeight, t * radius2);
-
-        const ai_real next = angle + angle_delta;
-        ai_real s2 = std::cos(next);
-        ai_real t2 = std::sin(next);
-
-        const aiVector3D v3 = aiVector3D(s2 * radius2, halfHeight, t2 * radius2);
-        const aiVector3D v4 = aiVector3D(s2 * radius1, -halfHeight, t2 * radius1);
-
-        positions.push_back(v1);
-        positions.push_back(v2);
-        positions.push_back(v3);
-        positions.push_back(v4);
-        positions.push_back(v1);
-        positions.push_back(v3);
-
-        if (!bOpen) {
-            // generate the end 'cap'
-            positions.push_back(aiVector3D(s * radius2, halfHeight, t * radius2));
-            positions.push_back(aiVector3D(s2 * radius2, halfHeight, t2 * radius2));
-            positions.push_back(aiVector3D(0.0, halfHeight, 0.0));
-
-            if (radius1) {
-                // generate the other end 'cap'
-                positions.push_back(aiVector3D(s * radius1, -halfHeight, t * radius1));
-                positions.push_back(aiVector3D(s2 * radius1, -halfHeight, t2 * radius1));
-                positions.push_back(aiVector3D(0.0, -halfHeight, 0.0));
-            }
-        }
-        s = s2;
-        t = t2;
-        angle = next;
-    }
-
-    // Need to flip face order?
-    if (SIZE_MAX != old) {
-        for (size_t p = old; p < positions.size(); p += 3) {
-            std::swap(positions[p], positions[p + 1]);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a circle
-void StandardShapes::MakeCircle(ai_real radius, unsigned int tess,
-        std::vector<aiVector3D> &positions) {
-    // Sorry, a circle with less than 3 segments makes ABSOLUTELY NO SENSE
-    if (tess < 3 || !radius)
-        return;
-
-    radius = std::fabs(radius);
-
-    // We will need 3 vertices per segment
-    positions.reserve(positions.size() + tess * 3);
-
-    const ai_real angle_delta = (ai_real)AI_MATH_TWO_PI / tess;
-    const ai_real angle_max = (ai_real)AI_MATH_TWO_PI;
-
-    ai_real s = 1.0; // std::cos(angle == 0);
-    ai_real t = 0.0; // std::sin(angle == 0);
-
-    for (ai_real angle = 0.0; angle < angle_max;) {
-        positions.push_back(aiVector3D(s * radius, 0.0, t * radius));
-        angle += angle_delta;
-        s = std::cos(angle);
-        t = std::sin(angle);
-        positions.push_back(aiVector3D(s * radius, 0.0, t * radius));
-
-        positions.push_back(aiVector3D(0.0, 0.0, 0.0));
-    }
-}
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/StdOStreamLogStream.h b/libs/assimp/code/Common/StdOStreamLogStream.h
deleted file mode 100644
index cc0e062..0000000
--- a/libs/assimp/code/Common/StdOStreamLogStream.h
+++ /dev/null
@@ -1,101 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file  StdOStreamLogStream.h
-*  @brief Implementation of StdOStreamLogStream
-*/
-
-#ifndef AI_STROSTREAMLOGSTREAM_H_INC
-#define AI_STROSTREAMLOGSTREAM_H_INC
-
-#include <assimp/LogStream.hpp>
-#include <ostream>
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** @class  StdOStreamLogStream
- *  @brief  Logs into a std::ostream
- */
-class StdOStreamLogStream : public LogStream {
-public:
-    /** @brief  Construction from an existing std::ostream
-     *  @param _ostream Output stream to be used
-    */
-    explicit StdOStreamLogStream(std::ostream& _ostream);
-
-    /** @brief  Destructor  */
-    ~StdOStreamLogStream();
-
-    /** @brief  Writer  */
-    void write(const char* message);
-
-private:
-    std::ostream& mOstream;
-};
-
-// ---------------------------------------------------------------------------
-//  Default constructor
-inline StdOStreamLogStream::StdOStreamLogStream(std::ostream& _ostream)
-: mOstream   (_ostream){
-    // empty
-}
-
-// ---------------------------------------------------------------------------
-//  Default constructor
-inline StdOStreamLogStream::~StdOStreamLogStream() {
-    // empty
-}
-
-// ---------------------------------------------------------------------------
-//  Write method
-inline void StdOStreamLogStream::write(const char* message) {
-    mOstream << message;
-    mOstream.flush();
-}
-
-// ---------------------------------------------------------------------------
-
-}   // Namespace Assimp
-
-#endif // guard
diff --git a/libs/assimp/code/Common/Subdivision.cpp b/libs/assimp/code/Common/Subdivision.cpp
deleted file mode 100644
index 705ea3f..0000000
--- a/libs/assimp/code/Common/Subdivision.cpp
+++ /dev/null
@@ -1,581 +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 <assimp/Subdivision.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/SpatialSort.h>
-#include <assimp/Vertex.h>
-#include <assimp/ai_assert.h>
-
-#include "PostProcessing/ProcessHelper.h"
-
-#include <stdio.h>
-
-using namespace Assimp;
-void mydummy() {}
-
-#ifdef _MSC_VER
-#pragma warning(disable : 4709)
-#endif // _MSC_VER
-// ------------------------------------------------------------------------------------------------
-/** Subdivider stub class to implement the Catmull-Clarke subdivision algorithm. The
- *  implementation is basing on recursive refinement. Directly evaluating the result is also
- *  possible and much quicker, but it depends on lengthy matrix lookup tables. */
-// ------------------------------------------------------------------------------------------------
-class CatmullClarkSubdivider : public Subdivider {
-public:
-    void Subdivide(aiMesh *mesh, aiMesh *&out, unsigned int num, bool discard_input);
-    void Subdivide(aiMesh **smesh, size_t nmesh,
-            aiMesh **out, unsigned int num, bool discard_input);
-
-    // ---------------------------------------------------------------------------
-    /** Intermediate description of an edge between two corners of a polygon*/
-    // ---------------------------------------------------------------------------
-    struct Edge {
-        Edge() :
-                ref(0) {}
-        Vertex edge_point, midpoint;
-        unsigned int ref;
-    };
-
-    typedef std::vector<unsigned int> UIntVector;
-    typedef std::map<uint64_t, Edge> EdgeMap;
-
-    // ---------------------------------------------------------------------------
-    // Hashing function to derive an index into an #EdgeMap from two given
-    // 'unsigned int' vertex coordinates (!!distinct coordinates - same
-    // vertex position == same index!!).
-    // NOTE - this leads to rare hash collisions if a) sizeof(unsigned int)>4
-    // and (id[0]>2^32-1 or id[0]>2^32-1).
-    // MAKE_EDGE_HASH() uses temporaries, so INIT_EDGE_HASH() needs to be put
-    // at the head of every function which is about to use MAKE_EDGE_HASH().
-    // Reason is that the hash is that hash construction needs to hold the
-    // invariant id0<id1 to identify an edge - else two hashes would refer
-    // to the same edge.
-    // ---------------------------------------------------------------------------
-#define MAKE_EDGE_HASH(id0, id1) (eh_tmp0__ = id0, eh_tmp1__ = id1, \
-        (eh_tmp0__ < eh_tmp1__ ? std::swap(eh_tmp0__, eh_tmp1__) : mydummy()), (uint64_t)eh_tmp0__ ^ ((uint64_t)eh_tmp1__ << 32u))
-
-#define INIT_EDGE_HASH_TEMPORARIES() \
-    unsigned int eh_tmp0__, eh_tmp1__;
-
-private:
-    void InternSubdivide(const aiMesh *const *smesh,
-            size_t nmesh, aiMesh **out, unsigned int num);
-};
-
-// ------------------------------------------------------------------------------------------------
-// Construct a subdivider of a specific type
-Subdivider *Subdivider::Create(Algorithm algo) {
-    switch (algo) {
-    case CATMULL_CLARKE:
-        return new CatmullClarkSubdivider();
-    };
-
-    ai_assert(false);
-
-    return nullptr; // shouldn't happen
-}
-
-// ------------------------------------------------------------------------------------------------
-// Call the Catmull Clark subdivision algorithm for one mesh
-void CatmullClarkSubdivider::Subdivide(
-        aiMesh *mesh,
-        aiMesh *&out,
-        unsigned int num,
-        bool discard_input) {
-    ai_assert(mesh != out);
-
-    Subdivide(&mesh, 1, &out, num, discard_input);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Call the Catmull Clark subdivision algorithm for multiple meshes
-void CatmullClarkSubdivider::Subdivide(
-        aiMesh **smesh,
-        size_t nmesh,
-        aiMesh **out,
-        unsigned int num,
-        bool discard_input) {
-    ai_assert(nullptr != smesh);
-    ai_assert(nullptr != out);
-
-    // course, both regions may not overlap
-    ai_assert(smesh < out || smesh + nmesh > out + nmesh);
-    if (!num) {
-        // No subdivision at all. Need to copy all the meshes .. argh.
-        if (discard_input) {
-            for (size_t s = 0; s < nmesh; ++s) {
-                out[s] = smesh[s];
-                smesh[s] = nullptr;
-            }
-        } else {
-            for (size_t s = 0; s < nmesh; ++s) {
-                SceneCombiner::Copy(out + s, smesh[s]);
-            }
-        }
-        return;
-    }
-
-    std::vector<aiMesh *> inmeshes;
-    std::vector<aiMesh *> outmeshes;
-    std::vector<unsigned int> maptbl;
-
-    inmeshes.reserve(nmesh);
-    outmeshes.reserve(nmesh);
-    maptbl.reserve(nmesh);
-
-    // Remove pure line and point meshes from the working set to reduce the
-    // number of edge cases the subdivider is forced to deal with. Line and
-    // point meshes are simply passed through.
-    for (size_t s = 0; s < nmesh; ++s) {
-        aiMesh *i = smesh[s];
-        // FIX - mPrimitiveTypes might not yet be initialized
-        if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE | aiPrimitiveType_POINT)) == i->mPrimitiveTypes) {
-            ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: Skipping pure line/point mesh");
-
-            if (discard_input) {
-                out[s] = i;
-                smesh[s] = nullptr;
-            } else {
-                SceneCombiner::Copy(out + s, i);
-            }
-            continue;
-        }
-
-        outmeshes.push_back(nullptr);
-        inmeshes.push_back(i);
-        maptbl.push_back(static_cast<unsigned int>(s));
-    }
-
-    // Do the actual subdivision on the preallocated storage. InternSubdivide
-    // *always* assumes that enough storage is available, it does not bother
-    // checking any ranges.
-    ai_assert(inmeshes.size() == outmeshes.size());
-    ai_assert(inmeshes.size() == maptbl.size());
-    if (inmeshes.empty()) {
-        ASSIMP_LOG_WARN("Catmull-Clark Subdivider: Pure point/line scene, I can't do anything");
-        return;
-    }
-    InternSubdivide(&inmeshes.front(), inmeshes.size(), &outmeshes.front(), num);
-    for (unsigned int i = 0; i < maptbl.size(); ++i) {
-        ai_assert(nullptr != outmeshes[i]);
-        out[maptbl[i]] = outmeshes[i];
-    }
-
-    if (discard_input) {
-        for (size_t s = 0; s < nmesh; ++s) {
-            delete smesh[s];
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Note - this is an implementation of the standard (recursive) Cm-Cl algorithm without further
-// optimizations (except we're using some nice LUTs). A description of the algorithm can be found
-// here: http://en.wikipedia.org/wiki/Catmull-Clark_subdivision_surface
-//
-// The code is mostly O(n), however parts are O(nlogn) which is therefore the algorithm's
-// expected total runtime complexity. The implementation is able to work in-place on the same
-// mesh arrays. Calling #InternSubdivide() directly is not encouraged. The code can operate
-// in-place unless 'smesh' and 'out' are equal (no strange overlaps or reorderings).
-// Previous data is replaced/deleted then.
-// ------------------------------------------------------------------------------------------------
-void CatmullClarkSubdivider::InternSubdivide(
-        const aiMesh *const *smesh,
-        size_t nmesh,
-        aiMesh **out,
-        unsigned int num) {
-    ai_assert(nullptr != smesh);
-    ai_assert(nullptr != out);
-
-    INIT_EDGE_HASH_TEMPORARIES();
-
-    // no subdivision requested or end of recursive refinement
-    if (!num) {
-        return;
-    }
-
-    UIntVector maptbl;
-    SpatialSort spatial;
-
-    // ---------------------------------------------------------------------
-    // 0. Offset table to index all meshes continuously, generate a spatially
-    // sorted representation of all vertices in all meshes.
-    // ---------------------------------------------------------------------
-    typedef std::pair<unsigned int, unsigned int> IntPair;
-    std::vector<IntPair> moffsets(nmesh);
-    unsigned int totfaces = 0, totvert = 0;
-    for (size_t t = 0; t < nmesh; ++t) {
-        const aiMesh *mesh = smesh[t];
-
-        spatial.Append(mesh->mVertices, mesh->mNumVertices, sizeof(aiVector3D), false);
-        moffsets[t] = IntPair(totfaces, totvert);
-
-        totfaces += mesh->mNumFaces;
-        totvert += mesh->mNumVertices;
-    }
-
-    spatial.Finalize();
-    const unsigned int num_unique = spatial.GenerateMappingTable(maptbl, ComputePositionEpsilon(smesh, nmesh));
-
-#define FLATTEN_VERTEX_IDX(mesh_idx, vert_idx) (moffsets[mesh_idx].second + vert_idx)
-#define FLATTEN_FACE_IDX(mesh_idx, face_idx) (moffsets[mesh_idx].first + face_idx)
-
-    // ---------------------------------------------------------------------
-    // 1. Compute the centroid point for all faces
-    // ---------------------------------------------------------------------
-    std::vector<Vertex> centroids(totfaces);
-    unsigned int nfacesout = 0;
-    for (size_t t = 0, n = 0; t < nmesh; ++t) {
-        const aiMesh *mesh = smesh[t];
-        for (unsigned int i = 0; i < mesh->mNumFaces; ++i, ++n) {
-            const aiFace &face = mesh->mFaces[i];
-            Vertex &c = centroids[n];
-
-            for (unsigned int a = 0; a < face.mNumIndices; ++a) {
-                c += Vertex(mesh, face.mIndices[a]);
-            }
-
-            c /= static_cast<float>(face.mNumIndices);
-            nfacesout += face.mNumIndices;
-        }
-    }
-
-    {
-        // we want edges to go away before the recursive calls so begin a new scope
-        EdgeMap edges;
-
-        // ---------------------------------------------------------------------
-        // 2. Set each edge point to be the average of all neighbouring
-        // face points and original points. Every edge exists twice
-        // if there is a neighboring face.
-        // ---------------------------------------------------------------------
-        for (size_t t = 0; t < nmesh; ++t) {
-            const aiMesh *mesh = smesh[t];
-
-            for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
-                const aiFace &face = mesh->mFaces[i];
-
-                for (unsigned int p = 0; p < face.mNumIndices; ++p) {
-                    const unsigned int id[] = {
-                        face.mIndices[p],
-                        face.mIndices[p == face.mNumIndices - 1 ? 0 : p + 1]
-                    };
-                    const unsigned int mp[] = {
-                        maptbl[FLATTEN_VERTEX_IDX(t, id[0])],
-                        maptbl[FLATTEN_VERTEX_IDX(t, id[1])]
-                    };
-
-                    Edge &e = edges[MAKE_EDGE_HASH(mp[0], mp[1])];
-                    e.ref++;
-                    if (e.ref <= 2) {
-                        if (e.ref == 1) { // original points (end points) - add only once
-                            e.edge_point = e.midpoint = Vertex(mesh, id[0]) + Vertex(mesh, id[1]);
-                            e.midpoint *= 0.5f;
-                        }
-                        e.edge_point += centroids[FLATTEN_FACE_IDX(t, i)];
-                    }
-                }
-            }
-        }
-
-        // ---------------------------------------------------------------------
-        // 3. Normalize edge points
-        // ---------------------------------------------------------------------
-        {
-            unsigned int bad_cnt = 0;
-            for (EdgeMap::iterator it = edges.begin(); it != edges.end(); ++it) {
-                if ((*it).second.ref < 2) {
-                    ai_assert((*it).second.ref);
-                    ++bad_cnt;
-                }
-                (*it).second.edge_point *= 1.f / ((*it).second.ref + 2.f);
-            }
-
-            if (bad_cnt) {
-                // Report the number of bad edges. bad edges are referenced by less than two
-                // faces in the mesh. They occur at outer model boundaries in non-closed
-                // shapes.
-                ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: got ", bad_cnt, " bad edges touching only one face (totally ",
-                        static_cast<unsigned int>(edges.size()), " edges). ");
-            }
-        }
-
-        // ---------------------------------------------------------------------
-        // 4. Compute a vertex-face adjacency table. We can't reuse the code
-        // from VertexTriangleAdjacency because we need the table for multiple
-        // meshes and out vertex indices need to be mapped to distinct values
-        // first.
-        // ---------------------------------------------------------------------
-        UIntVector faceadjac(nfacesout), cntadjfac(maptbl.size(), 0), ofsadjvec(maptbl.size() + 1, 0);
-        {
-            for (size_t t = 0; t < nmesh; ++t) {
-                const aiMesh *const minp = smesh[t];
-                for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
-
-                    const aiFace &f = minp->mFaces[i];
-                    for (unsigned int n = 0; n < f.mNumIndices; ++n) {
-                        ++cntadjfac[maptbl[FLATTEN_VERTEX_IDX(t, f.mIndices[n])]];
-                    }
-                }
-            }
-            unsigned int cur = 0;
-            for (size_t i = 0; i < cntadjfac.size(); ++i) {
-                ofsadjvec[i + 1] = cur;
-                cur += cntadjfac[i];
-            }
-            for (size_t t = 0; t < nmesh; ++t) {
-                const aiMesh *const minp = smesh[t];
-                for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
-
-                    const aiFace &f = minp->mFaces[i];
-                    for (unsigned int n = 0; n < f.mNumIndices; ++n) {
-                        faceadjac[ofsadjvec[1 + maptbl[FLATTEN_VERTEX_IDX(t, f.mIndices[n])]]++] = FLATTEN_FACE_IDX(t, i);
-                    }
-                }
-            }
-
-            // check the other way round for consistency
-#ifdef ASSIMP_BUILD_DEBUG
-
-            for (size_t t = 0; t < ofsadjvec.size() - 1; ++t) {
-                for (unsigned int m = 0; m < cntadjfac[t]; ++m) {
-                    const unsigned int fidx = faceadjac[ofsadjvec[t] + m];
-                    ai_assert(fidx < totfaces);
-                    for (size_t n = 1; n < nmesh; ++n) {
-
-                        if (moffsets[n].first > fidx) {
-                            const aiMesh *msh = smesh[--n];
-                            const aiFace &f = msh->mFaces[fidx - moffsets[n].first];
-
-                            bool haveit = false;
-                            for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                                if (maptbl[FLATTEN_VERTEX_IDX(n, f.mIndices[i])] == (unsigned int)t) {
-                                    haveit = true;
-                                    break;
-                                }
-                            }
-                            ai_assert(haveit);
-                            if (!haveit) {
-                                ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: Index not used");
-                            }
-                            break;
-                        }
-                    }
-                }
-            }
-
-#endif
-        }
-
-#define GET_ADJACENT_FACES_AND_CNT(vidx, fstartout, numout) \
-    fstartout = &faceadjac[ofsadjvec[vidx]], numout = cntadjfac[vidx]
-
-        typedef std::pair<bool, Vertex> TouchedOVertex;
-        std::vector<TouchedOVertex> new_points(num_unique, TouchedOVertex(false, Vertex()));
-        // ---------------------------------------------------------------------
-        // 5. Spawn a quad from each face point to the corresponding edge points
-        // the original points being the fourth quad points.
-        // ---------------------------------------------------------------------
-        for (size_t t = 0; t < nmesh; ++t) {
-            const aiMesh *const minp = smesh[t];
-            aiMesh *const mout = out[t] = new aiMesh();
-
-            for (unsigned int a = 0; a < minp->mNumFaces; ++a) {
-                mout->mNumFaces += minp->mFaces[a].mNumIndices;
-            }
-
-            // We need random access to the old face buffer, so reuse is not possible.
-            mout->mFaces = new aiFace[mout->mNumFaces];
-
-            mout->mNumVertices = mout->mNumFaces * 4;
-            mout->mVertices = new aiVector3D[mout->mNumVertices];
-
-            // quads only, keep material index
-            mout->mPrimitiveTypes = aiPrimitiveType_POLYGON;
-            mout->mMaterialIndex = minp->mMaterialIndex;
-
-            if (minp->HasNormals()) {
-                mout->mNormals = new aiVector3D[mout->mNumVertices];
-            }
-
-            if (minp->HasTangentsAndBitangents()) {
-                mout->mTangents = new aiVector3D[mout->mNumVertices];
-                mout->mBitangents = new aiVector3D[mout->mNumVertices];
-            }
-
-            for (unsigned int i = 0; minp->HasTextureCoords(i); ++i) {
-                mout->mTextureCoords[i] = new aiVector3D[mout->mNumVertices];
-                mout->mNumUVComponents[i] = minp->mNumUVComponents[i];
-            }
-
-            for (unsigned int i = 0; minp->HasVertexColors(i); ++i) {
-                mout->mColors[i] = new aiColor4D[mout->mNumVertices];
-            }
-
-            mout->mNumVertices = mout->mNumFaces << 2u;
-            for (unsigned int i = 0, v = 0, n = 0; i < minp->mNumFaces; ++i) {
-
-                const aiFace &face = minp->mFaces[i];
-                for (unsigned int a = 0; a < face.mNumIndices; ++a) {
-
-                    // Get a clean new face.
-                    aiFace &faceOut = mout->mFaces[n++];
-                    faceOut.mIndices = new unsigned int[faceOut.mNumIndices = 4];
-
-                    // Spawn a new quadrilateral (ccw winding) for this original point between:
-                    // a) face centroid
-                    centroids[FLATTEN_FACE_IDX(t, i)].SortBack(mout, faceOut.mIndices[0] = v++);
-
-                    // b) adjacent edge on the left, seen from the centroid
-                    const Edge &e0 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])],
-                            maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a == face.mNumIndices - 1 ? 0 : a + 1])])]; // fixme: replace with mod face.mNumIndices?
-
-                    // c) adjacent edge on the right, seen from the centroid
-                    const Edge &e1 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])],
-                            maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[!a ? face.mNumIndices - 1 : a - 1])])]; // fixme: replace with mod face.mNumIndices?
-
-                    e0.edge_point.SortBack(mout, faceOut.mIndices[3] = v++);
-                    e1.edge_point.SortBack(mout, faceOut.mIndices[1] = v++);
-
-                    // d= original point P with distinct index i
-                    // F := 0
-                    // R := 0
-                    // n := 0
-                    // for each face f containing i
-                    //    F := F+ centroid of f
-                    //    R := R+ midpoint of edge of f from i to i+1
-                    //    n := n+1
-                    //
-                    // (F+2R+(n-3)P)/n
-                    const unsigned int org = maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])];
-                    TouchedOVertex &ov = new_points[org];
-
-                    if (!ov.first) {
-                        ov.first = true;
-
-                        const unsigned int *adj;
-                        unsigned int cnt;
-                        GET_ADJACENT_FACES_AND_CNT(org, adj, cnt);
-
-                        if (cnt < 3) {
-                            ov.second = Vertex(minp, face.mIndices[a]);
-                        } else {
-
-                            Vertex F, R;
-                            for (unsigned int o = 0; o < cnt; ++o) {
-                                ai_assert(adj[o] < totfaces);
-                                F += centroids[adj[o]];
-
-                                // adj[0] is a global face index - search the face in the mesh list
-                                const aiMesh *mp = nullptr;
-                                size_t nidx;
-
-                                if (adj[o] < moffsets[0].first) {
-                                    mp = smesh[nidx = 0];
-                                } else {
-                                    for (nidx = 1; nidx <= nmesh; ++nidx) {
-                                        if (nidx == nmesh || moffsets[nidx].first > adj[o]) {
-                                            mp = smesh[--nidx];
-                                            break;
-                                        }
-                                    }
-                                }
-
-                                ai_assert(adj[o] - moffsets[nidx].first < mp->mNumFaces);
-                                const aiFace &f = mp->mFaces[adj[o] - moffsets[nidx].first];
-                                bool haveit = false;
-
-                                // find our original point in the face
-                                for (unsigned int m = 0; m < f.mNumIndices; ++m) {
-                                    if (maptbl[FLATTEN_VERTEX_IDX(nidx, f.mIndices[m])] == org) {
-
-                                        // add *both* edges. this way, we can be sure that we add
-                                        // *all* adjacent edges to R. In a closed shape, every
-                                        // edge is added twice - so we simply leave out the
-                                        // factor 2.f in the amove formula and get the right
-                                        // result.
-
-                                        const Edge &c0 = edges[MAKE_EDGE_HASH(org, maptbl[FLATTEN_VERTEX_IDX(
-                                                                                           nidx, f.mIndices[!m ? f.mNumIndices - 1 : m - 1])])];
-                                        // fixme: replace with mod face.mNumIndices?
-
-                                        const Edge &c1 = edges[MAKE_EDGE_HASH(org, maptbl[FLATTEN_VERTEX_IDX(
-                                                                                           nidx, f.mIndices[m == f.mNumIndices - 1 ? 0 : m + 1])])];
-                                        // fixme: replace with mod face.mNumIndices?
-                                        R += c0.midpoint + c1.midpoint;
-
-                                        haveit = true;
-                                        break;
-                                    }
-                                }
-
-                                // this invariant *must* hold if the vertex-to-face adjacency table is valid
-                                ai_assert(haveit);
-                                if (!haveit) {
-                                    ASSIMP_LOG_WARN("OBJ: no name for material library specified.");
-                                }
-                            }
-
-                            const float div = static_cast<float>(cnt), divsq = 1.f / (div * div);
-                            ov.second = Vertex(minp, face.mIndices[a]) * ((div - 3.f) / div) + R * divsq + F * divsq;
-                        }
-                    }
-                    ov.second.SortBack(mout, faceOut.mIndices[2] = v++);
-                }
-            }
-        }
-    } // end of scope for edges, freeing its memory
-
-    // ---------------------------------------------------------------------
-    // 7. Apply the next subdivision step.
-    // ---------------------------------------------------------------------
-    if (num != 1) {
-        std::vector<aiMesh *> tmp(nmesh);
-        InternSubdivide(out, nmesh, &tmp.front(), num - 1);
-        for (size_t i = 0; i < nmesh; ++i) {
-            delete out[i];
-            out[i] = tmp[i];
-        }
-    }
-}
diff --git a/libs/assimp/code/Common/TargetAnimation.cpp b/libs/assimp/code/Common/TargetAnimation.cpp
deleted file mode 100644
index 5f6d9ba..0000000
--- a/libs/assimp/code/Common/TargetAnimation.cpp
+++ /dev/null
@@ -1,226 +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 "TargetAnimation.h"
-#include <assimp/ai_assert.h>
-#include <algorithm>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-KeyIterator::KeyIterator(const std::vector<aiVectorKey> *_objPos,
-    const std::vector<aiVectorKey> *_targetObjPos,
-    const aiVector3D *defaultObjectPos /*= nullptr*/,
-    const aiVector3D *defaultTargetPos /*= nullptr*/) :
-        reachedEnd(false),
-        curTime(-1.),
-        objPos(_objPos),
-        targetObjPos(_targetObjPos),
-        nextObjPos(0),
-        nextTargetObjPos(0) {
-    // Generate default transformation tracks if necessary
-    if (!objPos || objPos->empty()) {
-        defaultObjPos.resize(1);
-        defaultObjPos.front().mTime = 10e10;
-
-        if (defaultObjectPos)
-            defaultObjPos.front().mValue = *defaultObjectPos;
-
-        objPos = &defaultObjPos;
-    }
-    if (!targetObjPos || targetObjPos->empty()) {
-        defaultTargetObjPos.resize(1);
-        defaultTargetObjPos.front().mTime = 10e10;
-
-        if (defaultTargetPos)
-            defaultTargetObjPos.front().mValue = *defaultTargetPos;
-
-        targetObjPos = &defaultTargetObjPos;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <class T>
-inline T Interpolate(const T &one, const T &two, ai_real val) {
-    return one + (two - one) * val;
-}
-
-// ------------------------------------------------------------------------------------------------
-void KeyIterator::operator++() {
-    // If we are already at the end of all keyframes, return
-    if (reachedEnd) {
-        return;
-    }
-
-    // Now search in all arrays for the time value closest
-    // to our current position on the time line
-    double d0, d1;
-
-    d0 = objPos->at(std::min(nextObjPos, static_cast<unsigned int>(objPos->size() - 1))).mTime;
-    d1 = targetObjPos->at(std::min(nextTargetObjPos, static_cast<unsigned int>(targetObjPos->size() - 1))).mTime;
-
-    // Easiest case - all are identical. In this
-    // case we don't need to interpolate so we can
-    // return earlier
-    if (d0 == d1) {
-        curTime = d0;
-        curPosition = objPos->at(nextObjPos).mValue;
-        curTargetPosition = targetObjPos->at(nextTargetObjPos).mValue;
-
-        // increment counters
-        if (objPos->size() != nextObjPos - 1)
-            ++nextObjPos;
-
-        if (targetObjPos->size() != nextTargetObjPos - 1)
-            ++nextTargetObjPos;
-    }
-
-    // An object position key is closest to us
-    else if (d0 < d1) {
-        curTime = d0;
-
-        // interpolate the other
-        if (1 == targetObjPos->size() || !nextTargetObjPos) {
-            curTargetPosition = targetObjPos->at(0).mValue;
-        } else {
-            const aiVectorKey &last = targetObjPos->at(nextTargetObjPos);
-            const aiVectorKey &first = targetObjPos->at(nextTargetObjPos - 1);
-
-            curTargetPosition = Interpolate(first.mValue, last.mValue, (ai_real)((curTime - first.mTime) / (last.mTime - first.mTime)));
-        }
-
-        if (objPos->size() != nextObjPos - 1)
-            ++nextObjPos;
-    }
-    // A target position key is closest to us
-    else {
-        curTime = d1;
-
-        // interpolate the other
-        if (1 == objPos->size() || !nextObjPos) {
-            curPosition = objPos->at(0).mValue;
-        } else {
-            const aiVectorKey &last = objPos->at(nextObjPos);
-            const aiVectorKey &first = objPos->at(nextObjPos - 1);
-
-            curPosition = Interpolate(first.mValue, last.mValue, (ai_real)((curTime - first.mTime) / (last.mTime - first.mTime)));
-        }
-
-        if (targetObjPos->size() != nextTargetObjPos - 1)
-            ++nextTargetObjPos;
-    }
-
-    if (nextObjPos >= objPos->size() - 1 &&
-            nextTargetObjPos >= targetObjPos->size() - 1) {
-        // We reached the very last keyframe
-        reachedEnd = true;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::SetTargetAnimationChannel(
-        const std::vector<aiVectorKey> *_targetPositions) {
-    ai_assert(nullptr != _targetPositions);
-
-    targetPositions = _targetPositions;
-}
-
-// ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::SetMainAnimationChannel(
-        const std::vector<aiVectorKey> *_objectPositions) {
-    ai_assert(nullptr != _objectPositions);
-
-    objectPositions = _objectPositions;
-}
-
-// ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::SetFixedMainAnimationChannel(
-        const aiVector3D &fixed) {
-    objectPositions = nullptr; // just to avoid confusion
-    fixedMain = fixed;
-}
-
-// ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::Process(std::vector<aiVectorKey> *distanceTrack) {
-    ai_assert(nullptr != targetPositions);
-    ai_assert(nullptr != distanceTrack);
-
-    // TODO: in most cases we won't need the extra array
-    std::vector<aiVectorKey> real;
-
-    std::vector<aiVectorKey> *fill = (distanceTrack == objectPositions ? &real : distanceTrack);
-    fill->reserve(std::max(objectPositions->size(), targetPositions->size()));
-
-    // Iterate through all object keys and interpolate their values if necessary.
-    // Then get the corresponding target position, compute the difference
-    // vector between object and target position. Then compute a rotation matrix
-    // that rotates the base vector of the object coordinate system at that time
-    // to match the diff vector.
-
-    KeyIterator iter(objectPositions, targetPositions, &fixedMain);
-    for (; !iter.Finished(); ++iter) {
-        const aiVector3D &position = iter.GetCurPosition();
-        const aiVector3D &tposition = iter.GetCurTargetPosition();
-
-        // diff vector
-        aiVector3D diff = tposition - position;
-        ai_real f = diff.Length();
-
-        // output distance vector
-        if (f) {
-            fill->push_back(aiVectorKey());
-            aiVectorKey &v = fill->back();
-            v.mTime = iter.GetCurTime();
-            v.mValue = diff;
-
-            diff /= f;
-        } else {
-            // FIXME: handle this
-        }
-
-        // diff is now the vector in which our camera is pointing
-    }
-
-    if (real.size()) {
-        *distanceTrack = real;
-    }
-}
diff --git a/libs/assimp/code/Common/TargetAnimation.h b/libs/assimp/code/Common/TargetAnimation.h
deleted file mode 100644
index 863406b..0000000
--- a/libs/assimp/code/Common/TargetAnimation.h
+++ /dev/null
@@ -1,161 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a helper class for the ASE and 3DS loaders to
- help them compute camera and spot light animation channels */
-#ifndef AI_TARGET_ANIMATION_H_INC
-#define AI_TARGET_ANIMATION_H_INC
-
-#include <assimp/anim.h>
-#include <vector>
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** Helper class to iterate through all keys in an animation channel.
- *
- *  Missing tracks are interpolated. This is a helper class for
- *  TargetAnimationHelper, but it can be freely used for other purposes.
-*/
-class KeyIterator {
-public:
-    // ------------------------------------------------------------------
-    /** Constructs a new key iterator
-     *
-     *  @param _objPos Object position track. May be nullptr.
-     *  @param _targetObjPos Target object position track. May be nullptr.
-     *  @param defaultObjectPos Default object position to be used if
-     *    no animated track is available. May be nullptr.
-     *  @param defaultTargetPos Default target position to be used if
-     *    no animated track is available. May be nullptr.
-     */
-    KeyIterator(const std::vector<aiVectorKey> *_objPos,
-            const std::vector<aiVectorKey> *_targetObjPos,
-            const aiVector3D *defaultObjectPos = nullptr,
-            const aiVector3D *defaultTargetPos = nullptr);
-
-    // ------------------------------------------------------------------
-    /** Returns true if all keys have been processed
-     */
-    bool Finished() const { return reachedEnd; }
-
-    // ------------------------------------------------------------------
-    /** Increment the iterator
-     */
-    void operator++();
-    inline void operator++(int) { return ++(*this); }
-
-    // ------------------------------------------------------------------
-    /** Getters to retrieve the current state of the iterator
-     */
-    inline const aiVector3D &GetCurPosition() const { return curPosition; }
-
-    inline const aiVector3D &GetCurTargetPosition() const { return curTargetPosition; }
-
-    inline double GetCurTime() const { return curTime; }
-
-private:
-    //! Did we reach the end?
-    bool reachedEnd;
-
-    //! Represents the current position of the iterator
-    aiVector3D curPosition, curTargetPosition;
-
-    double curTime;
-
-    //! Input tracks and the next key to process
-    const std::vector<aiVectorKey> *objPos, *targetObjPos;
-
-    unsigned int nextObjPos, nextTargetObjPos;
-    std::vector<aiVectorKey> defaultObjPos, defaultTargetObjPos;
-};
-
-// ---------------------------------------------------------------------------
-/** Helper class for the 3DS and ASE loaders to compute camera and spot light
- *  animations.
- *
- * 3DS and ASE store the differently to Assimp - there is an animation
- * channel for the camera/spot light itself and a separate position
- * animation channels specifying the position of the camera/spot light
- * look-at target */
-class TargetAnimationHelper {
-public:
-    TargetAnimationHelper() :
-            targetPositions(nullptr),
-            objectPositions(nullptr) {
-        // empty
-    }
-
-    // ------------------------------------------------------------------
-    /** Sets the target animation channel
-     *
-     *  This channel specifies the position of the camera/spot light
-     *  target at a specific position.
-     *
-     *  @param targetPositions Translation channel*/
-    void SetTargetAnimationChannel(const std::vector<aiVectorKey> *targetPositions);
-
-    // ------------------------------------------------------------------
-    /** Sets the main animation channel
-     *
-     *  @param objectPositions Translation channel */
-    void SetMainAnimationChannel(const std::vector<aiVectorKey> *objectPositions);
-
-    // ------------------------------------------------------------------
-    /** Sets the main animation channel to a fixed value
-     *
-     *  @param fixed Fixed value for the main animation channel*/
-    void SetFixedMainAnimationChannel(const aiVector3D &fixed);
-
-    // ------------------------------------------------------------------
-    /** Computes final animation channels
-     * @param distanceTrack Receive camera translation keys ... != nullptr. */
-    void Process(std::vector<aiVectorKey> *distanceTrack);
-
-private:
-    const std::vector<aiVectorKey> *targetPositions, *objectPositions;
-    aiVector3D fixedMain;
-};
-
-} // namespace Assimp
-
-#endif // include guard
diff --git a/libs/assimp/code/Common/Version.cpp b/libs/assimp/code/Common/Version.cpp
deleted file mode 100644
index 86d3f22..0000000
--- a/libs/assimp/code/Common/Version.cpp
+++ /dev/null
@@ -1,186 +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.
----------------------------------------------------------------------------
-*/
-
-// Actually just a dummy, used by the compiler to build the pre-compiled header.
-
-#include "ScenePrivate.h"
-#include <assimp/scene.h>
-#include <assimp/version.h>
-
-#include "revision.h"
-
-// --------------------------------------------------------------------------------
-// Legal information string - don't remove this.
-static const char *LEGAL_INFORMATION =
-        "Open Asset Import Library (Assimp).\n"
-        "A free C/C++ library to import various 3D file formats into applications\n\n"
-        "(c) 2006-2022, Assimp team\n"
-        "License under the terms and conditions of the 3-clause BSD license\n"
-        "https://www.assimp.org\n";
-
-// ------------------------------------------------------------------------------------------------
-// Get legal string
-ASSIMP_API const char *aiGetLegalString() {
-    return LEGAL_INFORMATION;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get Assimp patch version
-ASSIMP_API unsigned int aiGetVersionPatch() {
-    return VER_PATCH;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get Assimp minor version
-ASSIMP_API unsigned int aiGetVersionMinor() {
-    return VER_MINOR;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get Assimp major version
-ASSIMP_API unsigned int aiGetVersionMajor() {
-    return VER_MAJOR;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get flags used for compilation
-ASSIMP_API unsigned int aiGetCompileFlags() {
-
-    unsigned int flags = 0;
-
-#ifdef ASSIMP_BUILD_BOOST_WORKAROUND
-    flags |= ASSIMP_CFLAGS_NOBOOST;
-#endif
-#ifdef ASSIMP_BUILD_SINGLETHREADED
-    flags |= ASSIMP_CFLAGS_SINGLETHREADED;
-#endif
-#ifdef ASSIMP_BUILD_DEBUG
-    flags |= ASSIMP_CFLAGS_DEBUG;
-#endif
-#ifdef ASSIMP_BUILD_DLL_EXPORT
-    flags |= ASSIMP_CFLAGS_SHARED;
-#endif
-#ifdef _STLPORT_VERSION
-    flags |= ASSIMP_CFLAGS_STLPORT;
-#endif
-#ifdef ASSIMP_DOUBLE_PRECISION
-    flags |= ASSIMP_CFLAGS_DOUBLE_SUPPORT;
-#endif
-
-    return flags;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API unsigned int aiGetVersionRevision() {
-    return GitVersion;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API const char *aiGetBranchName() {
-    return GitBranch;
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API aiScene::aiScene() :
-        mFlags(0),
-        mRootNode(nullptr),
-        mNumMeshes(0),
-        mMeshes(nullptr),
-        mNumMaterials(0),
-        mMaterials(nullptr),
-        mNumAnimations(0),
-        mAnimations(nullptr),
-        mNumTextures(0),
-        mTextures(nullptr),
-        mNumLights(0),
-        mLights(nullptr),
-        mNumCameras(0),
-        mCameras(nullptr),
-        mMetaData(nullptr),
-        mPrivate(new Assimp::ScenePrivateData()) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-ASSIMP_API aiScene::~aiScene() {
-    // delete all sub-objects recursively
-    delete mRootNode;
-
-    // To make sure we won't crash if the data is invalid it's
-    // much better to check whether both mNumXXX and mXXX are
-    // valid instead of relying on just one of them.
-    if (mNumMeshes && mMeshes)
-        for (unsigned int a = 0; a < mNumMeshes; a++)
-            delete mMeshes[a];
-    delete[] mMeshes;
-
-    if (mNumMaterials && mMaterials) {
-        for (unsigned int a = 0; a < mNumMaterials; ++a) {
-            delete mMaterials[a];
-        }
-    }
-    delete[] mMaterials;
-
-    if (mNumAnimations && mAnimations)
-        for (unsigned int a = 0; a < mNumAnimations; a++)
-            delete mAnimations[a];
-    delete[] mAnimations;
-
-    if (mNumTextures && mTextures)
-        for (unsigned int a = 0; a < mNumTextures; a++)
-            delete mTextures[a];
-    delete[] mTextures;
-
-    if (mNumLights && mLights)
-        for (unsigned int a = 0; a < mNumLights; a++)
-            delete mLights[a];
-    delete[] mLights;
-
-    if (mNumCameras && mCameras)
-        for (unsigned int a = 0; a < mNumCameras; a++)
-            delete mCameras[a];
-    delete[] mCameras;
-
-    aiMetadata::Dealloc(mMetaData);
-    mMetaData = nullptr;
-
-    delete static_cast<Assimp::ScenePrivateData *>(mPrivate);
-}
diff --git a/libs/assimp/code/Common/VertexTriangleAdjacency.cpp b/libs/assimp/code/Common/VertexTriangleAdjacency.cpp
deleted file mode 100644
index 555e3e3..0000000
--- a/libs/assimp/code/Common/VertexTriangleAdjacency.cpp
+++ /dev/null
@@ -1,131 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the VertexTriangleAdjacency helper class
- */
-
-// internal headers
-#include "VertexTriangleAdjacency.h"
-#include <assimp/mesh.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
-        unsigned int iNumFaces,
-        unsigned int iNumVertices /*= 0*/,
-        bool bComputeNumTriangles /*= false*/) {
-    // compute the number of referenced vertices if it wasn't specified by the caller
-    const aiFace *const pcFaceEnd = pcFaces + iNumFaces;
-    if (0 == iNumVertices) {
-        for (aiFace *pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace) {
-            ai_assert(nullptr != pcFace);
-            ai_assert(3 == pcFace->mNumIndices);
-            iNumVertices = std::max(iNumVertices, pcFace->mIndices[0]);
-            iNumVertices = std::max(iNumVertices, pcFace->mIndices[1]);
-            iNumVertices = std::max(iNumVertices, pcFace->mIndices[2]);
-        }
-    }
-
-    mNumVertices = iNumVertices + 1;
-
-    unsigned int *pi;
-
-    // allocate storage
-    if (bComputeNumTriangles) {
-        pi = mLiveTriangles = new unsigned int[iNumVertices + 1];
-        ::memset(mLiveTriangles, 0, sizeof(unsigned int) * (iNumVertices + 1));
-        mOffsetTable = new unsigned int[iNumVertices + 2] + 1;
-    } else {
-        pi = mOffsetTable = new unsigned int[iNumVertices + 2] + 1;
-        ::memset(mOffsetTable, 0, sizeof(unsigned int) * (iNumVertices + 1));
-        mLiveTriangles = nullptr; // important, otherwise the d'tor would crash
-    }
-
-    // get a pointer to the end of the buffer
-    unsigned int *piEnd = pi + iNumVertices;
-    *piEnd++ = 0u;
-
-    // first pass: compute the number of faces referencing each vertex
-    for (aiFace *pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace) {
-        unsigned nind = pcFace->mNumIndices;
-        unsigned *ind = pcFace->mIndices;
-        if (nind > 0) pi[ind[0]]++;
-        if (nind > 1) pi[ind[1]]++;
-        if (nind > 2) pi[ind[2]]++;
-    }
-
-    // second pass: compute the final offset table
-    unsigned int iSum = 0;
-    unsigned int *piCurOut = this->mOffsetTable;
-    for (unsigned int *piCur = pi; piCur != piEnd; ++piCur, ++piCurOut) {
-
-        unsigned int iLastSum = iSum;
-        iSum += *piCur;
-        *piCurOut = iLastSum;
-    }
-    pi = this->mOffsetTable;
-
-    // third pass: compute the final table
-    this->mAdjacencyTable = new unsigned int[iSum];
-    iSum = 0;
-    for (aiFace *pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace, ++iSum) {
-        unsigned nind = pcFace->mNumIndices;
-        unsigned *ind = pcFace->mIndices;
-
-        if (nind > 0) mAdjacencyTable[pi[ind[0]]++] = iSum;
-        if (nind > 1) mAdjacencyTable[pi[ind[1]]++] = iSum;
-        if (nind > 2) mAdjacencyTable[pi[ind[2]]++] = iSum;
-    }
-    // fourth pass: undo the offset computations made during the third pass
-    // We could do this in a separate buffer, but this would be TIMES slower.
-    --mOffsetTable;
-    *mOffsetTable = 0u;
-}
-// ------------------------------------------------------------------------------------------------
-VertexTriangleAdjacency::~VertexTriangleAdjacency() {
-    // delete allocated storage
-    delete[] mOffsetTable;
-    delete[] mAdjacencyTable;
-    delete[] mLiveTriangles;
-}
diff --git a/libs/assimp/code/Common/VertexTriangleAdjacency.h b/libs/assimp/code/Common/VertexTriangleAdjacency.h
deleted file mode 100644
index 41d8094..0000000
--- a/libs/assimp/code/Common/VertexTriangleAdjacency.h
+++ /dev/null
@@ -1,117 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a helper class to compute a vertex-triangle adjacency map */
-#ifndef AI_VTADJACENCY_H_INC
-#define AI_VTADJACENCY_H_INC
-
-#include "BaseProcess.h"
-#include <assimp/types.h>
-#include <assimp/ai_assert.h>
-
-struct aiMesh;
-struct aiFace;
-
-namespace Assimp    {
-
-// --------------------------------------------------------------------------------------------
-/** @brief The VertexTriangleAdjacency class computes a vertex-triangle
- *  adjacency map from a given index buffer.
- *
- *  @note Although it is called #VertexTriangleAdjacency, the current version does also
- *    support arbitrary polygons. */
-// --------------------------------------------------------------------------------------------
-class ASSIMP_API VertexTriangleAdjacency {
-public:
-    // ----------------------------------------------------------------------------
-    /** @brief Construction from an existing index buffer
-     *  @param pcFaces Index buffer
-     *  @param iNumFaces Number of faces in the buffer
-     *  @param iNumVertices Number of referenced vertices. This value
-     *    is computed automatically if 0 is specified.
-     *  @param bComputeNumTriangles If you want the class to compute
-     *    a list containing the number of referenced triangles per vertex
-     *    per vertex - pass true.  */
-    VertexTriangleAdjacency(aiFace* pcFaces,unsigned int iNumFaces,
-        unsigned int iNumVertices = 0,
-        bool bComputeNumTriangles = true);
-
-    // ----------------------------------------------------------------------------
-    /** @brief Destructor */
-    ~VertexTriangleAdjacency();
-
-    // ----------------------------------------------------------------------------
-    /** @brief Get all triangles adjacent to a vertex
-     *  @param iVertIndex Index of the vertex
-     *  @return A pointer to the adjacency list. */
-    unsigned int* GetAdjacentTriangles(unsigned int iVertIndex) const {
-        ai_assert(iVertIndex < mNumVertices);
-        return &mAdjacencyTable[ mOffsetTable[iVertIndex]];
-    }
-
-    // ----------------------------------------------------------------------------
-    /** @brief Get the number of triangles that are referenced by
-     *    a vertex. This function returns a reference that can be modified
-     *  @param iVertIndex Index of the vertex
-     *  @return Number of referenced triangles */
-    unsigned int& GetNumTrianglesPtr(unsigned int iVertIndex) {
-        ai_assert( iVertIndex < mNumVertices );
-        ai_assert( nullptr != mLiveTriangles );
-        return mLiveTriangles[iVertIndex];
-    }
-
-    //! Offset table
-    unsigned int* mOffsetTable;
-
-    //! Adjacency table
-    unsigned int* mAdjacencyTable;
-
-    //! Table containing the number of referenced triangles per vertex
-    unsigned int* mLiveTriangles;
-
-    //! Debug: Number of referenced vertices
-    unsigned int mNumVertices;
-};
-
-} //! ns Assimp
-
-#endif // !! AI_VTADJACENCY_H_INC
diff --git a/libs/assimp/code/Common/Win32DebugLogStream.h b/libs/assimp/code/Common/Win32DebugLogStream.h
deleted file mode 100644
index 34d849e..0000000
--- a/libs/assimp/code/Common/Win32DebugLogStream.h
+++ /dev/null
@@ -1,95 +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.
----------------------------------------------------------------------------
-*/
-
-/** @file  Win32DebugLogStream.h
-*  @brief Implementation of Win32DebugLogStream
-*/
-#ifndef AI_WIN32DEBUGLOGSTREAM_H_INC
-#define AI_WIN32DEBUGLOGSTREAM_H_INC
-
-#ifdef _WIN32
-
-#include <assimp/LogStream.hpp>
-#include "windows.h"
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** @class  Win32DebugLogStream
- *  @brief  Logs into the debug stream from win32.
- */
-class Win32DebugLogStream : public LogStream {
-public:
-    /** @brief  Default constructor */
-    Win32DebugLogStream();
-
-    /** @brief  Destructor  */
-    ~Win32DebugLogStream();
-
-    /** @brief  Writer  */
-    void write(const char* messgae);
-};
-
-// ---------------------------------------------------------------------------
-inline
-Win32DebugLogStream::Win32DebugLogStream(){
-    // empty
-}
-
-// ---------------------------------------------------------------------------
-inline
-Win32DebugLogStream::~Win32DebugLogStream(){
-    // empty
-}
-
-// ---------------------------------------------------------------------------
-inline
-void Win32DebugLogStream::write(const char* message) {
-    ::OutputDebugStringA( message);
-}
-
-// ---------------------------------------------------------------------------
-}   // Namespace Assimp
-
-#endif // ! _WIN32
-#endif // guard
diff --git a/libs/assimp/code/Common/ZipArchiveIOSystem.cpp b/libs/assimp/code/Common/ZipArchiveIOSystem.cpp
deleted file mode 100644
index c322b14..0000000
--- a/libs/assimp/code/Common/ZipArchiveIOSystem.cpp
+++ /dev/null
@@ -1,563 +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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  ZipArchiveIOSystem.cpp
- *  @brief Zip File I/O implementation for #Importer
- */
-
-#include <assimp/BaseImporter.h>
-#include <assimp/ZipArchiveIOSystem.h>
-
-#include <assimp/ai_assert.h>
-
-#include <map>
-#include <memory>
-
-#ifdef ASSIMP_USE_HUNTER
-#    include <minizip/unzip.h>
-#else
-#    include <unzip.h>
-#endif
-
-namespace Assimp {
-
-// ----------------------------------------------------------------
-// A read-only file inside a ZIP
-
-class ZipFile : public IOStream {
-    friend class ZipFileInfo;
-    explicit ZipFile(std::string &filename, size_t size);
-
-public:
-    std::string m_Filename;
-    virtual ~ZipFile();
-
-    // IOStream interface
-    size_t Read(void *pvBuffer, size_t pSize, size_t pCount) override;
-    size_t Write(const void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override { return 0; }
-    size_t FileSize() const override;
-    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override;
-    size_t Tell() const override;
-    void Flush() override {}
-
-private:
-    size_t m_Size = 0;
-    size_t m_SeekPtr = 0;
-    std::unique_ptr<uint8_t[]> m_Buffer;
-};
-
-
-// ----------------------------------------------------------------
-// Wraps an existing Assimp::IOSystem for unzip
-class IOSystem2Unzip {
-public:
-    static voidpf open(voidpf opaque, const char *filename, int mode);
-    static voidpf opendisk(voidpf opaque, voidpf stream, uint32_t number_disk, int mode);
-    static uLong read(voidpf opaque, voidpf stream, void *buf, uLong size);
-    static uLong write(voidpf opaque, voidpf stream, const void *buf, uLong size);
-    static long tell(voidpf opaque, voidpf stream);
-    static long seek(voidpf opaque, voidpf stream, uLong offset, int origin);
-    static int close(voidpf opaque, voidpf stream);
-    static int testerror(voidpf opaque, voidpf stream);
-    static zlib_filefunc_def get(IOSystem *pIOHandler);
-};
-
-voidpf IOSystem2Unzip::open(voidpf opaque, const char *filename, int mode) {
-    IOSystem *io_system = reinterpret_cast<IOSystem *>(opaque);
-
-    const char *mode_fopen = nullptr;
-    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) {
-        mode_fopen = "rb";
-    } else {
-        if (mode & ZLIB_FILEFUNC_MODE_EXISTING) {
-            mode_fopen = "r+b";
-        } else {
-            if (mode & ZLIB_FILEFUNC_MODE_CREATE) {
-                mode_fopen = "wb";
-            }
-        }
-    }
-
-    return (voidpf)io_system->Open(filename, mode_fopen);
-}
-
-voidpf IOSystem2Unzip::opendisk(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) {
-    ZipFile *io_stream = (ZipFile *)stream;
-    voidpf ret = NULL;
-    size_t i;
-
-    char *disk_filename = (char*)malloc(io_stream->m_Filename.length() + 1);
-    strncpy(disk_filename, io_stream->m_Filename.c_str(), io_stream->m_Filename.length() + 1);
-    for (i = io_stream->m_Filename.length() - 1; i >= 0; i -= 1)
-    {
-        if (disk_filename[i] != '.')
-            continue;
-        snprintf(&disk_filename[i], io_stream->m_Filename.length() - i, ".z%02u", number_disk + 1);
-        break;
-    }
-
-    if (i >= 0)
-        ret = open(opaque, disk_filename, mode);
-
-    free(disk_filename);
-    return ret;
-}
-
-uLong IOSystem2Unzip::read(voidpf /*opaque*/, voidpf stream, void *buf, uLong size) {
-    IOStream *io_stream = (IOStream *)stream;
-
-    return static_cast<uLong>(io_stream->Read(buf, 1, size));
-}
-
-uLong IOSystem2Unzip::write(voidpf /*opaque*/, voidpf stream, const void *buf, uLong size) {
-    IOStream *io_stream = (IOStream *)stream;
-
-    return static_cast<uLong>(io_stream->Write(buf, 1, size));
-}
-
-long IOSystem2Unzip::tell(voidpf /*opaque*/, voidpf stream) {
-    IOStream *io_stream = (IOStream *)stream;
-
-    return static_cast<long>(io_stream->Tell());
-}
-
-long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {
-    IOStream *io_stream = (IOStream *)stream;
-
-    aiOrigin assimp_origin;
-    switch (origin) {
-        default:
-        case ZLIB_FILEFUNC_SEEK_CUR:
-            assimp_origin = aiOrigin_CUR;
-            break;
-        case ZLIB_FILEFUNC_SEEK_END:
-            assimp_origin = aiOrigin_END;
-            break;
-        case ZLIB_FILEFUNC_SEEK_SET:
-            assimp_origin = aiOrigin_SET;
-            break;
-    }
-
-    return (io_stream->Seek(offset, assimp_origin) == aiReturn_SUCCESS ? 0 : -1);
-}
-
-int IOSystem2Unzip::close(voidpf opaque, voidpf stream) {
-    IOSystem *io_system = (IOSystem *)opaque;
-    IOStream *io_stream = (IOStream *)stream;
-
-    io_system->Close(io_stream);
-
-    return 0;
-}
-
-int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) {
-    return 0;
-}
-
-zlib_filefunc_def IOSystem2Unzip::get(IOSystem *pIOHandler) {
-    zlib_filefunc_def mapping;
-
-    mapping.zopen_file = (open_file_func)open;
-    mapping.zopendisk_file = (opendisk_file_func)opendisk;
-    mapping.zread_file = (read_file_func)read;
-    mapping.zwrite_file = (write_file_func)write;
-    mapping.ztell_file = (tell_file_func)tell;
-    mapping.zseek_file = (seek_file_func)seek;
-    mapping.zclose_file = (close_file_func)close;
-    mapping.zerror_file = testerror;
-
-    mapping.opaque = reinterpret_cast<voidpf>(pIOHandler);
-
-    return mapping;
-}
-
-// ----------------------------------------------------------------
-// Info about a read-only file inside a ZIP
-class ZipFileInfo {
-public:
-    explicit ZipFileInfo(unzFile zip_handle, size_t size);
-
-    // Allocate and Extract data from the ZIP
-    ZipFile *Extract(std::string &filename, unzFile zip_handle) const;
-
-private:
-    size_t m_Size = 0;
-    unz_file_pos_s m_ZipFilePos;
-};
-
-ZipFileInfo::ZipFileInfo(unzFile zip_handle, size_t size) :
-        m_Size(size) {
-    ai_assert(m_Size != 0);
-    // Workaround for MSVC 2013 - C2797
-    m_ZipFilePos.num_of_file = 0;
-    m_ZipFilePos.pos_in_zip_directory = 0;
-    unzGetFilePos(zip_handle, &(m_ZipFilePos));
-}
-
-ZipFile *ZipFileInfo::Extract(std::string &filename, unzFile zip_handle) const {
-    // Find in the ZIP. This cannot fail
-    unz_file_pos_s *filepos = const_cast<unz_file_pos_s *>(&(m_ZipFilePos));
-    if (unzGoToFilePos(zip_handle, filepos) != UNZ_OK)
-        return nullptr;
-
-    if (unzOpenCurrentFile(zip_handle) != UNZ_OK)
-        return nullptr;
-
-    ZipFile *zip_file = new ZipFile(filename, m_Size);
-
-    // Unzip has a limit of UINT16_MAX bytes buffer
-    uint16_t unzipBufferSize = zip_file->m_Size <= UINT16_MAX ? static_cast<uint16_t>(zip_file->m_Size) : UINT16_MAX;
-    std::unique_ptr<uint8_t[]> unzipBuffer = std::unique_ptr<uint8_t[]>(new uint8_t[unzipBufferSize]);
-    size_t readCount = 0;
-    while (readCount < zip_file->m_Size)
-    {
-        size_t bufferSize = zip_file->m_Size - readCount;
-        if (bufferSize > UINT16_MAX) {
-            bufferSize = UINT16_MAX;
-        }
-
-        int ret = unzReadCurrentFile(zip_handle, unzipBuffer.get(), static_cast<unsigned int>(bufferSize));
-        if (ret != static_cast<int>(bufferSize))
-        {
-            // Failed, release the memory
-            delete zip_file;
-            zip_file = nullptr;
-            break;
-        }
-
-        std::memcpy(zip_file->m_Buffer.get() + readCount, unzipBuffer.get(), ret);
-        readCount += ret;
-    }
-
-    ai_assert(unzCloseCurrentFile(zip_handle) == UNZ_OK);
-    return zip_file;
-}
-
-ZipFile::ZipFile(std::string &filename, size_t size) :
-        m_Filename(filename), m_Size(size) {
-    ai_assert(m_Size != 0);
-    m_Buffer = std::unique_ptr<uint8_t[]>(new uint8_t[m_Size]);
-}
-
-ZipFile::~ZipFile() {
-}
-
-size_t ZipFile::Read(void *pvBuffer, size_t pSize, size_t pCount) {
-    // Should be impossible
-    ai_assert(m_Buffer != nullptr);
-    ai_assert(nullptr != pvBuffer);
-    ai_assert(0 != pSize);
-    ai_assert(0 != pCount);
-
-    // Clip down to file size
-    size_t byteSize = pSize * pCount;
-    if ((byteSize + m_SeekPtr) > m_Size) {
-        pCount = (m_Size - m_SeekPtr) / pSize;
-        byteSize = pSize * pCount;
-        if (byteSize == 0) {
-            return 0;
-        }
-    }
-
-    std::memcpy(pvBuffer, m_Buffer.get() + m_SeekPtr, byteSize);
-
-    m_SeekPtr += byteSize;
-
-    return pCount;
-}
-
-size_t ZipFile::FileSize() const {
-    return m_Size;
-}
-
-aiReturn ZipFile::Seek(size_t pOffset, aiOrigin pOrigin) {
-    switch (pOrigin) {
-        case aiOrigin_SET: {
-            if (pOffset > m_Size) return aiReturn_FAILURE;
-            m_SeekPtr = pOffset;
-            return aiReturn_SUCCESS;
-        }
-
-        case aiOrigin_CUR: {
-            if ((pOffset + m_SeekPtr) > m_Size) return aiReturn_FAILURE;
-            m_SeekPtr += pOffset;
-            return aiReturn_SUCCESS;
-        }
-
-        case aiOrigin_END: {
-            if (pOffset > m_Size) return aiReturn_FAILURE;
-            m_SeekPtr = m_Size - pOffset;
-            return aiReturn_SUCCESS;
-        }
-        default:;
-    }
-
-    return aiReturn_FAILURE;
-}
-
-size_t ZipFile::Tell() const {
-    return m_SeekPtr;
-}
-
-// ----------------------------------------------------------------
-// pImpl of the Zip Archive IO
-class ZipArchiveIOSystem::Implement {
-public:
-    static const unsigned int FileNameSize = 256;
-
-    Implement(IOSystem *pIOHandler, const char *pFilename, const char *pMode);
-    ~Implement();
-
-    bool isOpen() const;
-    void getFileList(std::vector<std::string> &rFileList);
-    void getFileListExtension(std::vector<std::string> &rFileList, const std::string &extension);
-    bool Exists(std::string &filename);
-    IOStream *OpenFile(std::string &filename);
-
-    static void SimplifyFilename(std::string &filename);
-
-private:
-    void MapArchive();
-
-private:
-    typedef std::map<std::string, ZipFileInfo> ZipFileInfoMap;
-
-    unzFile m_ZipFileHandle = nullptr;
-    ZipFileInfoMap m_ArchiveMap;
-};
-
-ZipArchiveIOSystem::Implement::Implement(IOSystem *pIOHandler, const char *pFilename, const char *pMode) {
-    ai_assert(strcmp(pMode, "r") == 0);
-    ai_assert(pFilename != nullptr);
-    if (pFilename[0] == 0 || nullptr == pMode) {
-        return;
-    }
-
-    zlib_filefunc_def mapping = IOSystem2Unzip::get(pIOHandler);
-    m_ZipFileHandle = unzOpen2(pFilename, &mapping);
-}
-
-ZipArchiveIOSystem::Implement::~Implement() {
-    if (m_ZipFileHandle != nullptr) {
-        unzClose(m_ZipFileHandle);
-    }
-}
-
-void ZipArchiveIOSystem::Implement::MapArchive() {
-    if (m_ZipFileHandle == nullptr)
-        return;
-
-    if (!m_ArchiveMap.empty())
-        return;
-
-    //  At first ensure file is already open
-    if (unzGoToFirstFile(m_ZipFileHandle) != UNZ_OK)
-        return;
-
-    // Loop over all files
-    do {
-        char filename[FileNameSize];
-        unz_file_info fileInfo;
-
-        if (unzGetCurrentFileInfo(m_ZipFileHandle, &fileInfo, filename, FileNameSize, nullptr, 0, nullptr, 0) == UNZ_OK) {
-            if (fileInfo.uncompressed_size != 0 && fileInfo.size_filename <= FileNameSize) {
-                std::string filename_string(filename, fileInfo.size_filename);
-                SimplifyFilename(filename_string);
-                m_ArchiveMap.emplace(filename_string, ZipFileInfo(m_ZipFileHandle, fileInfo.uncompressed_size));
-            }
-        }
-    } while (unzGoToNextFile(m_ZipFileHandle) != UNZ_END_OF_LIST_OF_FILE);
-}
-
-bool ZipArchiveIOSystem::Implement::isOpen() const {
-    return (m_ZipFileHandle != nullptr);
-}
-
-void ZipArchiveIOSystem::Implement::getFileList(std::vector<std::string> &rFileList) {
-    MapArchive();
-    rFileList.clear();
-
-    for (const auto &file : m_ArchiveMap) {
-        rFileList.push_back(file.first);
-    }
-}
-
-void ZipArchiveIOSystem::Implement::getFileListExtension(std::vector<std::string> &rFileList, const std::string &extension) {
-    MapArchive();
-    rFileList.clear();
-
-    for (const auto &file : m_ArchiveMap) {
-        if (extension == BaseImporter::GetExtension(file.first))
-            rFileList.push_back(file.first);
-    }
-}
-
-bool ZipArchiveIOSystem::Implement::Exists(std::string &filename) {
-    MapArchive();
-
-    ZipFileInfoMap::const_iterator it = m_ArchiveMap.find(filename);
-    return (it != m_ArchiveMap.end());
-}
-
-IOStream *ZipArchiveIOSystem::Implement::OpenFile(std::string &filename) {
-    MapArchive();
-
-    SimplifyFilename(filename);
-
-    // Find in the map
-    ZipFileInfoMap::const_iterator zip_it = m_ArchiveMap.find(filename);
-    if (zip_it == m_ArchiveMap.cend())
-        return nullptr;
-
-    const ZipFileInfo &zip_file = (*zip_it).second;
-    return zip_file.Extract(filename, m_ZipFileHandle);
-}
-
-inline void ReplaceAll(std::string &data, const std::string &before, const std::string &after) {
-    size_t pos = data.find(before);
-    while (pos != std::string::npos) {
-        data.replace(pos, before.size(), after);
-        pos = data.find(before, pos + after.size());
-    }
-}
-
-inline void ReplaceAllChar(std::string &data, const char before, const char after) {
-    size_t pos = data.find(before);
-    while (pos != std::string::npos) {
-        data[pos] = after;
-        pos = data.find(before, pos + 1);
-    }
-}
-
-void ZipArchiveIOSystem::Implement::SimplifyFilename(std::string &filename) {
-    ReplaceAllChar(filename, '\\', '/');
-
-    // Remove all . and / from the beginning of the path
-    size_t pos = filename.find_first_not_of("./");
-    if (pos != 0)
-        filename.erase(0, pos);
-
-    // Simplify "my/folder/../file.png" constructions, if any
-    static const std::string relative("/../");
-    const size_t relsize = relative.size() - 1;
-    pos = filename.find(relative);
-    while (pos != std::string::npos) {
-        // Previous slash
-        size_t prevpos = filename.rfind('/', pos - 1);
-        if (prevpos == pos)
-            filename.erase(0, pos + relative.size());
-        else
-            filename.erase(prevpos, pos + relsize - prevpos);
-
-        pos = filename.find(relative);
-    }
-}
-
-ZipArchiveIOSystem::ZipArchiveIOSystem(IOSystem *pIOHandler, const char *pFilename, const char *pMode) :
-        pImpl(new Implement(pIOHandler, pFilename, pMode)) {
-}
-
-// ----------------------------------------------------------------
-// The ZipArchiveIO
-ZipArchiveIOSystem::ZipArchiveIOSystem(IOSystem *pIOHandler, const std::string &rFilename, const char *pMode) :
-        pImpl(new Implement(pIOHandler, rFilename.c_str(), pMode)) {
-}
-
-ZipArchiveIOSystem::~ZipArchiveIOSystem() {
-    delete pImpl;
-}
-
-bool ZipArchiveIOSystem::Exists(const char *pFilename) const {
-    ai_assert(pFilename != nullptr);
-
-    if (pFilename == nullptr) {
-        return false;
-    }
-
-    std::string filename(pFilename);
-    return pImpl->Exists(filename);
-}
-
-// This is always '/' in a ZIP
-char ZipArchiveIOSystem::getOsSeparator() const {
-    return '/';
-}
-
-// Only supports Reading
-IOStream *ZipArchiveIOSystem::Open(const char *pFilename, const char *pMode) {
-    ai_assert(pFilename != nullptr);
-
-    for (size_t i = 0; pMode[i] != 0; ++i) {
-        ai_assert(pMode[i] != 'w');
-        if (pMode[i] == 'w')
-            return nullptr;
-    }
-
-    std::string filename(pFilename);
-    return pImpl->OpenFile(filename);
-}
-
-void ZipArchiveIOSystem::Close(IOStream *pFile) {
-    delete pFile;
-}
-
-bool ZipArchiveIOSystem::isOpen() const {
-    return (pImpl->isOpen());
-}
-
-void ZipArchiveIOSystem::getFileList(std::vector<std::string> &rFileList) const {
-    return pImpl->getFileList(rFileList);
-}
-
-void ZipArchiveIOSystem::getFileListExtension(std::vector<std::string> &rFileList, const std::string &extension) const {
-    return pImpl->getFileListExtension(rFileList, extension);
-}
-
-bool ZipArchiveIOSystem::isZipArchive(IOSystem *pIOHandler, const char *pFilename) {
-    Implement tmp(pIOHandler, pFilename, "r");
-    return tmp.isOpen();
-}
-
-bool ZipArchiveIOSystem::isZipArchive(IOSystem *pIOHandler, const std::string &rFilename) {
-    return isZipArchive(pIOHandler, rFilename.c_str());
-}
-
-} // namespace Assimp
diff --git a/libs/assimp/code/Common/assbin_chunks.h b/libs/assimp/code/Common/assbin_chunks.h
deleted file mode 100644
index 822df51..0000000
--- a/libs/assimp/code/Common/assbin_chunks.h
+++ /dev/null
@@ -1,196 +0,0 @@
-#ifndef INCLUDED_ASSBIN_CHUNKS_H
-#define INCLUDED_ASSBIN_CHUNKS_H
-
-#define ASSBIN_VERSION_MAJOR 1
-#define ASSBIN_VERSION_MINOR 0
-
-/**
-@page assfile .ASS File formats
-
-@section over Overview
-Assimp provides its own interchange format, which is intended to applications which need
-to serialize 3D-models and to reload them quickly. Assimp's file formats are designed to
-be read by Assimp itself. They encode additional information needed by Assimp to optimize
-its postprocessing pipeline. If you once apply specific steps to a scene, then save it
-and reread it from an ASS format using the same post processing settings, they won't
-be executed again.
-
-The format comes in two flavours: XML and binary - both of them hold a complete dump of
-the 'aiScene' data structure returned by the APIs. The focus for the binary format
-(<tt>.assbin</tt>) is fast loading. Optional deflate compression helps reduce file size. The XML
-flavour, <tt>.assxml</tt> or simply .xml, is just a plain-to-xml conversion of aiScene.
-
-ASSBIN is Assimp's binary interchange format. assimp_cmd (<tt>&lt;root&gt;/tools/assimp_cmd</tt>) is able to
-write it and the core library provides a loader for it.
-
-@section assxml XML File format
-
-The format is pretty much self-explanatory due to its similarity to the in-memory aiScene structure.
-With few exceptions, C structures are wrapped in XML elements.
-
-The DTD for ASSXML can be found in <tt>&lt;root&gt;/doc/AssXML_Scheme.xml</tt>. Or have   look
-at the output files generated by assimp_cmd.
-
-@section assbin Binary file format
-
-The ASSBIN file format is composed of chunks to represent the hierarchical aiScene data structure.
-This makes the format extensible and allows backward-compatibility with future data structure
-versions. The <tt>&lt;root&gt;/code/assbin_chunks.h</tt> header contains some magic constants
-for use by stand-alone ASSBIN loaders. Also, Assimp's own file writer can be found
-in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDump.cpp</tt> (yes, the 'b' is no typo ...).
-
-@verbatim
-
--------------------------------------------------------------------------------
-1. File structure:
--------------------------------------------------------------------------------
-
-----------------------
-| Header (512 bytes) |
-----------------------
-| Variable chunks    |
-----------------------
-
--------------------------------------------------------------------------------
-2. Definitions:
--------------------------------------------------------------------------------
-
-integer is four bytes wide, stored in little-endian byte order.
-short   is two bytes wide, stored in little-endian byte order.
-byte    is a single byte.
-string  is an integer n followed by n UTF-8 characters, not terminated by zero
-float   is an IEEE 754 single-precision floating-point value
-double  is an IEEE 754 double-precision floating-point value
-t[n]    is an array of n elements of type t
-
--------------------------------------------------------------------------------
-2. Header:
--------------------------------------------------------------------------------
-
-byte[44]    Magic identification string for ASSBIN files.
-                'ASSIMP.binary'
-
-integer     Major version of the Assimp library which wrote the file
-integer     Minor version of the Assimp library which wrote the file
-                match these against ASSBIN_VERSION_MAJOR and ASSBIN_VERSION_MINOR
-
-integer     SVN revision of the Assimp library (intended for our internal
-            debugging - if you write Ass files from your own APPs, set this value to 0.
-integer     Assimp compile flags
-
-short       0 for normal files, 1 for shortened dumps for regression tests
-                these should have the file extension assbin.regress
-
-short       1 if the data after the header is compressed with the DEFLATE algorithm,
-            0 for uncompressed files.
-                   For compressed files, the first integer after the header is
-                   always the uncompressed data size
-
-byte[256]   Zero-terminated source file name, UTF-8
-byte[128]   Zero-terminated command line parameters passed to assimp_cmd, UTF-8
-
-byte[64]    Reserved for future use
----> Total length: 512 bytes
-
--------------------------------------------------------------------------------
-3. Chunks:
--------------------------------------------------------------------------------
-
-integer     Magic chunk ID (ASSBIN_CHUNK_XXX)
-integer     Chunk data length, in bytes
-                (unknown chunks are possible, a good reader skips over them)
-                (chunk-data-length does not include the first two integers)
-
-byte[n]     chunk-data-length bytes of data, depending on the chunk type
-
-Chunks can contain nested chunks. Nested chunks are ALWAYS at the end of the chunk,
-their size is included in chunk-data-length.
-
-The chunk layout for all ASSIMP data structures is derived from their C declarations.
-The general 'rule' to get from Assimp headers to the serialized layout is:
-
-   1. POD members (i.e. aiMesh::mPrimitiveTypes, aiMesh::mNumVertices),
-        in order of declaration.
-
-   2. Array-members (aiMesh::mFaces, aiMesh::mVertices, aiBone::mWeights),
-        in order of declaration.
-
-   2. Object array members (i.e aiMesh::mBones, aiScene::mMeshes) are stored in
-      subchunks directly following the data written in 1.) and 2.)
-
-
-    Of course, there are some exceptions to this general order:
-
-[[aiScene]]
-
-   - The root node holding the scene structure is naturally stored in
-     a ASSBIN_CHUNK_AINODE subchunk following 1.) and 2.) (which is
-     empty for aiScene).
-
-[[aiMesh]]
-
-   - mTextureCoords and mNumUVComponents are serialized as follows:
-
-   [number of used uv channels times]
-       integer mNumUVComponents[n]
-       float mTextureCoords[n][3]
-
-       -> more than AI_MAX_TEXCOORD_CHANNELS can be stored. This allows Assimp
-       builds with different settings for AI_MAX_TEXCOORD_CHANNELS to exchange
-       data.
-       -> the on-disk format always uses 3 floats to write UV coordinates.
-       If mNumUVComponents[0] is 1, the corresponding mTextureCoords array
-       consists of 3 floats.
-
-   - The array member block of aiMesh is prefixed with an integer that specifies
-     the kinds of vertex components actually present in the mesh. This is a
-     bitwise combination of the ASSBIN_MESH_HAS_xxx constants.
-
-[[aiFace]]
-
-   - mNumIndices is stored as short
-   - mIndices are written as short, if aiMesh::mNumVertices<65536
-
-[[aiNode]]
-
-   - mParent is omitted
-
-[[aiLight]]
-
-   - mAttenuationXXX not written if aiLight::mType == aiLightSource_DIRECTIONAL
-   - mAngleXXX not written if aiLight::mType != aiLightSource_SPOT
-
-[[aiMaterial]]
-
-   - mNumAllocated is omitted, for obvious reasons :-)
-
-
- @endverbatim*/
-
-
-#define ASSBIN_HEADER_LENGTH 512
-
-// these are the magic chunk identifiers for the binary ASS file format
-#define ASSBIN_CHUNK_AICAMERA                   0x1234
-#define ASSBIN_CHUNK_AILIGHT                    0x1235
-#define ASSBIN_CHUNK_AITEXTURE                  0x1236
-#define ASSBIN_CHUNK_AIMESH                     0x1237
-#define ASSBIN_CHUNK_AINODEANIM                 0x1238
-#define ASSBIN_CHUNK_AISCENE                    0x1239
-#define ASSBIN_CHUNK_AIBONE                     0x123a
-#define ASSBIN_CHUNK_AIANIMATION                0x123b
-#define ASSBIN_CHUNK_AINODE                     0x123c
-#define ASSBIN_CHUNK_AIMATERIAL                 0x123d
-#define ASSBIN_CHUNK_AIMATERIALPROPERTY         0x123e
-
-#define ASSBIN_MESH_HAS_POSITIONS                   0x1
-#define ASSBIN_MESH_HAS_NORMALS                     0x2
-#define ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS     0x4
-#define ASSBIN_MESH_HAS_TEXCOORD_BASE               0x100
-#define ASSBIN_MESH_HAS_COLOR_BASE                  0x10000
-
-#define ASSBIN_MESH_HAS_TEXCOORD(n) (ASSBIN_MESH_HAS_TEXCOORD_BASE << n)
-#define ASSBIN_MESH_HAS_COLOR(n)    (ASSBIN_MESH_HAS_COLOR_BASE << n)
-
-
-#endif // INCLUDED_ASSBIN_CHUNKS_H
diff --git a/libs/assimp/code/Common/material.cpp b/libs/assimp/code/Common/material.cpp
deleted file mode 100644
index a7541d4..0000000
--- a/libs/assimp/code/Common/material.cpp
+++ /dev/null
@@ -1,100 +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.
-
-----------------------------------------------------------------------
-*/
-
-/// @file material.cpp
-/** Implement common material related functions. */
-
-#include <assimp/ai_assert.h>
-#include <assimp/material.h>
-
-// -------------------------------------------------------------------------------
-const char *TextureTypeToString(aiTextureType in) {
-    switch (in) {
-    case aiTextureType_NONE:
-        return "n/a";
-    case aiTextureType_DIFFUSE:
-        return "Diffuse";
-    case aiTextureType_SPECULAR:
-        return "Specular";
-    case aiTextureType_AMBIENT:
-        return "Ambient";
-    case aiTextureType_EMISSIVE:
-        return "Emissive";
-    case aiTextureType_OPACITY:
-        return "Opacity";
-    case aiTextureType_NORMALS:
-        return "Normals";
-    case aiTextureType_HEIGHT:
-        return "Height";
-    case aiTextureType_SHININESS:
-        return "Shininess";
-    case aiTextureType_DISPLACEMENT:
-        return "Displacement";
-    case aiTextureType_LIGHTMAP:
-        return "Lightmap";
-    case aiTextureType_REFLECTION:
-        return "Reflection";
-    case aiTextureType_BASE_COLOR:
-        return "BaseColor";
-    case aiTextureType_NORMAL_CAMERA:
-        return "NormalCamera";
-    case aiTextureType_EMISSION_COLOR:
-        return "EmissionColor";
-    case aiTextureType_METALNESS:
-        return "Metalness";
-    case aiTextureType_DIFFUSE_ROUGHNESS:
-        return "DiffuseRoughness";
-    case aiTextureType_AMBIENT_OCCLUSION:
-        return "AmbientOcclusion";
-    case aiTextureType_SHEEN:
-        return "Sheen";
-    case aiTextureType_CLEARCOAT:
-        return "Clearcoat";
-    case aiTextureType_TRANSMISSION:
-        return "Transmission";
-    case aiTextureType_UNKNOWN:
-        return "Unknown";
-    default:
-        break;
-    }
-    ai_assert(false);
-    return "BUG";
-}
diff --git a/libs/assimp/code/Common/scene.cpp b/libs/assimp/code/Common/scene.cpp
deleted file mode 100644
index b0e8821..0000000
--- a/libs/assimp/code/Common/scene.cpp
+++ /dev/null
@@ -1,135 +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 <assimp/scene.h>
-
-aiNode::aiNode() :
-        mName(""),
-        mParent(nullptr),
-        mNumChildren(0),
-        mChildren(nullptr),
-        mNumMeshes(0),
-        mMeshes(nullptr),
-        mMetaData(nullptr) {
-    // empty
-}
-
-aiNode::aiNode(const std::string &name) :
-        mName(name),
-        mParent(nullptr),
-        mNumChildren(0),
-        mChildren(nullptr),
-        mNumMeshes(0),
-        mMeshes(nullptr),
-        mMetaData(nullptr) {
-    // empty
-}
-
-/** Destructor */
-aiNode::~aiNode() {
-    // delete all children recursively
-    // to make sure we won't crash if the data is invalid ...
-    if (mNumChildren && mChildren) {
-        for (unsigned int a = 0; a < mNumChildren; a++)
-            delete mChildren[a];
-    }
-    delete[] mChildren;
-    delete[] mMeshes;
-    delete mMetaData;
-}
-
-const aiNode *aiNode::FindNode(const char *name) const {
-    if (nullptr == name) {
-        return nullptr;
-    }
-    if (!::strcmp(mName.data, name)) {
-        return this;
-    }
-    for (unsigned int i = 0; i < mNumChildren; ++i) {
-        const aiNode *const p = mChildren[i]->FindNode(name);
-        if (p) {
-            return p;
-        }
-    }
-    // there is definitely no sub-node with this name
-    return nullptr;
-}
-
-aiNode *aiNode::FindNode(const char *name) {
-    if (!::strcmp(mName.data, name)) return this;
-    for (unsigned int i = 0; i < mNumChildren; ++i) {
-        aiNode *const p = mChildren[i]->FindNode(name);
-        if (p) {
-            return p;
-        }
-    }
-    // there is definitely no sub-node with this name
-    return nullptr;
-}
-
-void aiNode::addChildren(unsigned int numChildren, aiNode **children) {
-    if (nullptr == children || 0 == numChildren) {
-        return;
-    }
-
-    for (unsigned int i = 0; i < numChildren; i++) {
-        aiNode *child = children[i];
-        if (nullptr != child) {
-            child->mParent = this;
-        }
-    }
-
-    if (mNumChildren > 0) {
-        aiNode **tmp = new aiNode *[mNumChildren];
-        ::memcpy(tmp, mChildren, sizeof(aiNode *) * mNumChildren);
-        delete[] mChildren;
-        mChildren = new aiNode *[mNumChildren + numChildren];
-        ::memcpy(mChildren, tmp, sizeof(aiNode *) * mNumChildren);
-        ::memcpy(&mChildren[mNumChildren], children, sizeof(aiNode *) * numChildren);
-        mNumChildren += numChildren;
-        delete[] tmp;
-    } else {
-        mChildren = new aiNode *[numChildren];
-        for (unsigned int i = 0; i < numChildren; i++) {
-            mChildren[i] = children[i];
-        }
-        mNumChildren = numChildren;
-    }
-}
diff --git a/libs/assimp/code/Common/simd.cpp b/libs/assimp/code/Common/simd.cpp
deleted file mode 100644
index 0dd437d..0000000
--- a/libs/assimp/code/Common/simd.cpp
+++ /dev/null
@@ -1,77 +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 "simd.h"
-
-namespace Assimp {
-
-bool CPUSupportsSSE2() {
-#if defined(__x86_64__) || defined(_M_X64)
-    //* x86_64 always has SSE2 instructions */
-    return true;
-#elif defined(__GNUC__) && defined(i386)
-    // for GCC x86 we check cpuid
-    unsigned int d;
-    __asm__(
-        "pushl %%ebx\n\t"
-        "cpuid\n\t"
-        "popl %%ebx\n\t"
-        : "=d" ( d )
-        :"a" ( 1 ) );
-    return ( d & 0x04000000 ) != 0;
-#elif (defined(_MSC_VER) && defined(_M_IX86))
-    // also check cpuid for MSVC x86
-    unsigned int d;
-    __asm {
-        xor     eax, eax
-        inc eax
-        push ebx
-        cpuid
-        pop ebx
-        mov d, edx
-    }
-    return ( d & 0x04000000 ) != 0;
-#else
-    return false;
-#endif
-}
-
-
-} // Namespace Assimp
diff --git a/libs/assimp/code/Common/simd.h b/libs/assimp/code/Common/simd.h
deleted file mode 100644
index 0a062a2..0000000
--- a/libs/assimp/code/Common/simd.h
+++ /dev/null
@@ -1,53 +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
-
-#include <assimp/defs.h>
-
-namespace Assimp {
-
-/// @brief  Checks if the platform supports SSE2 optimization
-/// @return true, if SSE2 is supported. false if SSE2 is not supported.
-bool ASSIMP_API CPUSupportsSSE2();
-
-} // Namespace Assimp