summaryrefslogtreecommitdiff
path: root/libs/assimp/code/Common
diff options
context:
space:
mode:
Diffstat (limited to 'libs/assimp/code/Common')
-rw-r--r--libs/assimp/code/Common/AssertHandler.cpp72
-rw-r--r--libs/assimp/code/Common/AssertHandler.h75
-rw-r--r--libs/assimp/code/Common/Assimp.cpp1299
-rw-r--r--libs/assimp/code/Common/Base64.cpp179
-rw-r--r--libs/assimp/code/Common/BaseImporter.cpp620
-rw-r--r--libs/assimp/code/Common/BaseProcess.cpp100
-rw-r--r--libs/assimp/code/Common/BaseProcess.h251
-rw-r--r--libs/assimp/code/Common/Bitmap.cpp156
-rw-r--r--libs/assimp/code/Common/Compression.cpp214
-rw-r--r--libs/assimp/code/Common/Compression.h121
-rw-r--r--libs/assimp/code/Common/CreateAnimMesh.cpp92
-rw-r--r--libs/assimp/code/Common/DefaultIOStream.cpp180
-rw-r--r--libs/assimp/code/Common/DefaultIOSystem.cpp223
-rw-r--r--libs/assimp/code/Common/DefaultLogger.cpp430
-rw-r--r--libs/assimp/code/Common/DefaultProgressHandler.h66
-rw-r--r--libs/assimp/code/Common/Exceptional.cpp52
-rw-r--r--libs/assimp/code/Common/Exporter.cpp695
-rw-r--r--libs/assimp/code/Common/FileLogStream.h100
-rw-r--r--libs/assimp/code/Common/FileSystemFilter.h346
-rw-r--r--libs/assimp/code/Common/IFF.h102
-rw-r--r--libs/assimp/code/Common/IOSystem.cpp53
-rw-r--r--libs/assimp/code/Common/Importer.cpp1287
-rw-r--r--libs/assimp/code/Common/Importer.h250
-rw-r--r--libs/assimp/code/Common/ImporterRegistry.cpp393
-rw-r--r--libs/assimp/code/Common/PolyTools.h226
-rw-r--r--libs/assimp/code/Common/PostStepRegistry.cpp265
-rw-r--r--libs/assimp/code/Common/RemoveComments.cpp121
-rw-r--r--libs/assimp/code/Common/SGSpatialSort.cpp168
-rw-r--r--libs/assimp/code/Common/SceneCombiner.cpp1375
-rw-r--r--libs/assimp/code/Common/ScenePreprocessor.cpp285
-rw-r--r--libs/assimp/code/Common/ScenePreprocessor.h118
-rw-r--r--libs/assimp/code/Common/ScenePrivate.h105
-rw-r--r--libs/assimp/code/Common/SkeletonMeshBuilder.cpp262
-rw-r--r--libs/assimp/code/Common/SpatialSort.cpp344
-rw-r--r--libs/assimp/code/Common/StandardShapes.cpp479
-rw-r--r--libs/assimp/code/Common/StdOStreamLogStream.h101
-rw-r--r--libs/assimp/code/Common/Subdivision.cpp581
-rw-r--r--libs/assimp/code/Common/TargetAnimation.cpp226
-rw-r--r--libs/assimp/code/Common/TargetAnimation.h161
-rw-r--r--libs/assimp/code/Common/Version.cpp186
-rw-r--r--libs/assimp/code/Common/VertexTriangleAdjacency.cpp131
-rw-r--r--libs/assimp/code/Common/VertexTriangleAdjacency.h117
-rw-r--r--libs/assimp/code/Common/Win32DebugLogStream.h95
-rw-r--r--libs/assimp/code/Common/ZipArchiveIOSystem.cpp563
-rw-r--r--libs/assimp/code/Common/assbin_chunks.h196
-rw-r--r--libs/assimp/code/Common/material.cpp100
-rw-r--r--libs/assimp/code/Common/scene.cpp135
-rw-r--r--libs/assimp/code/Common/simd.cpp77
-rw-r--r--libs/assimp/code/Common/simd.h53
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