Update USDLoader.h

Fix review finding,
Update USDLoader.cpp
2024-07-18 21:06:03 +02:00 · 2024-07-18 21:05:02 +02:00 · 2024-07-18 19:11:58 +02:00
70 changed files with 561 additions and 1456 deletions
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@ -7,10 +7,10 @@ on:
    branches: [ master ]

 permissions:
-  contents: write # to fetch code (actions/checkout),and release
+  contents: read # to fetch code (actions/checkout)

 jobs:
-  build:
+  job:
    name: ${{ matrix.name }}-build-and-test
    runs-on: ${{ matrix.os }}
    strategy:
@ -37,9 +37,6 @@ jobs:
            cc: gcc

    steps:
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2
-      
    - uses: actions/checkout@v4
      with:
          submodules: true
@ -73,12 +70,12 @@ jobs:
    - name: Set Windows specific CMake arguments
      if: contains(matrix.name, 'windows')
      id: windows_extra_cmake_args
-      run: echo ":set-output name=args::=-DASSIMP_BUILD_ASSIMP_TOOLS=1 -DASSIMP_BUILD_ASSIMP_VIEW=1" >> $GITHUB_OUTPUT
+      run: echo "::set-output name=args::-DASSIMP_BUILD_ASSIMP_TOOLS=1 -DASSIMP_BUILD_ASSIMP_VIEW=1 -DASSIMP_BUILD_ZLIB=1"
    
    - name: Set Hunter specific CMake arguments
      if: contains(matrix.name, 'hunter')
      id: hunter_extra_cmake_args
-      run: echo "args=-DBUILD_SHARED_LIBS=OFF -DASSIMP_HUNTER_ENABLED=ON -DCMAKE_TOOLCHAIN_FILE=${{ github.workspace }}/cmake/polly/${{ matrix.toolchain }}.cmake" >> $GITHUB_OUTPUT
+      run: echo "::set-output name=args::-DBUILD_SHARED_LIBS=OFF -DASSIMP_HUNTER_ENABLED=ON -DCMAKE_TOOLCHAIN_FILE=${{ github.workspace }}/cmake/polly/${{ matrix.toolchain }}.cmake"

    - name: configure and build
      uses: lukka/run-cmake@v3
@ -95,7 +92,7 @@ jobs:
    - name: Exclude certain tests in Hunter specific builds
      if: contains(matrix.name, 'hunter')
      id: hunter_extra_test_args
-      run: echo "args=--gtest_filter=-utOpenGEXImportExport.Importissue1340_EmptyCameraObject:utColladaZaeImportExport.importBlenFromFileTest" >> $GITHUB_OUTPUT
+      run: echo "::set-output name=args::--gtest_filter=-utOpenGEXImportExport.Importissue1340_EmptyCameraObject:utColladaZaeImportExport.importBlenFromFileTest"

    - name: test
      run: cd build/bin && ./unit ${{ steps.hunter_extra_test_args.outputs.args }}
@ -103,90 +100,6 @@ jobs:

    - uses: actions/upload-artifact@v4
      if: matrix.name == 'windows-msvc'
-      with:
-        name: 'assimp-bins-${{ matrix.name }}'
-        path: build/bin/assimp*.exe
-        
-    - uses: marvinpinto/action-automatic-releases@latest
-      if: contains(matrix.name, 'windows-msvc-hunter')
-      with:
-        repo_token: "${{ secrets.GITHUB_TOKEN }}"
-        automatic_release_tag: "master"
-        prerelease: true
-        title: "AutoRelease"
-        files: |
-          build/bin/assimp*.exe
-
-  create-release:
-    needs: [build]
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - id: create-release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: '${{secrets.GITHUB_TOKEN}}'
-        with:
-          tag_name: '${{github.ref}}'
-          release_name: 'Release ${{github.ref}}'
-          draft: false
-          prerelease: true
-      - run: |
-          echo '${{steps.create-release.outputs.upload_url}}' > release_upload_url.txt
-      - uses: actions/upload-artifact@v4
-        with:
-          name: create-release
-          path: release_upload_url.txt
-
-  upload-release:
-    strategy:
-      matrix:
-        name: [ubuntu-latest-g++, macos-latest-clang++, windows-latest-cl.exe, ubuntu-latest-clang++, ubuntu-gcc-hunter, macos-clang-hunter, windows-msvc-hunter]
-        # For Windows msvc, for Linux and macOS let's use the clang compiler, use gcc for Linux.
-        include:
-          - name: windows-latest-cl.exe
-            os: windows-latest
-            cxx: cl.exe
-            cc: cl.exe
-          - name: ubuntu-latest-clang++
-            os: ubuntu-latest
-            cxx: clang++
-            cc: clang
-          - name: macos-latest-clang++
-            os: macos-latest
-            cxx: clang++
-            cc: clang
-          - name: ubuntu-latest-g++
-            os: ubuntu-latest
-            cxx: g++
-            cc: gcc
-          - name: ubuntu-gcc-hunter
-            os: ubuntu-latest
-            toolchain: ninja-gcc-cxx17-fpic
-          - name: macos-clang-hunter
-            os: macos-latest
-            toolchain: ninja-clang-cxx17-fpic
-          - name: windows-msvc-hunter
-            os: windows-latest
-            toolchain: ninja-vs-win64-cxx17
-            
-    needs: [create-release]
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: softprops/action-gh-release@v2
-        with:
-          name: create-release
-      - id: upload-url
-        run: |
-          echo "url=$(cat create-release/release_upload_url.txt)" >> $GITHUB_OUTPUT
-      - uses: actions/download-artifact@v4
      with:
        name: 'assimp-bins-${{ matrix.name }}-${{ github.sha }}'
-      - uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: '${{secrets.GITHUB_TOKEN}}'
-        with:
-          files: |
-            *.zip
- 
+        path: build/bin
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -46,15 +46,6 @@ CMAKE_MINIMUM_REQUIRED( VERSION 3.22 )
 # auto-cloned during build; so MUST disable the feature or the PR will be rejected
 option(ASSIMP_BUILD_USD_IMPORTER "Enable USD file import" off)
 option(ASSIMP_BUILD_USD_VERBOSE_LOGS "Enable verbose USD import debug logging" off)
-option(ASSIMP_BUILD_USE_CCACHE "Use ccache to speed up compilation." on)
-
-if(ASSIMP_BUILD_USE_CCACHE)
-  find_program(CCACHE_PATH ccache)
-  if (CCACHE_PATH)
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_PATH})
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_PATH})
-  endif()
-endif()

 # Disabled importers: m3d for 5.1 or later
 ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_IMPORTER)
@ -71,7 +62,7 @@ IF(ASSIMP_HUNTER_ENABLED)
  add_definitions(-DASSIMP_USE_HUNTER)
 ENDIF()

-PROJECT(Assimp VERSION 5.4.3)
+PROJECT(Assimp VERSION 5.4.1)

 # All supported options ###############################################

@ -163,7 +154,7 @@ IF (WIN32)

  IF(MSVC)
    OPTION( ASSIMP_INSTALL_PDB
-      "Create MSVC debug symbol files and add to Install target."
+      "Install MSVC debug files."
      ON )
    IF(NOT (MSVC_VERSION LESS 1900))
      # Multibyte character set has been deprecated since at least MSVC2015 (possibly earlier)
@ -308,15 +299,8 @@ ELSEIF(MSVC)
  # supress warning for double to float conversion if Double precision is activated
  ADD_COMPILE_OPTIONS(/wd4244)
  SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /D_DEBUG /Zi /Od")
-  # Allow user to disable PDBs
-  if(ASSIMP_INSTALL_PDB)
-    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+  SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
  SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG:FULL /PDBALTPATH:%_PDB% /OPT:REF /OPT:ICF")
-  elseif((GENERATOR_IS_MULTI_CONFIG) OR (CMAKE_BUILD_TYPE MATCHES Release))
-    message("-- MSVC PDB generation disabled. Release binary will not be debuggable.")
-  endif()
-  # Source code is encoded in UTF-8
-  ADD_COMPILE_OPTIONS(/source-charset:utf-8)
 ELSEIF (CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
  IF(NOT ASSIMP_HUNTER_ENABLED)
    SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
@ -659,7 +643,7 @@ ELSE()
  IF ( ASSIMP_BUILD_DRACO )
    # Primarily for glTF v2
    # Enable Draco glTF feature set
-    set(DRACO_GLTF_BITSTREAM ON CACHE BOOL "" FORCE)
+    set(DRACO_GLTF ON CACHE BOOL "" FORCE)
    # Disable unnecessary or omitted components
    set(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
    set(DRACO_WASM OFF CACHE BOOL "" FORCE)
--- a/code/AssetLib/3DS/3DSConverter.cpp
+++ b/code/AssetLib/3DS/3DSConverter.cpp
@ -643,17 +643,11 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
    }

    // Allocate storage for children
-    const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
-
-    pcOut->mNumChildren = size;
-    if (size == 0) {
-        return;
-    }
-
+    pcOut->mNumChildren = (unsigned int)pcIn->mChildren.size();
    pcOut->mChildren = new aiNode *[pcIn->mChildren.size()];

    // Recursively process all children
-    
+    const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
    for (unsigned int i = 0; i < size; ++i) {
        pcOut->mChildren[i] = new aiNode();
        pcOut->mChildren[i]->mParent = pcOut;
--- a/code/AssetLib/3DS/3DSExporter.cpp
+++ b/code/AssetLib/3DS/3DSExporter.cpp
@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/StringComparison.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/Exporter.hpp>
-#include <assimp/Exceptional.h>
 #include <assimp/IOSystem.hpp>

 #include <memory>
--- a/code/AssetLib/3MF/D3MFExporter.cpp
+++ b/code/AssetLib/3MF/D3MFExporter.cpp
@ -249,10 +249,10 @@ void D3MFExporter::writeBaseMaterials() {
            if (color.r <= 1 && color.g <= 1 && color.b <= 1 && color.a <= 1) {

                hexDiffuseColor = ai_rgba2hex(
-                        (int)(((ai_real)color.r) * 255),
-                        (int)(((ai_real)color.g) * 255),
-                        (int)(((ai_real)color.b) * 255),
-                        (int)(((ai_real)color.a) * 255),
+                        (int)((ai_real)color.r) * 255,
+                        (int)((ai_real)color.g) * 255,
+                        (int)((ai_real)color.b) * 255,
+                        (int)((ai_real)color.a) * 255,
                        true);

            } else {
--- a/code/AssetLib/COB/COBLoader.cpp
+++ b/code/AssetLib/COB/COBLoader.cpp
@ -372,12 +372,10 @@ aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fi
    }

    // add children recursively
-    if (!root.temp_children.empty()) {
    nd->mChildren = new aiNode *[root.temp_children.size()]();
    for (const Node *n : root.temp_children) {
        (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n, scin, fill))->mParent = nd;
    }
-    }

    return nd;
 }
--- a/code/AssetLib/FBX/FBXConverter.cpp
+++ b/code/AssetLib/FBX/FBXConverter.cpp
@ -181,8 +181,6 @@ FBXConverter::FBXConverter(aiScene *out, const Document &doc, bool removeEmptyBo
    if (out->mNumMeshes == 0) {
        out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
    } else {
-        // Apply the FBX axis metadata unless requested not to
-        if (!doc.Settings().ignoreUpDirection)
        correctRootTransform(mSceneOut);
    }
 }
@ -312,8 +310,6 @@ void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node)

                child->mParent = last_parent;
                last_parent = child.mNode;
-
-                new_abs_transform *= child->mTransformation;
            }

            // attach geometry
@ -336,8 +332,6 @@ void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node)

                    postnode->mParent = last_parent;
                    last_parent = postnode.mNode;
-
-                    new_abs_transform *= postnode->mTransformation;
                }
            } else {
                // free the nodes we allocated as we don't need them
@ -363,13 +357,13 @@ void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node)
    if (nodes.empty()) {
        parent->mNumChildren = 0;
        parent->mChildren = nullptr;
-    } else {
+    }
+
    parent->mChildren = new aiNode *[nodes.size()]();
    parent->mNumChildren = static_cast<unsigned int>(nodes.size());
    for (unsigned int i = 0; i < nodes.size(); ++i) {
        parent->mChildren[i] = nodes[i].mOwnership.release();
    }
-    }
 }

 void FBXConverter::ConvertLights(const Model &model, const std::string &orig_name) {
@ -2134,10 +2128,6 @@ void FBXConverter::SetTextureProperties(aiMaterial *out_mat, const TextureMap &_
    TrySetTextureProperties(out_mat, _textures, "Maya|emissionColor", aiTextureType_EMISSION_COLOR, mesh);
    TrySetTextureProperties(out_mat, _textures, "Maya|metalness", aiTextureType_METALNESS, mesh);
    TrySetTextureProperties(out_mat, _textures, "Maya|diffuseRoughness", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
-    TrySetTextureProperties(out_mat, _textures, "Maya|base", aiTextureType_MAYA_BASE, mesh);
-    TrySetTextureProperties(out_mat, _textures, "Maya|specular", aiTextureType_MAYA_SPECULAR, mesh);
-    TrySetTextureProperties(out_mat, _textures, "Maya|specularColor", aiTextureType_MAYA_SPECULAR_COLOR, mesh);
-    TrySetTextureProperties(out_mat, _textures, "Maya|specularRoughness", aiTextureType_MAYA_SPECULAR_ROUGHNESS, mesh);

    // Maya stingray
    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_color_map", aiTextureType_BASE_COLOR, mesh);
--- a/code/AssetLib/FBX/FBXExporter.cpp
+++ b/code/AssetLib/FBX/FBXExporter.cpp
@ -1217,8 +1217,10 @@ void FBXExporter::WriteObjects ()
        }

        // colors, if any
-        for (size_t ci = 0; ci < m->GetNumColorChannels(); ++ci) {
-            FBX::Node vertexcolors("LayerElementColor", int32_t(ci));
+        // TODO only one color channel currently
+        const int32_t colorChannelIndex = 0;
+        if (m->HasVertexColors(colorChannelIndex)) {
+            FBX::Node vertexcolors("LayerElementColor", int32_t(colorChannelIndex));
            vertexcolors.Begin(outstream, binary, indent);
            vertexcolors.DumpProperties(outstream, binary, indent);
            vertexcolors.EndProperties(outstream, binary, indent);
@ -1228,7 +1230,7 @@ void FBXExporter::WriteObjects ()
                "Version", int32_t(101), outstream, binary, indent
            );
            char layerName[8];
-            snprintf(layerName, sizeof(layerName), "COLOR_%d", int32_t(ci));
+            snprintf(layerName, sizeof(layerName), "COLOR_%d", colorChannelIndex);
            FBX::Node::WritePropertyNode(
                "Name", (const char*)layerName, outstream, binary, indent
            );
@ -1245,7 +1247,7 @@ void FBXExporter::WriteObjects ()
            for (size_t fi = 0; fi < m->mNumFaces; ++fi) {
                const aiFace &f = m->mFaces[fi];
                for (size_t pvi = 0; pvi < f.mNumIndices; ++pvi) {
-                    const aiColor4D &c = m->mColors[ci][f.mIndices[pvi]];
+                    const aiColor4D &c = m->mColors[colorChannelIndex][f.mIndices[pvi]];
                    color_data.push_back(c.r);
                    color_data.push_back(c.g);
                    color_data.push_back(c.b);
@ -1352,14 +1354,11 @@ void FBXExporter::WriteObjects ()
        le.AddChild("Type", "LayerElementNormal");
        le.AddChild("TypedIndex", int32_t(0));
        layer.AddChild(le);
-
-        for (size_t ci = 0; ci < m->GetNumColorChannels(); ++ci) {
+        // TODO only 1 color channel currently
        le = FBX::Node("LayerElement");
        le.AddChild("Type", "LayerElementColor");
-            le.AddChild("TypedIndex", int32_t(ci));
+        le.AddChild("TypedIndex", int32_t(0));
        layer.AddChild(le);
-        }
-
        le = FBX::Node("LayerElement");
        le.AddChild("Type", "LayerElementMaterial");
        le.AddChild("TypedIndex", int32_t(0));
@ -2487,57 +2486,6 @@ const std::map<std::string,std::pair<std::string,char>> transform_types = {
    {"GeometricScalingInverse", {"GeometricScalingInverse", 'i'}}
 };

-//add metadata to fbx property
-void add_meta(FBX::Node& fbx_node, const aiNode* node){
-    if(node->mMetaData == nullptr) return;
-    aiMetadata* meta = node->mMetaData;
-    for (unsigned int i = 0; i < meta->mNumProperties; ++i) {
-        aiString key = meta->mKeys[i];
-        aiMetadataEntry* entry = &meta->mValues[i];
-        switch (entry->mType) {
-        case AI_BOOL:{
-            bool val = *static_cast<bool *>(entry->mData);
-            fbx_node.AddP70bool(key.C_Str(), val);
-            break;
-        }
-        case AI_INT32:{
-            int32_t val = *static_cast<int32_t *>(entry->mData);
-            fbx_node.AddP70int(key.C_Str(), val);
-            break;
-        }
-        case AI_UINT64:{
-            //use string to add uint64
-            uint64_t val = *static_cast<uint64_t *>(entry->mData);
-            fbx_node.AddP70string(key.C_Str(), std::to_string(val).c_str());
-            break;
-        }
-        case AI_FLOAT:{
-            float val = *static_cast<float *>(entry->mData);
-            fbx_node.AddP70double(key.C_Str(), val);
-            break;
-        }
-        case AI_DOUBLE:{
-            double val = *static_cast<double *>(entry->mData);
-            fbx_node.AddP70double(key.C_Str(), val);
-            break;
-        }
-        case AI_AISTRING:{
-            aiString val = *static_cast<aiString *>(entry->mData);
-            fbx_node.AddP70string(key.C_Str(), val.C_Str());
-            break;
-        }
-        case AI_AIMETADATA: {
-            //ignore
-            break;
-        }
-        default:
-            break;
-        }
-        
-    }
-    
-}
-
 // write a single model node to the stream
 void FBXExporter::WriteModelNode(
    StreamWriterLE& outstream,
@ -2605,7 +2553,6 @@ void FBXExporter::WriteModelNode(
            }
        }
    }
-    add_meta(p, node);
    m.AddChild(p);

    // not sure what these are for,
--- a/code/AssetLib/FBX/FBXImportSettings.h
+++ b/code/AssetLib/FBX/FBXImportSettings.h
@ -156,9 +156,6 @@ struct ImportSettings {
    /** Set to true to perform a conversion from cm to meter after the import
    */
    bool convertToMeters;
-
-    // Set to true to ignore the axis configuration in the file
-    bool ignoreUpDirection = false;
 };

 } // namespace FBX
--- a/code/AssetLib/FBX/FBXImporter.cpp
+++ b/code/AssetLib/FBX/FBXImporter.cpp
@ -117,7 +117,6 @@ void FBXImporter::SetupProperties(const Importer *pImp) {
    mSettings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false);
    mSettings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true);
    mSettings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false);
-    mSettings.ignoreUpDirection = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION, false);
    mSettings.useSkeleton = pImp->GetPropertyBool(AI_CONFIG_FBX_USE_SKELETON_BONE_CONTAINER, false);
 }

--- a/code/AssetLib/LWS/LWSLoader.cpp
+++ b/code/AssetLib/LWS/LWSLoader.cpp
@ -78,15 +78,7 @@ static constexpr aiImporterDesc desc = {

 // ------------------------------------------------------------------------------------------------
 // Recursive parsing of LWS files
-namespace {
-    constexpr int MAX_DEPTH = 1000; // Define the maximum depth allowed
-}
-
-void LWS::Element::Parse(const char *&buffer, const char *end, int depth) {
-    if (depth > MAX_DEPTH) {
-        throw std::runtime_error("Maximum recursion depth exceeded in LWS::Element::Parse");
-    }
-
+void LWS::Element::Parse(const char *&buffer, const char *end) {
    for (; SkipSpacesAndLineEnd(&buffer, end); SkipLine(&buffer, end)) {

        // begin of a new element with children
@ -129,7 +121,7 @@ void LWS::Element::Parse(const char *&buffer, const char *end, int depth) {

        // parse more elements recursively
        if (sub) {
-            children.back().Parse(buffer, end, depth + 1);
+            children.back().Parse(buffer, end);
        }
    }
 }
--- a/code/AssetLib/LWS/LWSLoader.h
+++ b/code/AssetLib/LWS/LWSLoader.h
@ -76,7 +76,7 @@ public:
    std::list<Element> children;

    //! Recursive parsing function
-    void Parse(const char *&buffer, const char *end, int depth = 0);
+    void Parse(const char *&buffer, const char *end);
 };

 #define AI_LWS_MASK (0xffffffff >> 4u)
--- a/code/AssetLib/MD3/MD3Loader.cpp
+++ b/code/AssetLib/MD3/MD3Loader.cpp
@ -724,7 +724,6 @@ void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
    std::vector<unsigned char> mBuffer2(fileSize);
    file->Read(&mBuffer2[0], 1, fileSize);
    mBuffer = &mBuffer2[0];
-    const unsigned char* bufferEnd = mBuffer + fileSize;

    pcHeader = (BE_NCONST MD3::Header *)mBuffer;

@ -750,15 +749,9 @@ void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy

    // Navigate to the list of surfaces
    BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES);
-    if ((const unsigned char*)pcSurfaces + sizeof(MD3::Surface) * pcHeader->NUM_SURFACES > bufferEnd) {
-        throw DeadlyImportError("MD3 surface headers are outside the file");
-    }

    // Navigate to the list of tags
    BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS);
-    if ((const unsigned char*)pcTags + sizeof(MD3::Tag) * pcHeader->NUM_TAGS > bufferEnd) {
-        throw DeadlyImportError("MD3 tags are outside the file");
-    }

    // Allocate output storage
    pScene->mNumMeshes = pcHeader->NUM_SURFACES;
@ -1033,10 +1026,6 @@ void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy

        for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) {
            aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode();
-            if ((const unsigned char*)pcTags + sizeof(MD3::Tag) > bufferEnd) {
-                throw DeadlyImportError("MD3 tag is outside the file");
-            }
-
            nd->mName.Set((const char *)pcTags->NAME);
            nd->mParent = pScene->mRootNode;

--- a/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
+++ b/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
@ -63,8 +63,7 @@ struct HL1ImportSettings {
        read_bone_controllers(false),
        read_hitboxes(false),
        read_textures(false),
-        read_misc_global_info(false),
-        transform_coord_system(true) {
+        read_misc_global_info(false) {
    }

    bool read_animations;
@ -77,7 +76,6 @@ struct HL1ImportSettings {
    bool read_hitboxes;
    bool read_textures;
    bool read_misc_global_info;
-    bool transform_coord_system;
 };

 } // namespace HalfLife
--- a/code/AssetLib/MDL/MDLLoader.cpp
+++ b/code/AssetLib/MDL/MDLLoader.cpp
@ -99,7 +99,7 @@ MDLImporter::MDLImporter() :
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    static constexpr uint32_t tokens[] = {
+    static const uint32_t tokens[] = {
        AI_MDL_MAGIC_NUMBER_LE_HL2a,
        AI_MDL_MAGIC_NUMBER_LE_HL2b,
        AI_MDL_MAGIC_NUMBER_LE_GS7,
@ -138,7 +138,6 @@ void MDLImporter::SetupProperties(const Importer *pImp) {
    mHL1ImportSettings.read_bone_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS, true);
    mHL1ImportSettings.read_hitboxes = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES, true);
    mHL1ImportSettings.read_misc_global_info = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO, true);
-    mHL1ImportSettings.transform_coord_system = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_TRANSFORM_COORD_SYSTEM);
 }

 // ------------------------------------------------------------------------------------------------
@ -147,20 +146,6 @@ const aiImporterDesc *MDLImporter::GetInfo() const {
    return &desc;
 }

-// ------------------------------------------------------------------------------------------------
-static void transformCoordinateSystem(const aiScene *pScene) {
-    if (pScene == nullptr) {
-        return;
-    }
-
-    pScene->mRootNode->mTransformation = aiMatrix4x4(
-        0.f, -1.f, 0.f, 0.f,
-        0.f, 0.f, 1.f, 0.f,
-        -1.f, 0.f, 0.f, 0.f,
-        0.f, 0.f, 0.f, 1.f
-    );
-}
-
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void MDLImporter::InternReadFile(const std::string &pFile,
@ -261,17 +246,19 @@ void MDLImporter::InternReadFile(const std::string &pFile,
                                    ". Magic word (", ai_str_toprintable((const char *)&iMagicWord, sizeof(iMagicWord)), ") is not known");
        }

-        if (is_half_life && mHL1ImportSettings.transform_coord_system) {
+        if (is_half_life){
            // Now rotate the whole scene 90 degrees around the z and x axes to convert to internal coordinate system
-            transformCoordinateSystem(pScene);
-        } else {
-            // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
            pScene->mRootNode->mTransformation = aiMatrix4x4(
-                1.f,  0.f, 0.f, 0.f,
-                0.f,  0.f, 1.f, 0.f, 
                    0.f, -1.f, 0.f, 0.f,
+                    0.f, 0.f, 1.f, 0.f,
+                    -1.f, 0.f, 0.f, 0.f,
                    0.f, 0.f, 0.f, 1.f);
        }
+        else {
+            // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+            pScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+                    0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
+        }

        DeleteBufferAndCleanup();
    } catch (...) {
--- a/code/AssetLib/MDL/MDLMaterialLoader.cpp
+++ b/code/AssetLib/MDL/MDLMaterialLoader.cpp
@ -730,12 +730,10 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
    // if an ASCII effect description (HLSL?) is contained in the file,
    // we can simply ignore it ...
    if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF) {
-        VALIDATE_FILE_SIZE(szCurrent + sizeof(int32_t));
        int32_t iMe = 0;
        ::memcpy(&iMe, szCurrent, sizeof(int32_t));
        AI_SWAP4(iMe);
        szCurrent += sizeof(char) * iMe + sizeof(int32_t);
-        VALIDATE_FILE_SIZE(szCurrent);
    }
    *szCurrentOut = szCurrent;
 }
--- a/code/AssetLib/Ply/PlyLoader.cpp
+++ b/code/AssetLib/Ply/PlyLoader.cpp
@ -81,27 +81,6 @@ namespace {

        return props[idx];
    }
-
-    // ------------------------------------------------------------------------------------------------
-    static bool isBigEndian(const char *szMe) {
-        ai_assert(nullptr != szMe);
-
-        // binary_little_endian
-        // binary_big_endian
-        bool isBigEndian{ false };
-#if (defined AI_BUILD_BIG_ENDIAN)
-        if ('l' == *szMe || 'L' == *szMe) {
-            isBigEndian = true;
-        }
-#else
-        if ('b' == *szMe || 'B' == *szMe) {
-            isBigEndian = true;
-        }
-#endif // ! AI_BUILD_BIG_ENDIAN
-
-        return isBigEndian;
-    }
-
 } // namespace

 // ------------------------------------------------------------------------------------------------
@ -113,11 +92,6 @@ PLYImporter::PLYImporter() :
    // empty
 }

-// ------------------------------------------------------------------------------------------------
-PLYImporter::~PLYImporter() {
-    delete mGeneratedMesh;
-}
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool PLYImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
@ -130,6 +104,26 @@ const aiImporterDesc *PLYImporter::GetInfo() const {
    return &desc;
 }

+// ------------------------------------------------------------------------------------------------
+static bool isBigEndian(const char *szMe) {
+    ai_assert(nullptr != szMe);
+
+    // binary_little_endian
+    // binary_big_endian
+    bool isBigEndian(false);
+#if (defined AI_BUILD_BIG_ENDIAN)
+    if ('l' == *szMe || 'L' == *szMe) {
+        isBigEndian = true;
+    }
+#else
+    if ('b' == *szMe || 'B' == *szMe) {
+        isBigEndian = true;
+    }
+#endif // ! AI_BUILD_BIG_ENDIAN
+
+    return isBigEndian;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
@ -140,7 +134,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
    }

    // Get the file-size
-    const size_t fileSize = fileStream->FileSize();
+    const size_t fileSize(fileStream->FileSize());
    if (0 == fileSize) {
        throw DeadlyImportError("File ", pFile, " is empty.");
    }
@ -186,7 +180,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
            }
        } else if (!::strncmp(szMe, "binary_", 7)) {
            szMe += 7;
-            const bool bIsBE = isBigEndian(szMe);
+            const bool bIsBE(isBigEndian(szMe));

            // skip the line, parse the rest of the header and build the DOM
            if (!PLY::DOM::ParseInstanceBinary(streamedBuffer, &sPlyDom, this, bIsBE)) {
@ -248,8 +242,6 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
    pScene->mNumMeshes = 1;
    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
    pScene->mMeshes[0] = mGeneratedMesh;
-
-    // Move the mesh ownership into the scene instance
    mGeneratedMesh = nullptr;

    // generate a simple node structure
@ -262,22 +254,20 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
    }
 }

-static constexpr ai_uint NotSet = 0xFFFFFFFF;
-
 void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos) {
    ai_assert(nullptr != pcElement);
    ai_assert(nullptr != instElement);

-    ai_uint aiPositions[3] = { NotSet, NotSet, NotSet };
+    ai_uint aiPositions[3] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
    PLY::EDataType aiTypes[3] = { EDT_Char, EDT_Char, EDT_Char };

-    ai_uint aiNormal[3] = { NotSet, NotSet, NotSet };
+    ai_uint aiNormal[3] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
    PLY::EDataType aiNormalTypes[3] = { EDT_Char, EDT_Char, EDT_Char };

-    unsigned int aiColors[4] = { NotSet, NotSet, NotSet, NotSet };
+    unsigned int aiColors[4] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
    PLY::EDataType aiColorsTypes[4] = { EDT_Char, EDT_Char, EDT_Char, EDT_Char };

-    unsigned int aiTexcoord[2] = { NotSet, NotSet };
+    unsigned int aiTexcoord[2] = { 0xFFFFFFFF, 0xFFFFFFFF };
    PLY::EDataType aiTexcoordTypes[2] = { EDT_Char, EDT_Char };

    // now check whether which normal components are available
@ -347,17 +337,17 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
    if (0 != cnt) {
        // Position
        aiVector3D vOut;
-        if (NotSet != aiPositions[0]) {
+        if (0xFFFFFFFF != aiPositions[0]) {
            vOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiPositions[0]).avList.front(), aiTypes[0]);
        }

-        if (NotSet != aiPositions[1]) {
+        if (0xFFFFFFFF != aiPositions[1]) {
            vOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiPositions[1]).avList.front(), aiTypes[1]);
        }

-        if (NotSet != aiPositions[2]) {
+        if (0xFFFFFFFF != aiPositions[2]) {
            vOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiPositions[2]).avList.front(), aiTypes[2]);
        }
@ -365,19 +355,19 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
        // Normals
        aiVector3D nOut;
        bool haveNormal = false;
-        if (NotSet != aiNormal[0]) {
+        if (0xFFFFFFFF != aiNormal[0]) {
            nOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiNormal[0]).avList.front(), aiNormalTypes[0]);
            haveNormal = true;
        }

-        if (NotSet != aiNormal[1]) {
+        if (0xFFFFFFFF != aiNormal[1]) {
            nOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiNormal[1]).avList.front(), aiNormalTypes[1]);
            haveNormal = true;
        }

-        if (NotSet != aiNormal[2]) {
+        if (0xFFFFFFFF != aiNormal[2]) {
            nOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiNormal[2]).avList.front(), aiNormalTypes[2]);
            haveNormal = true;
@ -386,7 +376,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
        // Colors
        aiColor4D cOut;
        bool haveColor = false;
-        if (NotSet != aiColors[0]) {
+        if (0xFFFFFFFF != aiColors[0]) {
            cOut.r = NormalizeColorValue(GetProperty(instElement->alProperties,
                                                 aiColors[0])
                                                 .avList.front(),
@ -394,7 +384,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
            haveColor = true;
        }

-        if (NotSet != aiColors[1]) {
+        if (0xFFFFFFFF != aiColors[1]) {
            cOut.g = NormalizeColorValue(GetProperty(instElement->alProperties,
                                                 aiColors[1])
                                                 .avList.front(),
@ -402,7 +392,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
            haveColor = true;
        }

-        if (NotSet != aiColors[2]) {
+        if (0xFFFFFFFF != aiColors[2]) {
            cOut.b = NormalizeColorValue(GetProperty(instElement->alProperties,
                                                 aiColors[2])
                                                 .avList.front(),
@ -411,7 +401,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
        }

        // assume 1.0 for the alpha channel if it is not set
-        if (NotSet == aiColors[3]) {
+        if (0xFFFFFFFF == aiColors[3]) {
            cOut.a = 1.0;
        } else {
            cOut.a = NormalizeColorValue(GetProperty(instElement->alProperties,
@ -426,13 +416,13 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
        aiVector3D tOut;
        tOut.z = 0;
        bool haveTextureCoords = false;
-        if (NotSet != aiTexcoord[0]) {
+        if (0xFFFFFFFF != aiTexcoord[0]) {
            tOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiTexcoord[0]).avList.front(), aiTexcoordTypes[0]);
            haveTextureCoords = true;
        }

-        if (NotSet != aiTexcoord[1]) {
+        if (0xFFFFFFFF != aiTexcoord[1]) {
            tOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
                    GetProperty(instElement->alProperties, aiTexcoord[1]).avList.front(), aiTexcoordTypes[1]);
            haveTextureCoords = true;
@ -448,9 +438,6 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
            mGeneratedMesh->mNumVertices = pcElement->NumOccur;
            mGeneratedMesh->mVertices = new aiVector3D[mGeneratedMesh->mNumVertices];
        }
-        if (pos >= mGeneratedMesh->mNumVertices) {
-            throw DeadlyImportError("Invalid .ply file: Too many vertices");
-        }

        mGeneratedMesh->mVertices[pos] = vOut;

@ -517,12 +504,16 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
    bool bOne = false;

    // index of the vertex index list
-    unsigned int iProperty = NotSet;
+    unsigned int iProperty = 0xFFFFFFFF;
    PLY::EDataType eType = EDT_Char;
    bool bIsTriStrip = false;

+    // index of the material index property
+    // unsigned int iMaterialIndex = 0xFFFFFFFF;
+    // PLY::EDataType eType2 = EDT_Char;
+
    // texture coordinates
-    unsigned int iTextureCoord = NotSet;
+    unsigned int iTextureCoord = 0xFFFFFFFF;
    PLY::EDataType eType3 = EDT_Char;

    // face = unique number of vertex indices
@ -581,7 +572,7 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst

        if (!bIsTriStrip) {
            // parse the list of vertex indices
-            if (NotSet != iProperty) {
+            if (0xFFFFFFFF != iProperty) {
                const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iProperty).avList.size();
                mGeneratedMesh->mFaces[pos].mNumIndices = iNum;
                mGeneratedMesh->mFaces[pos].mIndices = new unsigned int[iNum];
@ -594,7 +585,15 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
                }
            }

-            if (NotSet != iTextureCoord) {
+            // parse the material index
+            // cannot be handled without processing the whole file first
+            /*if (0xFFFFFFFF != iMaterialIndex)
+        {
+            mGeneratedMesh->mFaces[pos]. = PLY::PropertyInstance::ConvertTo<unsigned int>(
+            GetProperty(instElement->alProperties, iMaterialIndex).avList.front(), eType2);
+        }*/
+
+            if (0xFFFFFFFF != iTextureCoord) {
                const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iTextureCoord).avList.size();

                // should be 6 coords
@ -680,29 +679,41 @@ void PLYImporter::GetMaterialColor(const std::vector<PLY::PropertyInstance> &avL
        aiColor4D *clrOut) {
    ai_assert(nullptr != clrOut);

-    if (NotSet == aiPositions[0]) {
+    if (0xFFFFFFFF == aiPositions[0])
        clrOut->r = 0.0f;
-    } else {
-        clrOut->r = NormalizeColorValue(GetProperty(avList, aiPositions[0]).avList.front(), aiTypes[0]);
+    else {
+        clrOut->r = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[0])
+                                                .avList.front(),
+                aiTypes[0]);
    }

-    if (NotSet == aiPositions[1]) {
+    if (0xFFFFFFFF == aiPositions[1])
        clrOut->g = 0.0f;
-    } else {
-        clrOut->g = NormalizeColorValue(GetProperty(avList, aiPositions[1]).avList.front(), aiTypes[1]);
+    else {
+        clrOut->g = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[1])
+                                                .avList.front(),
+                aiTypes[1]);
    }

-    if (NotSet == aiPositions[2])
+    if (0xFFFFFFFF == aiPositions[2])
        clrOut->b = 0.0f;
    else {
-        clrOut->b = NormalizeColorValue(GetProperty(avList, aiPositions[2]).avList.front(), aiTypes[2]);
+        clrOut->b = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[2])
+                                                .avList.front(),
+                aiTypes[2]);
    }

    // assume 1.0 for the alpha channel ifit is not set
-    if (NotSet == aiPositions[3])
+    if (0xFFFFFFFF == aiPositions[3])
        clrOut->a = 1.0f;
    else {
-        clrOut->a = NormalizeColorValue(GetProperty(avList, aiPositions[3]).avList.front(), aiTypes[3]);
+        clrOut->a = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[3])
+                                                .avList.front(),
+                aiTypes[3]);
    }
 }

--- a/code/AssetLib/Ply/PlyLoader.h
+++ b/code/AssetLib/Ply/PlyLoader.h
@ -62,10 +62,10 @@ using namespace PLY;
 // ---------------------------------------------------------------------------
 /** Importer class to load the stanford PLY file format
 */
-class PLYImporter final : public BaseImporter {
+class PLYImporter : public BaseImporter {
 public:
    PLYImporter();
-    ~PLYImporter() override;
+    ~PLYImporter() override = default;

    // -------------------------------------------------------------------
    /** Returns whether the class can handle the format of the given file.
@ -120,9 +120,13 @@ protected:
            PLY::PropertyInstance::ValueUnion val,
            PLY::EDataType eType);

-private:
+    /** Buffer to hold the loaded file */
    unsigned char *mBuffer;
+
+    /** Document object model representation extracted from the file */
    PLY::DOM *pcDOM;
+
+    /** Mesh generated by loader */
    aiMesh *mGeneratedMesh;
 };

--- a/code/AssetLib/Ply/PlyParser.cpp
+++ b/code/AssetLib/Ply/PlyParser.cpp
@ -48,29 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/ByteSwapper.h>
 #include <assimp/fast_atof.h>
 #include <assimp/DefaultLogger.hpp>
-#include <unordered_set>
 #include <utility>

 namespace Assimp {

-std::string to_string(EElementSemantic e) {
-
-    switch (e) {
-    case EEST_Vertex:
-        return std::string{ "vertex" };
-    case EEST_TriStrip:
-        return std::string{ "tristrips" };
-    case EEST_Edge:
-        return std::string{ "edge" };
-    case EEST_Material:
-        return std::string{ "material" };
-    case EEST_TextureFile:
-        return std::string{ "TextureFile" };
-    default:
-        return std::string{ "invalid" };
-    }
-}
-
 // ------------------------------------------------------------------------------------------------
 PLY::EDataType PLY::Property::ParseDataType(std::vector<char> &buffer) {
    ai_assert(!buffer.empty());
@ -300,8 +281,6 @@ bool PLY::Element::ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<
        // if the exact semantic can't be determined, just store
        // the original string identifier
        pOut->szName = std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
-        auto pos = pOut->szName.find_last_of(' ');
-        pOut->szName.erase(pos, pOut->szName.size());
    }

    if (!PLY::DOM::SkipSpaces(buffer))
@ -434,7 +413,6 @@ bool PLY::DOM::SkipComments(std::vector<char> buffer) {
 bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) {
    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseHeader() begin");

-    std::unordered_set<std::string> definedAlElements;
    // parse all elements
    while (!buffer.empty()) {
        // skip all comments
@ -443,13 +421,6 @@ bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char>
        PLY::Element out;
        if (PLY::Element::ParseElement(streamBuffer, buffer, &out)) {
            // add the element to the list of elements
-
-            const auto propertyName = (out.szName.empty()) ? to_string(out.eSemantic) : out.szName;
-            auto alreadyDefined = definedAlElements.find(propertyName);
-            if (alreadyDefined != definedAlElements.end()) {
-                throw DeadlyImportError("Property '" + propertyName + "' in header already defined ");
-            }
-            definedAlElements.insert(propertyName);
            alElements.push_back(out);
        } else if (TokenMatch(buffer, "end_header", 10)) {
            // we have reached the end of the header
--- a/code/AssetLib/SMD/SMDLoader.cpp
+++ b/code/AssetLib/SMD/SMDLoader.cpp
@ -400,12 +400,8 @@ void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) {
        }
    }

-    // nothing to do
-    if (pcNode->mNumChildren == 0)
-        return;
-
    // now allocate the output array
-    pcNode->mChildren = new aiNode *[pcNode->mNumChildren];
+    pcNode->mChildren = new aiNode*[pcNode->mNumChildren];

    // and fill all subnodes
    unsigned int qq( 0 );
--- a/code/AssetLib/USD/USDLoader.cpp
+++ b/code/AssetLib/USD/USDLoader.cpp
@ -121,4 +121,3 @@ void USDImporter::InternReadFile(
 } // namespace Assimp

 #endif // !! ASSIMP_BUILD_NO_USD_IMPORTER
-
--- a/code/AssetLib/USD/USDLoaderImplTinyusdz.cpp
+++ b/code/AssetLib/USD/USDLoaderImplTinyusdz.cpp
@ -72,7 +72,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../../../contrib/tinyusdz/assimp_tinyusdz_logging.inc"

 namespace {
-    static constexpr char TAG[] = "tinyusdz loader";
+    static constexpr char Tag[] = "tinyusdz loader";
 }

 namespace Assimp {
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@ -1036,10 +1036,10 @@ size_t Accessor::ExtractData(T *&outData, const std::vector<unsigned int> *remap
    outData = new T[usedCount];

    if (remappingIndices != nullptr) {
-        const unsigned int maxIndexCount = static_cast<unsigned int>(maxSize / stride);
+        const unsigned int maxIndex = static_cast<unsigned int>(maxSize / stride - 1);
        for (size_t i = 0; i < usedCount; ++i) {
            size_t srcIdx = (*remappingIndices)[i];
-            if (srcIdx >= maxIndexCount) {
+            if (srcIdx > maxIndex) {
                throw DeadlyImportError("GLTF: index*stride ", (srcIdx * stride), " > maxSize ", maxSize, " in ", getContextForErrorMessages(id, name));
            }
            memcpy(outData + i, data + srcIdx * stride, elemSize);
--- a/code/AssetLib/glTF2/glTF2AssetWriter.inl
+++ b/code/AssetLib/glTF2/glTF2AssetWriter.inl
@ -940,7 +940,7 @@ namespace glTF2 {
            if (outfile->Write(bodyBuffer->GetPointer(), 1, bodyBuffer->byteLength) != bodyBuffer->byteLength) {
                throw DeadlyExportError("Failed to write body data!");
            }
-            if (curPaddingLength && outfile->Write(&padding, 1, curPaddingLength) != curPaddingLength) {
+            if (curPaddingLength && outfile->Write(&padding, 1, paddingLength) != paddingLength) {
                throw DeadlyExportError("Failed to write body data padding!");
            }
        }
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@ -1053,7 +1053,7 @@ ENDIF() # IF (ASSIMP_BUILD_USD_IMPORTER)
 IF(ASSIMP_HUNTER_ENABLED)
  hunter_add_package(pugixml)
  find_package(pugixml CONFIG REQUIRED)
-ELSEIF(NOT TARGET pugixml::pugixml)
+ELSE()
  SET( Pugixml_SRCS
    ../contrib/pugixml/src/pugiconfig.hpp
    ../contrib/pugixml/src/pugixml.hpp
@ -1334,7 +1334,7 @@ ADD_LIBRARY(assimp::assimp ALIAS assimp)
 IF (BUILD_SHARED_LIBS)
  TARGET_COMPILE_DEFINITIONS(assimp PRIVATE ASSIMP_BUILD_DLL_EXPORT)
 ELSE ()
-  TARGET_COMPILE_DEFINITIONS(assimp PRIVATE OPENDDL_STATIC_LIBARY P2T_STATIC_EXPORTS)
+  TARGET_COMPILE_DEFINITIONS(assimp PRIVATE OPENDDL_STATIC_LIBARY)
 ENDIF ()

 TARGET_USE_COMMON_OUTPUT_DIRECTORY(assimp)
@ -1396,7 +1396,6 @@ IF (ASSIMP_WARNINGS_AS_ERRORS)
        -Wno-unused-template
        -Wno-undefined-func-template
        -Wno-declaration-after-statement
-        -Wno-deprecated-declarations
      )
    ELSE()
      TARGET_COMPILE_OPTIONS(assimp PRIVATE /W4 /WX)
@ -1418,7 +1417,9 @@ TARGET_INCLUDE_DIRECTORIES ( assimp PUBLIC
 IF(ASSIMP_HUNTER_ENABLED)
  TARGET_LINK_LIBRARIES(assimp
      PUBLIC
+      #polyclipping::polyclipping
      openddlparser::openddl_parser
+      #poly2tri::poly2tri
      minizip::minizip
      ZLIB::zlib
      RapidJSON::rapidjson
@ -1438,9 +1439,6 @@ ELSE()
  if (ASSIMP_BUILD_DRACO)
    target_link_libraries(assimp ${draco_LIBRARIES})
  endif()
-  if(TARGET pugixml::pugixml)
-    target_link_libraries(assimp pugixml::pugixml)
-  endif()
 ENDIF()

 if(ASSIMP_ANDROID_JNIIOSYSTEM)
@ -1577,7 +1575,7 @@ if(MSVC AND ASSIMP_INSTALL_PDB)
      COMPILE_PDB_NAME_DEBUG assimp${LIBRARY_SUFFIX}${CMAKE_DEBUG_POSTFIX}
    )

-    IF(is_multi_config)
+    IF(GENERATOR_IS_MULTI_CONFIG)
      install(FILES ${Assimp_BINARY_DIR}/code/Debug/assimp${LIBRARY_SUFFIX}${CMAKE_DEBUG_POSTFIX}.pdb
        DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
        CONFIGURATIONS Debug
--- a/code/Common/Assimp.cpp
+++ b/code/Common/Assimp.cpp
@ -359,25 +359,20 @@ void CallbackToLogRedirector(const char *msg, char *dt) {
    s->write(msg);
 }

-static LogStream *DefaultStream = nullptr;
-
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) {
    aiLogStream sout;

    ASSIMP_BEGIN_EXCEPTION_REGION();
-    if (DefaultStream == nullptr) {
-        DefaultStream = LogStream::createDefaultStream(pStream, file);
-    }
-    
-    if (!DefaultStream) {
+    LogStream *stream = LogStream::createDefaultStream(pStream, file);
+    if (!stream) {
        sout.callback = nullptr;
        sout.user = nullptr;
    } else {
        sout.callback = &CallbackToLogRedirector;
-        sout.user = (char *)DefaultStream;
+        sout.user = (char *)stream;
    }
-    gPredefinedStreams.push_back(DefaultStream);
+    gPredefinedStreams.push_back(stream);
    ASSIMP_END_EXCEPTION_REGION(aiLogStream);
    return sout;
 }
@ -517,11 +512,6 @@ void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn,
    ASSIMP_END_EXCEPTION_REGION(void);
 }

-// ------------------------------------------------------------------------------------------------
-ASSIMP_API const C_STRUCT aiTexture *aiGetEmbeddedTexture(const C_STRUCT aiScene *pIn, const char *filename) {
-    return pIn->GetEmbeddedTexture(filename);
-}
-
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) {
    return reinterpret_cast<aiPropertyStore *>(new PropertyMap());
@ -1278,6 +1268,7 @@ ASSIMP_API void aiQuaternionInterpolate(
    aiQuaternion::Interpolate(*dst, *start, *end, factor);
 }

+
 // stb_image is a lightweight image loader. It is shared by:
 //  - M3D import
 //  - PBRT export
@ -1288,21 +1279,21 @@ ASSIMP_API void aiQuaternionInterpolate(
 #define ASSIMP_HAS_M3D ((!ASSIMP_BUILD_NO_EXPORT && !ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER)

 #ifndef STB_USE_HUNTER
-#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_HAS_PBRT_EXPORT
+#       define ASSIMP_NEEDS_STB_IMAGE 1
+#   elif ASSIMP_HAS_M3D
+#       define ASSIMP_NEEDS_STB_IMAGE 1
+#       define STBI_ONLY_PNG
+#   endif
 #endif

 // Ensure all symbols are linked correctly
 #if ASSIMP_NEEDS_STB_IMAGE
-// Share stb_image's PNG loader with other importers/exporters instead of bringing our own copy.
-#define STBI_ONLY_PNG
-#ifdef ASSIMP_USE_STB_IMAGE_STATIC
-#define STB_IMAGE_STATIC
-#endif
-#define STB_IMAGE_IMPLEMENTATION
-#include "Common/StbCommon.h"
+    // Share stb_image's PNG loader with other importers/exporters instead of bringing our own copy.
+#   define STBI_ONLY_PNG
+#   ifdef ASSIMP_USE_STB_IMAGE_STATIC
+#       define STB_IMAGE_STATIC
+#   endif
+#   define STB_IMAGE_IMPLEMENTATION
+#   include "Common/StbCommon.h"
 #endif
--- a/code/Common/DefaultIOSystem.cpp
+++ b/code/Common/DefaultIOSystem.cpp
@ -93,10 +93,6 @@ static std::string WideToUtf8(const wchar_t *in) {
 // ------------------------------------------------------------------------------------------------
 // Tests for the existence of a file at the given path.
 bool DefaultIOSystem::Exists(const char *pFile) const {
-    if (pFile == nullptr) {
-        return false;
-    }
-        
 #ifdef _WIN32
    struct __stat64 filestat;
    if (_wstat64(Utf8ToWide(pFile).c_str(), &filestat) != 0) {
--- a/code/Common/Importer.cpp
+++ b/code/Common/Importer.cpp
@ -848,7 +848,11 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
            break;
        }
 #ifdef ASSIMP_BUILD_DEBUG
-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
+
+#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");
@ -860,7 +864,6 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
                break;
            }
        }
-#endif  // no validation
 #endif // ! DEBUG
    }
    pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()),
@ -936,7 +939,6 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
        profiler->EndRegion( "postprocess" );
    }

-#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
    // 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" );
@ -947,7 +949,6 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
            ASSIMP_LOG_ERROR( "Verbose Import: failed to revalidate data structures" );
        }
    }
-#endif // no validation

    // clear any data allocated by post-process steps
    pimpl->mPPShared->Clean();
--- a/code/Common/SceneCombiner.cpp
+++ b/code/Common/SceneCombiner.cpp
@ -63,7 +63,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <stdio.h>
 #include <assimp/DefaultLogger.hpp>
-#include <unordered_set>

 namespace Assimp {

@ -253,14 +252,6 @@ void SceneCombiner::AttachToGraph(aiScene *master, std::vector<NodeAttachmentInf
 // ------------------------------------------------------------------------------------------------
 void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<AttachmentInfo> &srcList, unsigned int flags) {
    if (nullptr == _dest) {
-        std::unordered_set<aiScene *> uniqueScenes;
-        uniqueScenes.insert(master);
-        for (const auto &item : srcList) {
-            uniqueScenes.insert(item.scene);
-        }
-        for (const auto &item : uniqueScenes) {
-            delete item;
-        }
        return;
    }

@ -268,7 +259,6 @@ void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<At
    if (srcList.empty()) {
        if (*_dest) {
            SceneCombiner::CopySceneFlat(_dest, master);
-            delete master;
        } else
            *_dest = master;
        return;
@ -1067,7 +1057,7 @@ void SceneCombiner::CopyScene(aiScene **_dest, const aiScene *src, bool allocate
    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 (src->mPrivate != nullptr) {
+    if (dest->mPrivate != nullptr) {
        ScenePriv(dest)->mPPStepsApplied = ScenePriv(src) ? ScenePriv(src)->mPPStepsApplied : 0;
    }
 }
--- a/code/PostProcessing/CalcTangentsProcess.cpp
+++ b/code/PostProcessing/CalcTangentsProcess.cpp
@ -200,10 +200,8 @@ bool CalcTangentsProcess::ProcessMesh(aiMesh *pMesh, unsigned int meshIndex) {
            localBitangent.NormalizeSafe();

            // reconstruct tangent/bitangent according to normal and bitangent/tangent when it's infinite or NaN.
-            bool invalid_tangent = is_special_float(localTangent.x) || is_special_float(localTangent.y) || is_special_float(localTangent.z) 
-                || (-0.5f < localTangent.x && localTangent.x < 0.5f && -0.5f < localTangent.y && localTangent.y < 0.5f && -0.5f < localTangent.z && localTangent.z < 0.5f);
-            bool invalid_bitangent = is_special_float(localBitangent.x) || is_special_float(localBitangent.y) || is_special_float(localBitangent.z)
-                || (-0.5f < localBitangent.x && localBitangent.x < 0.5f && -0.5f < localBitangent.y && localBitangent.y < 0.5f && -0.5f < localBitangent.z && localBitangent.z < 0.5f);
+            bool invalid_tangent = is_special_float(localTangent.x) || is_special_float(localTangent.y) || is_special_float(localTangent.z);
+            bool invalid_bitangent = is_special_float(localBitangent.x) || is_special_float(localBitangent.y) || is_special_float(localBitangent.z);
            if (invalid_tangent != invalid_bitangent) {
                if (invalid_tangent) {
                    localTangent = meshNorm[p] ^ localBitangent;
--- a/code/PostProcessing/FindDegenerates.cpp
+++ b/code/PostProcessing/FindDegenerates.cpp
@ -143,13 +143,9 @@ bool FindDegeneratesProcess::ExecuteOnMesh(aiMesh *mesh) {
    for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
        aiFace &face = mesh->mFaces[a];
        bool first = true;
-        auto vertex_in_range = [numVertices = mesh->mNumVertices](unsigned int vertex_idx) { return vertex_idx < numVertices; };

        // check whether the face contains degenerated entries
        for (unsigned int i = 0; i < face.mNumIndices; ++i) {
-            if (!std::all_of(face.mIndices, face.mIndices + face.mNumIndices, vertex_in_range))
-                continue;
-
            // Polygons with more than 4 points are allowed to have double points, that is
            // simulating polygons with holes just with concave polygons. However,
            // double points may not come directly after another.
--- a/code/PostProcessing/ImproveCacheLocality.cpp
+++ b/code/PostProcessing/ImproveCacheLocality.cpp
@ -380,4 +380,3 @@ ai_real ImproveCacheLocalityProcess::ProcessMesh(aiMesh *pMesh, unsigned int mes
 }

 } // namespace Assimp
-
--- a/code/PostProcessing/SortByPTypeProcess.cpp
+++ b/code/PostProcessing/SortByPTypeProcess.cpp
@ -65,48 +65,38 @@ void SortByPTypeProcess::SetupProperties(const Importer *pImp) {
    mConfigRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, 0);
 }

-// ------------------------------------------------------------------------------------------------
-static void clearMeshesInNode(aiNode *node) {
-    delete[] node->mMeshes;
-    node->mNumMeshes = 0;
-    node->mMeshes = nullptr;
-}
-
 // ------------------------------------------------------------------------------------------------
 // Update changed meshes in all nodes
 void UpdateNodes(const std::vector<unsigned int> &replaceMeshIndex, aiNode *node) {
-    ai_assert(node != nullptr);
-    
    if (node->mNumMeshes) {
        unsigned int newSize = 0;
        for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
            unsigned int add = node->mMeshes[m] << 2;
            for (unsigned int i = 0; i < 4; ++i) {
-                if (UINT_MAX != replaceMeshIndex[add + i]) {
-                    ++newSize;
+                if (UINT_MAX != replaceMeshIndex[add + i]) ++newSize;
            }
        }
-        }
-        if (newSize == 0) {
-            clearMeshesInNode(node);
-            return;
-        }
-        
+        if (!newSize) {
+            delete[] node->mMeshes;
+            node->mNumMeshes = 0;
+            node->mMeshes = nullptr;
+        } else {
            // Try to reuse the old array if possible
            unsigned int *newMeshes = (newSize > node->mNumMeshes ? new unsigned int[newSize] : node->mMeshes);
+
            for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
                unsigned int add = node->mMeshes[m] << 2;
                for (unsigned int i = 0; i < 4; ++i) {
-                if (UINT_MAX != replaceMeshIndex[add + i]) {
+                    if (UINT_MAX != replaceMeshIndex[add + i])
                        *newMeshes++ = replaceMeshIndex[add + i];
                }
            }
-        }
-        if (newSize > node->mNumMeshes) {
-            clearMeshesInNode(node);
-        }
+            if (newSize > node->mNumMeshes)
+                delete[] node->mMeshes;
+
            node->mMeshes = newMeshes - (node->mNumMeshes = newSize);
        }
+    }

    // call all subnodes recursively
    for (unsigned int m = 0; m < node->mNumChildren; ++m) {
@ -177,10 +167,6 @@ void SortByPTypeProcess::Execute(aiScene *pScene) {
        // with the largest number of primitives
        unsigned int aiNumPerPType[4] = { 0, 0, 0, 0 };
        aiFace *pFirstFace = mesh->mFaces;
-        if (pFirstFace == nullptr) {
-            continue;
-        }
-
        aiFace *const pLastFace = pFirstFace + mesh->mNumFaces;

        unsigned int numPolyVerts = 0;
--- a/code/PostProcessing/TriangulateProcess.cpp
+++ b/code/PostProcessing/TriangulateProcess.cpp
@ -192,14 +192,14 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) {

        for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
            const aiFace& face = pMesh->mFaces[a];
+
            if( face.mNumIndices != 3)  {
                bNeed = true;
            }
        }
-        if (!bNeed) {
+        if (!bNeed)
            return false;
    }
-    }
    else if (!(pMesh->mPrimitiveTypes & aiPrimitiveType_POLYGON)) {
        return false;
    }
@ -213,7 +213,8 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) {
            get_normals = false;
        }
        if( face.mNumIndices <= 3) {
-            ++numOut;
+            numOut++;
+
        } else {
            numOut += face.mNumIndices-2;
            max_out = std::max(max_out,face.mNumIndices);
@ -221,10 +222,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) {
    }

    // Just another check whether aiMesh::mPrimitiveTypes is correct
-    if (numOut == pMesh->mNumFaces) {
-        ASSIMP_LOG_ERROR( "Invalidation detected in the number of indices: does not fit to the primitive type." );
-        return false;
-    }
+    ai_assert(numOut != pMesh->mNumFaces);

    aiVector3D *nor_out = nullptr;

--- a/code/PostProcessing/ValidateDataStructure.cpp
+++ b/code/PostProcessing/ValidateDataStructure.cpp
@ -891,9 +891,6 @@ void ValidateDSProcess::Validate(const aiNode *pNode) {
                ReportError("aiNode \"%s\" child %i \"%s\" parent is someone else: \"%s\"", pNode->mName.C_Str(), i, pChild->mName.C_Str(), parentName);
            }
        }
-    } else if (pNode->mChildren) {
-        ReportError("aiNode::mChildren is not nullptr for empty node %s (aiNode::mNumChildren is %i)",
-                nodeName, pNode->mNumChildren);
    }
 }

--- a/contrib/poly2tri/LICENSE
+++ b/contrib/poly2tri/LICENSE
@ -1,6 +1,7 @@
-Copyright (c) 2009-2018, Poly2Tri Contributors
-All rights reserved.
+Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+http://code.google.com/p/poly2tri/

+All rights reserved.
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

--- a/contrib/poly2tri/README
+++ b/contrib/poly2tri/README
@ -0,0 +1,51 @@
+==================
+INSTALLATION GUIDE
+==================
+
+------------
+Dependencies
+------------
+
+  Core poly2tri lib:
+  - Standard Template Library (STL)
+  
+  Testbed:
+  - gcc
+  - OpenGL
+  - GLFW (http://glfw.sf.net)
+  - Python
+ 
+Waf (http://code.google.com/p/waf/) is used to compile the testbed.   
+A waf script (86kb) is included in the repositoty.
+
+----------------------------------------------
+Building the Testbed
+----------------------------------------------
+
+Posix/MSYS environment:
+
+  ./waf configure
+  ./waf build
+
+Windows command line:
+
+  python waf configure
+  python waf build
+
+----------------------------------------------
+Running the Examples
+----------------------------------------------
+
+Load data points from a file:
+p2t <filename> <center_x> <center_y> <zoom>
+
+Random distribution of points inside a consrained box:
+p2t random <num_points> <box_radius> <zoom>
+
+Examples:
+
+  ./p2t dude.dat 300 500 2
+  ./p2t nazca_monkey.dat 0 0 9
+  
+  ./p2t random 10 100 5.0
+  ./p2t random 1000 20000 0.025
--- a/contrib/poly2tri/README.md
+++ b/contrib/poly2tri/README.md
@ -1,101 +0,0 @@
-Since there are no Input validation of the data given for triangulation you need
-to think about this. Poly2Tri does not support repeat points within epsilon.
-
-* If you have a cyclic function that generates random points make sure you don't
-  add the same coordinate twice.
-* If you are given input and aren't sure same point exist twice you need to
-  check for this yourself.
-* Only simple polygons are supported. You may add holes or interior Steiner points
-* Interior holes must not touch other holes, nor touch the polyline boundary
-* Use the library in this order:
-  1. Initialize CDT with a simple polyline (this defines the constrained edges)
-  2. Add holes if necessary (also simple polylines)
-  3. Add Steiner points
-  4. Triangulate
-
-Make sure you understand the preceding notice before posting an issue. If you have
-an issue not covered by the above, include your data-set with the problem.
-The only easy day was yesterday; have a nice day. <Mason Green>
-
-TESTBED INSTALLATION GUIDE
-==========================
-
-Dependencies
------------
-
-Core poly2tri lib:
-
-* Standard Template Library (STL)
-
-Unit tests:
-* Boost (filesystem, test framework)
-
-Testbed:
-
-* OpenGL
-* [GLFW](http://glfw.sf.net)
-
-Build the library
-----------------
-
-With the ninja build system installed:
-
-```
-mkdir build && cd build
-cmake -GNinja ..
-cmake --build .
-```
-
-Build and run with unit tests
----------------------------
-
-With the ninja build system:
-
-```
-mkdir build && cd build
-cmake -GNinja -DP2T_BUILD_TESTS=ON ..
-cmake --build .
-ctest --output-on-failure
-```
-
-Build with the testbed
-----------------
-
-```
-mkdir build && cd build
-cmake -GNinja -DP2T_BUILD_TESTBED=ON ..
-cmake --build .
-```
-
-Running the Examples
--------------------
-
-Load data points from a file:
-```
-build/testbed/p2t <filename> <center_x> <center_y> <zoom>
-```
-Load data points from a file and automatically fit the geometry to the window:
-```
-build/testbed/p2t <filename>
-```
-Random distribution of points inside a constrained box:
-```
-build/testbed/p2t random <num_points> <box_radius> <zoom>
-```
-Examples:
-```
-build/testbed/p2t testbed/data/dude.dat 350 500 3
-
-build/testbed/p2t testbed/data/nazca_monkey.dat
-
-build/testbed/p2t random 10 100 5.0
-build/testbed/p2t random 1000 20000 0.025
-```
-
-References
-==========
-
- Domiter V. and Zalik B. (2008) Sweep‐line algorithm for constrained Delaunay triangulation
- FlipScan by library author Thomas Åhlén
-
-![FlipScan](doc/FlipScan.png)
--- a/contrib/poly2tri/poly2tri/common/dll_symbol.h
+++ b/contrib/poly2tri/poly2tri/common/dll_symbol.h
@ -1,61 +0,0 @@
-/*
- * Poly2Tri Copyright (c) 2009-2022, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
- *
- * All rights reserved.
- *
- * Redistribution and use 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 Poly2Tri nor the names of its contributors may be
- *   used to endorse or promote products derived from this software without specific
- *   prior written permission.
- *
- * 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
-
-#if defined(_MSC_VER)
-#  pragma warning( disable: 4273)
-#  define P2T_COMPILER_DLLEXPORT __declspec(dllexport)
-#  define P2T_COMPILER_DLLIMPORT __declspec(dllimport)
-#elif defined(__GNUC__)
-#  define P2T_COMPILER_DLLEXPORT __attribute__ ((visibility ("default")))
-#  define P2T_COMPILER_DLLIMPORT __attribute__ ((visibility ("default")))
-#else
-#  define P2T_COMPILER_DLLEXPORT
-#  define P2T_COMPILER_DLLIMPORT
-#endif
-
-// We need to enable shard linkage explicitely
-#ifdef ASSIMP_BUILD_DLL_EXPORT
-#  define P2T_SHARED_EXPORTS 1
-#endif
-
-#ifndef P2T_DLL_SYMBOL
-#  if defined(P2T_STATIC_EXPORTS)
-#    define P2T_DLL_SYMBOL
-#  elif defined(P2T_SHARED_EXPORTS)
-#    define P2T_DLL_SYMBOL P2T_COMPILER_DLLEXPORT
-#  elif defined(BUILD_SHARED_LIBS)
-#    define P2T_DLL_SYMBOL P2T_COMPILER_DLLIMPORT
-#  else
-#    define P2T_DLL_SYMBOL
-#  endif
-#endif
--- a/contrib/poly2tri/poly2tri/common/shapes.cc
+++ b/contrib/poly2tri/poly2tri/common/shapes.cc
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,24 +29,14 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #include "shapes.h"
-
-#include <cassert>
 #include <iostream>

 namespace p2t {

-Point::Point(double x, double y) : x(x), y(y)
-{
-}
-
-std::ostream& operator<<(std::ostream& out, const Point& point) {
-  return out << point.x << "," << point.y;
-}
-
 Triangle::Triangle(Point& a, Point& b, Point& c)
 {
  points_[0] = &a; points_[1] = &b; points_[2] = &c;
-  neighbors_[0] = nullptr; neighbors_[1] = nullptr; neighbors_[2] = nullptr;
+  neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
  constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false;
  delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
  interior_ = false;
@ -86,37 +76,39 @@ void Triangle::MarkNeighbor(Triangle& t)
 void Triangle::Clear()
 {
    Triangle *t;
-    for (auto& neighbor : neighbors_) {
-      t = neighbor;
-      if (t != nullptr) {
-        t->ClearNeighbor(this);
+    for( int i=0; i<3; i++ )
+    {
+        t = neighbors_[i];
+        if( t != NULL )
+        {
+            t->ClearNeighbor( this );
        }
    }
    ClearNeighbors();
-    points_[0]=points_[1]=points_[2] = nullptr;
+    points_[0]=points_[1]=points_[2] = NULL;
 }

 void Triangle::ClearNeighbor(const Triangle *triangle )
 {
    if( neighbors_[0] == triangle )
    {
-        neighbors_[0] = nullptr;
+        neighbors_[0] = NULL;
    }
    else if( neighbors_[1] == triangle )
    {
-        neighbors_[1] = nullptr;
+        neighbors_[1] = NULL;
    }
    else
    {
-        neighbors_[2] = nullptr;
+        neighbors_[2] = NULL;
    }
 }

 void Triangle::ClearNeighbors()
 {
-  neighbors_[0] = nullptr;
-  neighbors_[1] = nullptr;
-  neighbors_[2] = nullptr;
+  neighbors_[0] = NULL;
+  neighbors_[1] = NULL;
+  neighbors_[2] = NULL;
 }

 void Triangle::ClearDelunayEdges()
@ -228,7 +220,7 @@ Point* Triangle::PointCW(const Point& point)
    return points_[1];
  }
  assert(0);
-  return nullptr;
+  return NULL;
 }

 // The point counter-clockwise to given point
@ -242,18 +234,7 @@ Point* Triangle::PointCCW(const Point& point)
    return points_[0];
  }
  assert(0);
-  return nullptr;
-}
-
-// The neighbor across to given point
-Triangle* Triangle::NeighborAcross(const Point& point)
-{
-  if (&point == points_[0]) {
-    return neighbors_[0];
-  } else if (&point == points_[1]) {
-    return neighbors_[1];
-  }
-  return neighbors_[2];
+  return NULL;
 }

 // The neighbor clockwise to given point
@ -362,50 +343,23 @@ void Triangle::SetDelunayEdgeCW(const Point& p, bool e)
  }
 }

+// The neighbor across to given point
+Triangle& Triangle::NeighborAcross(const Point& opoint)
+{
+  if (&opoint == points_[0]) {
+    return *neighbors_[0];
+  } else if (&opoint == points_[1]) {
+    return *neighbors_[1];
+  }
+  return *neighbors_[2];
+}
+
 void Triangle::DebugPrint()
 {
-  std::cout << *points_[0] << " " << *points_[1] << " " << *points_[2] << std::endl;
+  using namespace std;
+  cout << points_[0]->x << "," << points_[0]->y << " ";
+  cout << points_[1]->x << "," << points_[1]->y << " ";
+  cout << points_[2]->x << "," << points_[2]->y << endl;
 }

-bool Triangle::CircumcicleContains(const Point& point) const
-{
-  assert(IsCounterClockwise());
-  const double dx = points_[0]->x - point.x;
-  const double dy = points_[0]->y - point.y;
-  const double ex = points_[1]->x - point.x;
-  const double ey = points_[1]->y - point.y;
-  const double fx = points_[2]->x - point.x;
-  const double fy = points_[2]->y - point.y;
-
-  const double ap = dx * dx + dy * dy;
-  const double bp = ex * ex + ey * ey;
-  const double cp = fx * fx + fy * fy;
-
-  return (dx * (fy * bp - cp * ey) - dy * (fx * bp - cp * ex) + ap * (fx * ey - fy * ex)) < 0;
 }
-
-bool Triangle::IsCounterClockwise() const
-{
-  return (points_[1]->x - points_[0]->x) * (points_[2]->y - points_[0]->y) -
-             (points_[2]->x - points_[0]->x) * (points_[1]->y - points_[0]->y) >
-         0;
-}
-
-bool IsDelaunay(const std::vector<p2t::Triangle*>& triangles)
-{
-  for (const auto triangle : triangles) {
-    for (const auto other : triangles) {
-      if (triangle == other) {
-        continue;
-      }
-      for (int i = 0; i < 3; ++i) {
-        if (triangle->CircumcicleContains(*other->GetPoint(i))) {
-          return false;
-        }
-      }
-    }
-  }
-  return true;
-}
-
-} // namespace p2t
--- a/contrib/poly2tri/poly2tri/common/shapes.h
+++ b/contrib/poly2tri/poly2tri/common/shapes.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,24 +29,22 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#pragma once
+// Include guard
+#ifndef SHAPES_H
+#define SHAPES_H

-#include "dll_symbol.h"
-
-#include <cmath>
+#include <vector>
 #include <cstddef>
 #include <stdexcept>
-#include <vector>
+#include <assert.h>
+#include <cmath>
+#include <string>

-
-#if defined(_WIN32)
-#  pragma warning( disable: 4251)
-#endif
 namespace p2t {

 struct Edge;

-struct P2T_DLL_SYMBOL Point {
+struct Point {

  double x, y;

@ -61,7 +59,7 @@ struct P2T_DLL_SYMBOL Point {
  std::vector<Edge*> edge_list;

  /// Construct using coordinates.
-  Point(double x, double y);
+  Point(double x, double y) : x(x), y(y) {}

  /// Set this point to all zeros.
  void set_zero()
@ -123,10 +121,8 @@ struct P2T_DLL_SYMBOL Point {

 };

-P2T_DLL_SYMBOL std::ostream& operator<<(std::ostream&, const Point&);
-
 // Represents a simple polygon's edge
-struct P2T_DLL_SYMBOL Edge {
+struct Edge {

  Point* p, *q;

@ -142,7 +138,9 @@ struct P2T_DLL_SYMBOL Edge {
        p = &p2;
      } else if (p1.x == p2.x) {
        // Repeat points
-        throw std::runtime_error("Edge::Edge: p1 == p2");
+        // ASSIMP_CHANGE (aramis_acg)
+        throw std::runtime_error(std::string("repeat points"));
+        //assert(false);
      }
    }

@ -153,7 +151,7 @@ struct P2T_DLL_SYMBOL Edge {
 // Triangle-based data structures are know to have better performance than quad-edge structures
 // See: J. Shewchuk, "Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator"
 //      "Triangulations in CGAL"
-class P2T_DLL_SYMBOL Triangle {
+class Triangle {
 public:

 /// Constructor
@ -180,7 +178,6 @@ void MarkConstrainedEdge(Point* p, Point* q);
 int Index(const Point* p);
 int EdgeIndex(const Point* p1, const Point* p2);

-Triangle* NeighborAcross(const Point& point);
 Triangle* NeighborCW(const Point& point);
 Triangle* NeighborCCW(const Point& point);
 bool GetConstrainedEdgeCCW(const Point& p);
@ -208,14 +205,12 @@ void ClearDelunayEdges();
 inline bool IsInterior();
 inline void IsInterior(bool b);

+Triangle& NeighborAcross(const Point& opoint);
+
 void DebugPrint();

-bool CircumcicleContains(const Point&) const;
-
 private:

-bool IsCounterClockwise() const;
-
 /// Triangle points
 Point* points_[3];
 /// Neighbor list
@ -263,7 +258,7 @@ inline bool operator ==(const Point& a, const Point& b)

 inline bool operator !=(const Point& a, const Point& b)
 {
-  return !(a.x == b.x) || !(a.y == b.y);
+  return !(a.x == b.x) && !(a.y == b.y);
 }

 /// Peform the dot product on two vectors.
@ -327,7 +322,6 @@ inline void Triangle::IsInterior(bool b)
  interior_ = b;
 }

-/// Is this set a valid delaunay triangulation?
-P2T_DLL_SYMBOL bool IsDelaunay(const std::vector<p2t::Triangle*>&);
-
 }
+
+#endif
--- a/contrib/poly2tri/poly2tri/common/utils.h
+++ b/contrib/poly2tri/poly2tri/common/utils.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,15 +29,14 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#pragma once
+#ifndef UTILS_H
+#define UTILS_H

 // Otherwise #defines like M_PI are undeclared under Visual Studio
 #define _USE_MATH_DEFINES

-#include "shapes.h"
-
-#include <cmath>
 #include <exception>
+#include <math.h>

 // C99 removes M_PI from math.h
 #ifndef M_PI
@ -67,11 +66,7 @@ Orientation Orient2d(const Point& pa, const Point& pb, const Point& pc)
  double detleft = (pa.x - pc.x) * (pb.y - pc.y);
  double detright = (pa.y - pc.y) * (pb.x - pc.x);
  double val = detleft - detright;
-
-// Using a tolerance here fails on concave-by-subepsilon boundaries
-//   if (val > -EPSILON && val < EPSILON) {
-// Using == on double makes -Wfloat-equal warnings yell at us
-  if (std::fpclassify(val) == FP_ZERO) {
+  if (val > -EPSILON && val < EPSILON) {
    return COLLINEAR;
  } else if (val > 0) {
    return CCW;
@ -128,3 +123,5 @@ bool InScanArea(const Point& pa, const Point& pb, const Point& pc, const Point&
 }

 }
+
+#endif
--- a/contrib/poly2tri/poly2tri/poly2tri.h
+++ b/contrib/poly2tri/poly2tri/poly2tri.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,7 +29,10 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#pragma once
+#ifndef POLY2TRI_H
+#define POLY2TRI_H

 #include "common/shapes.h"
 #include "sweep/cdt.h"
+
+#endif
--- a/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
+++ b/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -30,8 +30,6 @@
 */
 #include "advancing_front.h"

-#include <cassert>
-
 namespace p2t {

 AdvancingFront::AdvancingFront(Node& head, Node& tail)
@ -46,21 +44,21 @@ Node* AdvancingFront::LocateNode(double x)
  Node* node = search_node_;

  if (x < node->value) {
-    while ((node = node->prev) != nullptr) {
+    while ((node = node->prev) != NULL) {
      if (x >= node->value) {
        search_node_ = node;
        return node;
      }
    }
  } else {
-    while ((node = node->next) != nullptr) {
+    while ((node = node->next) != NULL) {
      if (x < node->value) {
        search_node_ = node->prev;
        return node->prev;
      }
    }
  }
-  return nullptr;
+  return NULL;
 }

 Node* AdvancingFront::FindSearchNode(double x)
@ -88,13 +86,13 @@ Node* AdvancingFront::LocatePoint(const Point* point)
      }
    }
  } else if (px < nx) {
-    while ((node = node->prev) != nullptr) {
+    while ((node = node->prev) != NULL) {
      if (point == node->point) {
        break;
      }
    }
  } else {
-    while ((node = node->next) != nullptr) {
+    while ((node = node->next) != NULL) {
      if (point == node->point)
        break;
    }
@ -107,4 +105,4 @@ AdvancingFront::~AdvancingFront()
 {
 }

-} // namespace p2t
+}
--- a/contrib/poly2tri/poly2tri/sweep/advancing_front.h
+++ b/contrib/poly2tri/poly2tri/sweep/advancing_front.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,7 +29,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#pragma once
+#ifndef ADVANCED_FRONT_H
+#define ADVANCED_FRONT_H

 #include "../common/shapes.h"

@ -113,3 +114,5 @@ inline void AdvancingFront::set_search(Node* node)
 }

 }
+
+#endif
--- a/contrib/poly2tri/poly2tri/sweep/cdt.cc
+++ b/contrib/poly2tri/poly2tri/sweep/cdt.cc
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2021, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -68,4 +68,4 @@ CDT::~CDT()
  delete sweep_;
 }

-} // namespace p2t
+}
--- a/contrib/poly2tri/poly2tri/sweep/cdt.h
+++ b/contrib/poly2tri/poly2tri/sweep/cdt.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,14 +29,13 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#pragma once
+#ifndef CDT_H
+#define CDT_H

 #include "advancing_front.h"
 #include "sweep_context.h"
 #include "sweep.h"

-#include "../common/dll_symbol.h"
-
 /**
 *
 * @author Mason Green <mason.green@gmail.com>
@ -45,7 +44,7 @@

 namespace p2t {

-class P2T_DLL_SYMBOL CDT
+class CDT
 {
 public:

@ -102,3 +101,5 @@ public:
 };

 }
+
+#endif
--- a/contrib/poly2tri/poly2tri/sweep/sweep.cc
+++ b/contrib/poly2tri/poly2tri/sweep/sweep.cc
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -28,21 +28,24 @@
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+#include <stdexcept>
 #include "sweep.h"
 #include "sweep_context.h"
 #include "advancing_front.h"
 #include "../common/utils.h"

-#include <cassert>
-#include <stdexcept>
-
 namespace p2t {

+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning( disable : 4702 )
+#endif // _MSC_VER
+
 // Triangulate simple polygon with holes
 void Sweep::Triangulate(SweepContext& tcx)
 {
  tcx.InitTriangulation();
-  tcx.CreateAdvancingFront();
+  tcx.CreateAdvancingFront(nodes_);
  // Sweep points; build mesh
  SweepPoints(tcx);
  // Clean up
@ -54,8 +57,8 @@ void Sweep::SweepPoints(SweepContext& tcx)
  for (size_t i = 1; i < tcx.point_count(); i++) {
    Point& point = *tcx.GetPoint(i);
    Node* node = &PointEvent(tcx, point);
-    for (auto& j : point.edge_list) {
-      EdgeEvent(tcx, j, node);
+    for (unsigned int ii = 0; ii < point.edge_list.size(); ii++) {
+      EdgeEvent(tcx, point.edge_list[ii], node);
    }
  }
 }
@ -65,25 +68,17 @@ void Sweep::FinalizationPolygon(SweepContext& tcx)
  // Get an Internal triangle to start with
  Triangle* t = tcx.front()->head()->next->triangle;
  Point* p = tcx.front()->head()->next->point;
-  while (t && !t->GetConstrainedEdgeCW(*p)) {
+  while (!t->GetConstrainedEdgeCW(*p)) {
    t = t->NeighborCCW(*p);
  }

  // Collect interior triangles constrained by edges
-  if (t) {
  tcx.MeshClean(*t);
-  }
 }

 Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
 {
-  Node* node_ptr = tcx.LocateNode(point);
-  if (!node_ptr || !node_ptr->point || !node_ptr->next || !node_ptr->next->point)
-  {
-    throw std::runtime_error("PointEvent - null node");
-  }
-
-  Node& node = *node_ptr;
+  Node& node = tcx.LocateNode(point);
  Node& new_node = NewFrontTriangle(tcx, point, node);

  // Only need to check +epsilon since point never have smaller
@ -116,9 +111,9 @@ void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node* node)

 void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point)
 {
-  if (triangle == nullptr) {
-    throw std::runtime_error("EdgeEvent - null triangle");
-  }
+  if (triangle == nullptr)
+   return;
+
  if (IsEdgeSideOfTriangle(*triangle, ep, eq)) {
    return;
  }
@ -126,14 +121,17 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
  Point* p1 = triangle->PointCCW(point);
  Orientation o1 = Orient2d(eq, *p1, ep);
  if (o1 == COLLINEAR) {
-    if (triangle->Contains(&eq, p1)) {
-      triangle->MarkConstrainedEdge(&eq, p1);
+
+
+    if( triangle->Contains(&eq, p1)) {
+      triangle->MarkConstrainedEdge(&eq, p1 );
      // We are modifying the constraint maybe it would be better to
      // not change the given constraint and just keep a variable for the new constraint
      tcx.edge_event.constrained_edge->q = p1;
-      triangle = triangle->NeighborAcross(point);
-      EdgeEvent(tcx, ep, *p1, triangle, *p1);
+      triangle = &triangle->NeighborAcross(point);
+      EdgeEvent( tcx, ep, *p1, triangle, *p1 );
    } else {
+	  // ASSIMP_CHANGE (aramis_acg)
      throw std::runtime_error("EdgeEvent - collinear points not supported");
    }
    return;
@ -142,14 +140,18 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
  Point* p2 = triangle->PointCW(point);
  Orientation o2 = Orient2d(eq, *p2, ep);
  if (o2 == COLLINEAR) {
-    if (triangle->Contains(&eq, p2)) {
-      triangle->MarkConstrainedEdge(&eq, p2);
+
+
+
+    if( triangle->Contains(&eq, p2)) {
+      triangle->MarkConstrainedEdge(&eq, p2 );
      // We are modifying the constraint maybe it would be better to
      // not change the given constraint and just keep a variable for the new constraint
      tcx.edge_event.constrained_edge->q = p2;
-      triangle = triangle->NeighborAcross(point);
-      EdgeEvent(tcx, ep, *p2, triangle, *p2);
+      triangle = &triangle->NeighborAcross(point);
+      EdgeEvent( tcx, ep, *p2, triangle, *p2 );
    } else {
+      // ASSIMP_CHANGE (aramis_acg)
      throw std::runtime_error("EdgeEvent - collinear points not supported");
    }
    return;
@ -160,13 +162,12 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
    // that will cross edge
    if (o1 == CW) {
      triangle = triangle->NeighborCCW(point);
-    } else {
+    }       else{
      triangle = triangle->NeighborCW(point);
    }
    EdgeEvent(tcx, ep, eq, triangle, point);
  } else {
    // This triangle crosses constraint so lets flippin start!
-    assert(triangle);
    FlipEdgeEvent(tcx, ep, eq, triangle, point);
  }
 }
@ -227,6 +228,7 @@ void Sweep::Fill(SweepContext& tcx, Node& node)
  if (!Legalize(tcx, *triangle)) {
    tcx.MapTriangleToNodes(*triangle);
  }
+
 }

 void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
@ -235,7 +237,7 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
  // Fill right holes
  Node* node = n.next;

-  while (node && node->next) {
+  while (node->next) {
    // if HoleAngle exceeds 90 degrees then break.
    if (LargeHole_DontFill(node)) break;
    Fill(tcx, *node);
@ -245,7 +247,7 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
  // Fill left holes
  node = n.prev;

-  while (node && node->prev) {
+  while (node->prev) {
    // if HoleAngle exceeds 90 degrees then break.
    if (LargeHole_DontFill(node)) break;
    Fill(tcx, *node);
@ -262,35 +264,6 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
 }

 // True if HoleAngle exceeds 90 degrees.
-// LargeHole_DontFill checks if the advancing front has a large hole.
-// A "Large hole" is a triangle formed by a sequence of points in the advancing
-// front where three neighbor points form a triangle.
-// And angle between left-top, bottom, and right-top points is more than 90 degrees.
-// The first part of the algorithm reviews only three neighbor points, e.g. named A, B, C.
-// Additional part of this logic reviews a sequence of 5 points -
-// additionally reviews one point before and one after the sequence of three (A, B, C),
-// e.g. named X and Y.
-// In this case, angles are XBC and ABY and this if angles are negative or more
-// than 90 degrees LargeHole_DontFill returns true.
-// But there is a configuration when ABC has a negative angle but XBC or ABY is less
-// than 90 degrees and positive.
-// Then function LargeHole_DontFill return false and initiates filling.
-// This filling creates a triangle ABC and adds it to the advancing front.
-// But in the case when angle ABC is negative this triangle goes inside the advancing front
-// and can intersect previously created triangles.
-// This triangle leads to making wrong advancing front and problems in triangulation in the future.
-// Looks like such a triangle should not be created.
-// The simplest way to check and fix it is to check an angle ABC.
-// If it is negative LargeHole_DontFill should return true and
-// not initiate creating the ABC triangle in the advancing front.
-// X______A         Y
-//        \        /
-//         \      /
-//          \ B  /
-//           |  /
-//           | /
-//           |/
-//           C
 bool Sweep::LargeHole_DontFill(const Node* node) const {

  const Node* nextNode = node->next;
@ -298,28 +271,20 @@ bool Sweep::LargeHole_DontFill(const Node* node) const {
  if (!AngleExceeds90Degrees(node->point, nextNode->point, prevNode->point))
          return false;

-  if (AngleIsNegative(node->point, nextNode->point, prevNode->point))
-          return true;
-
  // Check additional points on front.
  const Node* next2Node = nextNode->next;
  // "..Plus.." because only want angles on same side as point being added.
-  if ((next2Node != nullptr) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point))
+  if ((next2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point))
          return false;

  const Node* prev2Node = prevNode->prev;
  // "..Plus.." because only want angles on same side as point being added.
-  if ((prev2Node != nullptr) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point))
+  if ((prev2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point))
          return false;

  return true;
 }

-bool Sweep::AngleIsNegative(const Point* origin, const Point* pa, const Point* pb) const {
-    const double angle = Angle(origin, pa, pb);
-    return angle < 0;
-}
-
 bool Sweep::AngleExceeds90Degrees(const Point* origin, const Point* pa, const Point* pb) const {
  const double angle = Angle(origin, pa, pb);
  return ((angle > PI_div2) || (angle < -PI_div2));
@ -341,7 +306,7 @@ double Sweep::Angle(const Point* origin, const Point* pa, const Point* pb) const
   */
  const double px = origin->x;
  const double py = origin->y;
-  const double ax = pa->x - px;
+  const double ax = pa->x- px;
  const double ay = pa->y - py;
  const double bx = pb->x - px;
  const double by = pb->y - py;
@ -634,7 +599,7 @@ void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
    if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
      // Concave
      FillRightConcaveEdgeEvent(tcx, edge, node);
-    } else {
+    } else{
      // Convex
      FillRightConvexEdgeEvent(tcx, edge, node);
      // Retry this one
@ -658,6 +623,7 @@ void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
      }
    }
  }
+
 }

 void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
@ -666,13 +632,13 @@ void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
  if (Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point) == CCW) {
    // Concave
    FillRightConcaveEdgeEvent(tcx, edge, *node.next);
-  } else {
+  } else{
    // Convex
    // Next above or below edge?
    if (Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) {
      // Below
      FillRightConvexEdgeEvent(tcx, edge, *node.next);
-    } else {
+    } else{
      // Above
    }
  }
@ -711,13 +677,13 @@ void Sweep::FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
  if (Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) {
    // Concave
    FillLeftConcaveEdgeEvent(tcx, edge, *node.prev);
-  } else {
+  } else{
    // Convex
    // Next above or below edge?
    if (Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) {
      // Below
      FillLeftConvexEdgeEvent(tcx, edge, *node.prev);
-    } else {
+    } else{
      // Above
    }
  }
@ -733,22 +699,17 @@ void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
      if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
        // Next is concave
        FillLeftConcaveEdgeEvent(tcx, edge, node);
-      } else {
+      } else{
        // Next is convex
      }
    }
  }
+
 }

 void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p)
 {
-  assert(t);
-  Triangle* ot_ptr = t->NeighborAcross(p);
-  if (ot_ptr == nullptr)
-  {
-    throw std::runtime_error("FlipEdgeEvent - null neighbor across");
-  }
-  Triangle& ot = *ot_ptr;
+  Triangle& ot = t->NeighborAcross(p);
  Point& op = *ot.OppositePoint(*t, p);

  if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) {
@ -814,26 +775,10 @@ Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op)
 void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle,
                              Triangle& t, Point& p)
 {
-  Triangle* ot_ptr = t.NeighborAcross(p);
-  if (ot_ptr == nullptr) {
-    throw std::runtime_error("FlipScanEdgeEvent - null neighbor across");
-  }
+  Triangle& ot = t.NeighborAcross(p);
+  Point& op = *ot.OppositePoint(t, p);

-  Point* op_ptr = ot_ptr->OppositePoint(t, p);
-  if (op_ptr == nullptr) {
-    throw std::runtime_error("FlipScanEdgeEvent - null opposing point");
-  }
-
-  Point* p1 = flip_triangle.PointCCW(eq);
-  Point* p2 = flip_triangle.PointCW(eq);
-  if (p1 == nullptr || p2 == nullptr) {
-    throw std::runtime_error("FlipScanEdgeEvent - null on either of points");
-  }
-
-  Triangle& ot = *ot_ptr;
-  Point& op = *op_ptr;
-
-  if (InScanArea(eq, *p1, *p2, op)) {
+  if (InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW(eq), op)) {
    // flip with new edge op->eq
    FlipEdgeEvent(tcx, eq, op, &ot, op);
    // TODO: Actually I just figured out that it should be possible to
@ -843,7 +788,7 @@ void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle&
    // also need to set a new flip_triangle first
    // Turns out at first glance that this is somewhat complicated
    // so it will have to wait.
-  } else {
+  } else{
    Point& newP = NextFlipPoint(ep, eq, ot, op);
    FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP);
  }
@ -852,9 +797,14 @@ void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle&
 Sweep::~Sweep() {

    // Clean up memory
-    for (auto& node : nodes_) {
-      delete node;
+    for(size_t i = 0; i < nodes_.size(); i++) {
+        delete nodes_[i];
    }
+
 }

-} // namespace p2t
+#ifdef _MSC_VER
+#    pragma warning( pop )
+#endif // _MSC_VER
+
+}
--- a/contrib/poly2tri/poly2tri/sweep/sweep.h
+++ b/contrib/poly2tri/poly2tri/sweep/sweep.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -33,10 +33,11 @@
 * Zalik, B.(2008)'Sweep-line algorithm for constrained Delaunay triangulation',
 * International Journal of Geographical Information Science
 *
- * "FlipScan" Constrained Edge Algorithm invented by Thomas Åhlén, thahlen@gmail.com
+ * "FlipScan" Constrained Edge Algorithm invented by Thomas ?hl?n, thahlen@gmail.com
 */

-#pragma once
+#ifndef SWEEP_H
+#define SWEEP_H

 #include <vector>

@ -171,7 +172,6 @@ private:
  // Decision-making about when to Fill hole.
  // Contributed by ToolmakerSteve2
  bool LargeHole_DontFill(const Node* node) const;
-  bool AngleIsNegative(const Point* origin, const Point* pa, const Point* pb) const;
  bool AngleExceeds90Degrees(const Point* origin, const Point* pa, const Point* pb) const;
  bool AngleExceedsPlus90DegreesOrIsNegative(const Point* origin, const Point* pa, const Point* pb) const;
  double Angle(const Point* origin, const Point* pa, const Point* pb) const;
@ -281,3 +281,5 @@ private:
 };

 }
+
+#endif
--- a/contrib/poly2tri/poly2tri/sweep/sweep_context.cc
+++ b/contrib/poly2tri/poly2tri/sweep/sweep_context.cc
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2022, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -34,13 +34,13 @@

 namespace p2t {

-SweepContext::SweepContext(std::vector<Point*> polyline) : points_(std::move(polyline)),
-  front_(nullptr),
-  head_(nullptr),
-  tail_(nullptr),
-  af_head_(nullptr),
-  af_middle_(nullptr),
-  af_tail_(nullptr)
+SweepContext::SweepContext(const std::vector<Point*>& polyline) : points_(polyline),
+  front_(0),
+  head_(0),
+  tail_(0),
+  af_head_(0),
+  af_middle_(0),
+  af_tail_(0)
 {
  InitEdges(points_);
 }
@ -48,8 +48,8 @@ SweepContext::SweepContext(std::vector<Point*> polyline) : points_(std::move(pol
 void SweepContext::AddHole(const std::vector<Point*>& polyline)
 {
  InitEdges(polyline);
-  for (auto i : polyline) {
-    points_.push_back(i);
+  for(unsigned int i = 0; i < polyline.size(); i++) {
+    points_.push_back(polyline[i]);
  }
 }

@ -73,8 +73,8 @@ void SweepContext::InitTriangulation()
  double ymax(points_[0]->y), ymin(points_[0]->y);

  // Calculate bounds.
-  for (auto& point : points_) {
-    Point& p = *point;
+  for (unsigned int i = 0; i < points_.size(); i++) {
+    Point& p = *points_[i];
    if (p.x > xmax)
      xmax = p.x;
    if (p.x < xmin)
@ -87,8 +87,8 @@ void SweepContext::InitTriangulation()

  double dx = kAlpha * (xmax - xmin);
  double dy = kAlpha * (ymax - ymin);
-  head_ = new Point(xmin - dx, ymin - dy);
-  tail_ = new Point(xmax + dx, ymin - dy);
+  head_ = new Point(xmax + dx, ymin - dy);
+  tail_ = new Point(xmin - dx, ymin - dy);

  // Sort points along y-axis
  std::sort(points_.begin(), points_.end(), cmp);
@ -114,17 +114,18 @@ void SweepContext::AddToMap(Triangle* triangle)
  map_.push_back(triangle);
 }

-Node* SweepContext::LocateNode(const Point& point)
+Node& SweepContext::LocateNode(const Point& point)
 {
  // TODO implement search tree
-  return front_->LocateNode(point.x);
+  return *front_->LocateNode(point.x);
 }

-void SweepContext::CreateAdvancingFront()
+void SweepContext::CreateAdvancingFront(const std::vector<Node*>& nodes)
 {

+  (void) nodes;
  // Initial triangle
-  Triangle* triangle = new Triangle(*points_[0], *head_, *tail_);
+  Triangle* triangle = new Triangle(*points_[0], *tail_, *head_);

  map_.push_back(triangle);

@ -171,7 +172,7 @@ void SweepContext::MeshClean(Triangle& triangle)
 	Triangle *t = triangles.back();
 	triangles.pop_back();

-    if (t != nullptr && !t->IsInterior()) {
+    if (t != NULL && !t->IsInterior()) {
      t->IsInterior(true);
      triangles_.push_back(t);
      for (int i = 0; i < 3; i++) {
@ -194,13 +195,17 @@ SweepContext::~SweepContext()
    delete af_middle_;
    delete af_tail_;

-    for (auto ptr : map_) {
+    typedef std::list<Triangle*> type_list;
+
+    for(type_list::iterator iter = map_.begin(); iter != map_.end(); ++iter) {
+        Triangle* ptr = *iter;
        delete ptr;
    }

-    for (auto& i : edge_list) {
-      delete i;
+     for(unsigned int i = 0; i < edge_list.size(); i++) {
+        delete edge_list[i];
    }
+
 }

-} // namespace p2t
+}
--- a/contrib/poly2tri/poly2tri/sweep/sweep_context.h
+++ b/contrib/poly2tri/poly2tri/sweep/sweep_context.h
@ -1,6 +1,6 @@
 /*
- * Poly2Tri Copyright (c) 2009-2022, Poly2Tri Contributors
- * https://github.com/jhasse/poly2tri
+ * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+ * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
@ -29,7 +29,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#pragma once
+#ifndef SWEEP_CONTEXT_H
+#define SWEEP_CONTEXT_H

 #include <list>
 #include <vector>
@ -51,7 +52,7 @@ class SweepContext {
 public:

 /// Constructor
-explicit SweepContext(std::vector<Point*> polyline);
+SweepContext(const std::vector<Point*>& polyline);
 /// Destructor
 ~SweepContext();

@ -65,11 +66,11 @@ Point* tail() const;

 size_t point_count() const;

-Node* LocateNode(const Point& point);
+Node& LocateNode(const Point& point);

 void RemoveNode(Node* node);

-void CreateAdvancingFront();
+void CreateAdvancingFront(const std::vector<Node*>& nodes);

 /// Try to map a node to all sides of this triangle that don't have a neighbor
 void MapTriangleToNodes(Triangle& t);
@ -102,16 +103,15 @@ struct Basin {
  double width;
  bool left_highest;

-  Basin()
-  : left_node(nullptr), bottom_node(nullptr), right_node(nullptr), width(0.0), left_highest(false)
+  Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL), width(0.0), left_highest(false)
  {
  }

  void Clear()
  {
-    left_node = nullptr;
-    bottom_node = nullptr;
-    right_node = nullptr;
+    left_node = NULL;
+    bottom_node = NULL;
+    right_node = NULL;
    width = 0.0;
    left_highest = false;
  }
@ -182,3 +182,5 @@ inline Point* SweepContext::tail() const
 }

 }
+
+#endif
--- a/fuzz/assimp_fuzzer.cc
+++ b/fuzz/assimp_fuzzer.cc
@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;

 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize) {
-    aiLogStream stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT, nullptr);
+    aiLogStream stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
    aiAttachLogStream(&stream);

    Importer importer;
--- a/include/assimp/StringComparison.h
+++ b/include/assimp/StringComparison.h
@ -57,6 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #pragma GCC system_header
 #endif

+#include <assimp/StringComparison.h>
 #include <assimp/ai_assert.h>
 #include <assimp/defs.h>

--- a/include/assimp/cimport.h
+++ b/include/assimp/cimport.h
@ -58,7 +58,6 @@ extern "C" {
 #endif

 struct aiScene;
-struct aiTexture;
 struct aiFileIO;

 typedef void (*aiLogStreamCallback)(const char * /* message */, char * /* user */);
@ -374,13 +373,6 @@ ASSIMP_API void aiGetMemoryRequirements(
        const C_STRUCT aiScene *pIn,
        C_STRUCT aiMemoryInfo *in);

-// --------------------------------------------------------------------------------
-/** Returns an embedded texture, or nullptr.
- * @param pIn Input asset.
- * @param filename Texture path extracted from aiGetMaterialString.
- */
-ASSIMP_API const C_STRUCT aiTexture *aiGetEmbeddedTexture(const C_STRUCT aiScene *pIn, const char *filename);
-
 // --------------------------------------------------------------------------------
 /** Create an empty property store. Property stores are used to collect import
 *  settings.
--- a/include/assimp/config.h.in
+++ b/include/assimp/config.h.in
@ -676,19 +676,6 @@ enum aiComponent
 #define AI_CONFIG_FBX_CONVERT_TO_M \
    "AI_CONFIG_FBX_CONVERT_TO_M"

-// ---------------------------------------------------------------------------
-/** @brief  Set whether the FBX importer shall ignore the provided axis configuration
- *
- * If this property is set to true, the axis directions provided in the FBX file
- * will be ignored and the file will be loaded as is.
- *
- * Set to true for Assimp 5.3.x and earlier behavior
- * Equivalent to AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION
- * Property type: Bool. Default value: false.
- */
-#define AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION \
-    "AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION"
-
 // ---------------------------------------------------------------------------
 /** @brief  Will enable the skeleton struct to store bone data.
 *
@ -737,12 +724,6 @@ enum aiComponent
 */
 #define AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS "IMPORT_MDL_HL1_READ_ANIMATION_EVENTS"

-// ---------------------------------------------------------------------------
-/** @brief Set whether you want to convert the HS1 coordinate system in a special way.
- * The default value is true (S1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_TRANSFORM_COORD_SYSTEM "TRANSFORM COORDSYSTEM FOR HS! MODELS"
 // ---------------------------------------------------------------------------
 /** @brief Set whether the MDL (HL1) importer will read blend controllers.
 * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
--- a/include/assimp/defs.h
+++ b/include/assimp/defs.h
@ -49,16 +49,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_DEFINES_H_INC

 #ifdef __GNUC__
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif

 #include <assimp/config.h>

 //////////////////////////////////////////////////////////////////////////
-/** 
- * @brief Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific file format loader. 
- *
- * The loader is be excluded from the
+/* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
+ * file format loader. The loader is be excluded from the
 * build in this case. 'XX' stands for the most common file
 * extension of the file format. E.g.:
 * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
@ -78,33 +76,34 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //////////////////////////////////////////////////////////////////////////

 #ifndef ASSIMP_BUILD_NO_COMPRESSED_X
-#  define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_Z_INFLATE
 #endif

 #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-#  define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_Z_INFLATE
 #endif

 #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-#  define ASSIMP_BUILD_NEED_Z_INFLATE
-#  define ASSIMP_BUILD_NEED_UNZIP
+#define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_UNZIP
 #endif

 #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-#  define ASSIMP_BUILD_NEED_Z_INFLATE
-#  define ASSIMP_BUILD_NEED_UNZIP
+#define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_UNZIP
 #endif

-/**
- * @brief We need those constants, workaround for any platforms where nobody defined them yet.
- */
+// We need those constants, workaround for any platforms where nobody defined them yet
 #if (!defined SIZE_MAX)
-#  define SIZE_MAX (~((size_t)0))
+#define SIZE_MAX (~((size_t)0))
 #endif

+/*#if (!defined UINT_MAX)
+#define UINT_MAX (~((unsigned int)0))
+#endif*/
+
 //////////////////////////////////////////////////////////////////////////
-/** @brief Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
- *
+/* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
 * post processing step. This is the current list of process names ('XX'):
 * CALCTANGENTS
 * JOINVERTICES
@ -135,50 +134,46 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * OPTIMIZEGRAPH
 * GENENTITYMESHES
 * FIXTEXTUREPATHS
- * GENBOUNDINGBOXES 
- */
+ * GENBOUNDINGBOXES */
+//////////////////////////////////////////////////////////////////////////
+
+#ifdef _WIN32
+#undef ASSIMP_API
+//////////////////////////////////////////////////////////////////////////
+/* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
+//////////////////////////////////////////////////////////////////////////
+#ifdef ASSIMP_BUILD_DLL_EXPORT
+#define ASSIMP_API __declspec(dllexport)
+#define ASSIMP_API_WINONLY __declspec(dllexport)

 //////////////////////////////////////////////////////////////////////////
-/** @brief Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library 
- *
- * Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
- * an external DLL under Windows. Default is static linkage. 
- */
+/* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
+     * an external DLL under Windows. Default is static linkage. */
 //////////////////////////////////////////////////////////////////////////
-#ifdef _WIN32
-#  undef ASSIMP_API
-#  ifdef ASSIMP_BUILD_DLL_EXPORT
-#    define ASSIMP_API __declspec(dllexport)
-#    define ASSIMP_API_WINONLY __declspec(dllexport)
-#  elif (defined ASSIMP_DLL)
-#    define ASSIMP_API __declspec(dllimport)
-#    define ASSIMP_API_WINONLY __declspec(dllimport)
-#  else
-#    define ASSIMP_API
-#    define ASSIMP_API_WINONLY
-#  endif
+#elif (defined ASSIMP_DLL)
+#define ASSIMP_API __declspec(dllimport)
+#define ASSIMP_API_WINONLY __declspec(dllimport)
 #else
-#  define ASSIMP_API __attribute__((visibility("default")))
-#  define ASSIMP_API_WINONLY
+#define ASSIMP_API
+#define ASSIMP_API_WINONLY
+#endif
+#elif defined(SWIG)
+/* Do nothing, the relevant defines are all in AssimpSwigPort.i */
+#else
+#define ASSIMP_API __attribute__((visibility("default")))
+#define ASSIMP_API_WINONLY
 #endif // _WIN32

-/**
- * @brief Helper macros
- *
- * @def   AI_FORCE_INLINE
- * @brief Force the compiler to inline a function, if possible
- *
- * @def   AI_WONT_RETURN
- * @brief Tells the compiler that a function never returns. 
- *
- * Used in code analysis to skip dead paths (e.g. after an assertion evaluated to false).
- */
 #ifdef _MSC_VER
    #pragma warning(disable : 4521 4512 4714 4127 4351 4510)
    #ifdef ASSIMP_BUILD_DLL_EXPORT
        #pragma warning(disable : 4251)
    #endif
+    /* Force the compiler to inline a function, if possible */
    #define AI_FORCE_INLINE inline
+
+    /* Tells the compiler that a function never returns. Used in code analysis
+    * to skip dead paths (e.g. after an assertion evaluated to false). */
    #define AI_WONT_RETURN __declspec(noreturn)
 #elif defined(SWIG)
  /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
@ -228,31 +223,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     * to typedef all structs/enums. */
 //////////////////////////////////////////////////////////////////////////
 #if (defined ASSIMP_DOXYGEN_BUILD)
-#  define C_STRUCT
-#  define C_ENUM
+#define C_STRUCT
+#define C_ENUM
 #else
-#  define C_STRUCT struct
-#  define C_ENUM enum
+#define C_STRUCT struct
+#define C_ENUM enum
 #endif
 #endif

 #if (defined(__BORLANDC__) || defined(__BCPLUSPLUS__))
-#  error Currently, Borland is unsupported. Feel free to port Assimp.
+#error Currently, Borland is unsupported. Feel free to port Assimp.
 #endif

 //////////////////////////////////////////////////////////////////////////
-/**
- * Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
+/* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
     * without threading support. The library doesn't utilize
- * threads then and is itself not threadsafe. 
- */
+     * threads then and is itself not threadsafe. */
 //////////////////////////////////////////////////////////////////////////
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#  define ASSIMP_BUILD_SINGLETHREADED
+#define ASSIMP_BUILD_SINGLETHREADED
 #endif

 #if defined(_DEBUG) || !defined(NDEBUG)
-#  define ASSIMP_BUILD_DEBUG
+#define ASSIMP_BUILD_DEBUG
 #endif

 //////////////////////////////////////////////////////////////////////////
@ -298,74 +291,55 @@ typedef unsigned int ai_uint;
 #ifdef __cplusplus
 constexpr ai_real ai_epsilon = (ai_real) 1e-6;
 #else
-#  define ai_epsilon ((ai_real)1e-6)
+#define ai_epsilon ((ai_real)1e-6)
 #endif

-/**
- * @brief Support for big-endian builds
- * 
- * This will check which byte ordering is used on the target architecture.
- */
+/* Support for big-endian builds */
 #if defined(__BYTE_ORDER__)
-#  if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#    if !defined(__BIG_ENDIAN__)
-#      define __BIG_ENDIAN__
-#    endif
-#  else /* little endian */
-#    if defined(__BIG_ENDIAN__)
-#      undef __BIG_ENDIAN__
-#    endif
-#  endif
+#if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#if !defined(__BIG_ENDIAN__)
+#define __BIG_ENDIAN__
+#endif
+#else /* little endian */
+#if defined(__BIG_ENDIAN__)
+#undef __BIG_ENDIAN__
+#endif
+#endif
 #endif
 #if defined(__BIG_ENDIAN__)
-#  define AI_BUILD_BIG_ENDIAN
+#define AI_BUILD_BIG_ENDIAN
 #endif

 /**
- *  @brief To avoid running out of memory
- *
+ *  To avoid running out of memory
 *  This can be adjusted for specific use cases
 *  It's NOT a total limit, just a limit for individual allocations
 */
 #define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))

 #ifndef _MSC_VER
-#  if __cplusplus >= 201103L // C++11
-#    define AI_NO_EXCEPT noexcept
-#  else
-#    define AI_NO_EXCEPT
-#  endif
+#if __cplusplus >= 201103L // C++11
+#define AI_NO_EXCEPT noexcept
 #else
-#  if (_MSC_VER >= 1915)
-#    define AI_NO_EXCEPT noexcept
-#  else
-#    define AI_NO_EXCEPT
-#  endif
+#define AI_NO_EXCEPT
+#endif
+#else
+#if (_MSC_VER >= 1915)
+#define AI_NO_EXCEPT noexcept
+#else
+#define AI_NO_EXCEPT
+#endif
 #endif // _MSC_VER

 /**
- *  @brief Helper macro to set a pointer to NULL in debug builds
+ *  Helper macro to set a pointer to NULL in debug builds
 */
 #if (defined ASSIMP_BUILD_DEBUG)
-#  define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
+#define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
 #else
-#  define AI_DEBUG_INVALIDATE_PTR(x)
+#define AI_DEBUG_INVALIDATE_PTR(x)
 #endif

 #define AI_COUNT_OF(X) (sizeof(X) / sizeof((X)[0]))

-/**
- * @brief Will mark functions or classes as deprecated.
- *
- * Deprecation means that we will remove this function, class or methods in the next m
- */
-#if defined(__GNUC__) || defined(__clang__)
-#  define AI_DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#  define AI_DEPRECATED __declspec(deprecated)
-#else
-#  pragma message("WARNING: You need to implement DEPRECATED for this compiler")
-#  define AI_DEPRECATED
-#endif
-
 #endif // !! AI_DEFINES_H_INC
--- a/include/assimp/material.h
+++ b/include/assimp/material.h
@ -292,14 +292,6 @@ enum aiTextureType {
    aiTextureType_DIFFUSE_ROUGHNESS = 16,
    aiTextureType_AMBIENT_OCCLUSION = 17,

-    /** Unknown texture
-     *
-     *  A texture reference that does not match any of the definitions
-     *  above is considered to be 'unknown'. It is still imported,
-     *  but is excluded from any further post-processing.
-    */
-    aiTextureType_UNKNOWN = 18,
-
    /** PBR Material Modifiers
    * Some modern renderers have further PBR modifiers that may be overlaid
    * on top of the 'base' PBR materials for additional realism.
@ -326,20 +318,20 @@ enum aiTextureType {
    */
    aiTextureType_TRANSMISSION = 21,

-    /**
-     * Maya material declarations
+    /** Unknown texture
+     *
+     *  A texture reference that does not match any of the definitions
+     *  above is considered to be 'unknown'. It is still imported,
+     *  but is excluded from any further post-processing.
    */
-    aiTextureType_MAYA_BASE = 22,
-    aiTextureType_MAYA_SPECULAR = 23,
-    aiTextureType_MAYA_SPECULAR_COLOR = 24,
-    aiTextureType_MAYA_SPECULAR_ROUGHNESS = 25,
+    aiTextureType_UNKNOWN = 18,

 #ifndef SWIG
    _aiTextureType_Force32Bit = INT_MAX
 #endif
 };

-#define AI_TEXTURE_TYPE_MAX aiTextureType_MAYA_SPECULAR_ROUGHNESS
+#define AI_TEXTURE_TYPE_MAX aiTextureType_TRANSMISSION

 // -------------------------------------------------------------------------------
 /**
@ -701,7 +693,7 @@ struct aiMaterialProperty {
 *  Material data is stored using a key-value structure. A single key-value
 *  pair is called a 'material property'. C++ users should use the provided
 *  member functions of aiMaterial to process material properties, C users
-*  have to stick with the aiGetMaterialXXX family of unbound functions.
+*  have to stick with the aiMaterialGetXXX family of unbound functions.
 *  The library defines a set of standard keys (AI_MATKEY_XXX).
 */
 #ifdef __cplusplus
--- a/include/assimp/module.modulemap
+++ b/include/assimp/module.modulemap
@ -1,33 +0,0 @@
-// Export headers for Swift (iOS)
-module libassimp {
-    header "ColladaMetaData.h"
-    header "GltfMaterial.h"
-    header "ObjMaterial.h"
-    header "anim.h"
-    header "camera.h"
-    header "cexport.h"
-    header "cfileio.h"
-    header "cimport.h"
-    header "color4.h"
-    header "commonMetaData.h"
-    header "config.h"
-    header "defs.h"
-    header "importerdesc.h"
-    header "light.h"
-    header "material.h"
-    header "matrix3x3.h"
-    header "matrix4x4.h"
-    header "mesh.h"
-    header "metadata.h"
-    header "pbrmaterial.h"
-    header "postprocess.h"
-    header "quaternion.h"
-    header "revision.h"
-    header "scene.h"
-    header "texture.h"
-    header "types.h"
-    header "vector2.h"
-    header "vector3.h"
-    header "version.h"
-    export *
-}
--- a/include/assimp/scene.h
+++ b/include/assimp/scene.h
@ -401,9 +401,8 @@ struct ASSIMP_API aiScene {
    //! Returns a short filename from a full path
    static const char* GetShortFilename(const char* filename) {
        const char* lastSlash = strrchr(filename, '/');
-        const char* lastBackSlash = strrchr(filename, '\\');
-        if (lastSlash < lastBackSlash) {
-            lastSlash = lastBackSlash;
+        if (lastSlash == nullptr) {
+            lastSlash = strrchr(filename, '\\');
        }
        const char* shortFilename = lastSlash != nullptr ? lastSlash + 1 : filename;
        return shortFilename;
--- a/port/PyAssimp/pyassimp/structs.py
+++ b/port/PyAssimp/pyassimp/structs.py
@ -1,6 +1,6 @@
 #-*- coding: utf-8 -*-

-from ctypes import POINTER, c_void_p, c_uint, c_char, c_float, Structure, c_double, c_ubyte, c_size_t, c_uint32, c_int
+from ctypes import POINTER, c_void_p, c_uint, c_char, c_float, Structure, c_double, c_ubyte, c_size_t, c_uint32


 class Vector2D(Structure):
@ -78,7 +78,7 @@ class String(Structure):
            #  the number of bytes from the beginning of the string to its end.
            ("length", c_uint32),

-            # String buffer. Size limit is AI_MAXLEN
+            # String buffer. Size limit is MAXLEN
            ("data", c_char*AI_MAXLEN),
        ]

@ -1010,54 +1010,6 @@ class Animation(Structure):

        ]

-class SkeletonBone(Structure):
-    """
-    See 'mesh.h' for details
-    """
-    _fields_ = [
-            # The parent bone index, is -1 one if this bone represents the root bone.
-            ("mParent", c_int),
-
-            # The number of weights
-            ("mNumnWeights", c_uint),
-
-            # The mesh index, which will get influenced by the weight
-            ("mMeshId", POINTER(Mesh)),
-
-            # The influence weights of this bone, by vertex index.
-            ("mWeights", POINTER(VertexWeight)),
-
-            #  Matrix that transforms from bone space to mesh space in bind pose.
-            #
-            #  This matrix describes the position of the mesh
-            #  in the local space of this bone when the skeleton was bound.
-            #  Thus it can be used directly to determine a desired vertex position,
-            #  given the world-space transform of the bone when animated,
-            #  and the position of the vertex in mesh space.
-            #
-            #  It is sometimes called an inverse-bind matrix,
-            #  or inverse bind pose matrix
-            ("mOffsetMatrix", Matrix4x4),
-
-            # Matrix that transforms the locale bone in bind pose.
-            ("mLocalMatrix", Matrix4x4)
-    ]
-
-class Skeleton(Structure):
-    """
-    See 'mesh.h' for details
-    """
-    _fields_ = [
-             # Name
-             ("mName", String),
-
-             # Number of bones
-             ("mNumBones", c_uint),
-
-             # Bones
-             ("mBones", POINTER(POINTER(SkeletonBone)))
-    ]
-
 class ExportDataBlob(Structure):
    """
    See 'cexport.h' for details.
@ -1179,15 +1131,6 @@ class Scene(Structure):
            # can be used to store format-specific metadata as well.
            ("mMetadata", POINTER(Metadata)),

-            # The name of the scene itself
-            ("mName", String),
-
-            # Number of skeletons
-            ("mNumSkeletons", c_uint),
-
-            # Skeletons
-            ("mSkeletons", POINTER(POINTER(Skeleton))),
-
            # Internal data, do not touch
            ("mPrivate", POINTER(c_char)),
        ]
--- a/port/iOS/README.md
+++ b/port/iOS/README.md
@ -1,13 +1,7 @@
 # assimp for iOS
 (deployment target 6.0+, 32/64bit)

-### Requirements 
- cmake
- pkg-config
-
-Note: all these packages can be installed with [brew](https://brew.sh)
-
-Builds assimp libraries for several iOS CPU architectures at once, and outputs a fat binary / XCFramework from the result.
+Builds assimp libraries for several iOS CPU architectures at once, and outputs a fat binary from the result.

 Run the **build.sh** script from the ```./port/iOS/``` directory. See **./build.sh --help** for information about command line options. 

@ -21,11 +15,11 @@ shadeds-Mac:iOS arul$ ./build.sh --help
 Example:
 ```bash
 cd ./port/iOS/
-./build.sh --stdlib=libc++ --archs="arm64 x86_64" --no-fat --min-version="16.0"
+./build.sh --stdlib=libc++ --archs="armv7 arm64 i386"
 ```
 Supported architectures/devices:

-### Simulator [CPU Architectures](https://docs.elementscompiler.com/Platforms/Cocoa/CpuArchitectures/)
+### Simulator
 - i386
 - x86_64
 
--- a/port/iOS/build.sh
+++ b/port/iOS/build.sh
@ -76,7 +76,7 @@ build_arch()

    rm CMakeCache.txt
    
-    CMAKE_CLI_INPUT="-DCMAKE_C_COMPILER=$CMAKE_C_COMPILER -DCMAKE_CXX_COMPILER=$CMAKE_CXX_COMPILER -DCMAKE_TOOLCHAIN_FILE=./port/iOS/IPHONEOS_$(echo $1 | tr '[:lower:]' '[:upper:]')_TOOLCHAIN.cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DBUILD_SHARED_LIBS=$BUILD_SHARED_LIBS -DASSIMP_BUILD_ZLIB=ON"
+    CMAKE_CLI_INPUT="-DCMAKE_C_COMPILER=$CMAKE_C_COMPILER -DCMAKE_CXX_COMPILER=$CMAKE_CXX_COMPILER -DCMAKE_TOOLCHAIN_FILE=./port/iOS/IPHONEOS_$(echo $1 | tr '[:lower:]' '[:upper:]')_TOOLCHAIN.cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DBUILD_SHARED_LIBS=$BUILD_SHARED_LIBS"
    
    echo "[!] Running CMake with -G 'Unix Makefiles' $CMAKE_CLI_INPUT"
    
@ -102,7 +102,6 @@ CPP_STD_LIB=${CPP_STD_LIB_LIST[0]}
 CPP_STD=${CPP_STD_LIST[0]}
 DEPLOY_ARCHS=${BUILD_ARCHS_ALL[*]}
 DEPLOY_FAT=1
-DEPLOY_XCFramework=1

 for i in "$@"; do
    case $i in
@ -118,11 +117,6 @@ for i in "$@"; do
        DEPLOY_ARCHS=`echo $i | sed 's/[-a-zA-Z0-9]*=//'`
        echo "[!] Selecting architectures: $DEPLOY_ARCHS"
    ;;
-    --min-version=*)
-        MIN_IOS_VERSION=`echo $i | sed 's/[-a-zA-Z0-9]*=//'`
-        IOS_SDK_TARGET=$MIN_IOS_VERSION
-        echo "[!] Selecting minimum iOS version: $MIN_IOS_VERSION"
-    ;;
    --debug)
    	BUILD_TYPE=Debug        
        echo "[!] Selecting build type: Debug"
@ -135,17 +129,11 @@ for i in "$@"; do
        DEPLOY_FAT=0
        echo "[!] Fat binary will not be created."
    ;;
-    --no-xcframework)
-        DEPLOY_XCFramework=0
-        echo "[!] XCFramework will not be created."
-    ;;
    -h|--help)
        echo " - don't build fat library (--no-fat)."
-        echo " - don't build XCFramework (--no-xcframework)."
        echo " - Include debug information and symbols, no compiler optimizations (--debug)."
        echo " - generate dynamic libraries rather than static ones (--shared-lib)."
        echo " - supported architectures (--archs):  $(echo $(join , ${BUILD_ARCHS_ALL[*]}) | sed 's/,/, /g')"
-        echo " - minimum iOS version (--min-version): 16.0"
        echo " - supported C++ STD libs (--stdlib): $(echo $(join , ${CPP_STD_LIB_LIST[*]}) | sed 's/,/, /g')"
        echo " - supported C++ standards (--std): $(echo $(join , ${CPP_STD_LIST[*]}) | sed 's/,/, /g')"
        exit
@ -208,32 +196,3 @@ if [[ "$DEPLOY_FAT" -eq 1 ]]; then
    
    echo "[!] Done! The fat binaries can be found at $BUILD_DIR"
 fi
-
-make_xcframework()
-{
-    LIB_NAME=$1
-    FRAMEWORK_PATH=$BUILD_DIR/$LIB_NAME.xcframework   
-
-    ARGS = ""
-    for ARCH_TARGET in $DEPLOY_ARCHS; do
-        if [[ "$BUILD_SHARED_LIBS" =~ "ON" ]]; then
-            ARGS="$ARGS -library $BUILD_DIR/$ARCH_TARGET/$LIB_NAME.dylib -headers ./include "
-        else
-            ARGS="$ARGS -library $BUILD_DIR/$ARCH_TARGET/$LIB_NAME.a -headers ./include "
-        fi
-    done
-
-    xcodebuild -create-xcframework $ARGS -output $FRAMEWORK_PATH
-}
-
-if [[ "$DEPLOY_XCFramework" -eq 1 ]]; then
-    echo '[+] Creating XCFramework ...'
-
-    if [[ "$BUILD_TYPE" =~ "Debug" ]]; then
-        make_xcframework 'libassimpd'
-    else
-        make_xcframework 'libassimp'
-    fi
-
-    echo "[!] Done! The XCFramework can be found at $BUILD_DIR"
-fi
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -100,7 +100,6 @@ SET( COMMON
  unit/Common/utBase64.cpp
  unit/Common/utHash.cpp
  unit/Common/utBaseProcess.cpp
-  unit/Common/utLogger.cpp
 )

 SET(Geometry 
--- a/test/models/PLY/payload_JVN42386607
+++ b/test/models/PLY/payload_JVN42386607
--- a/test/unit/Common/utLogger.cpp
+++ b/test/unit/Common/utLogger.cpp
@ -1,52 +0,0 @@
-/*
---------------------------------------------------------------------------
-Open Asset Import Library (assimp)
---------------------------------------------------------------------------
-
-Copyright (c) 2006-2024, 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 "UnitTestPCH.h"
-#include <assimp/Importer.hpp>
-
-using namespace Assimp;
-class utLogger : public ::testing::Test {};
-
-TEST_F(utLogger, aiGetPredefinedLogStream_leak_test) {
-    aiLogStream stream1 = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT, nullptr);
-    aiLogStream stream2 = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT, nullptr);
-    ASSERT_EQ(stream1.callback, stream2.callback);
-}
--- a/test/unit/utFBXImporterExporter.cpp
+++ b/test/unit/utFBXImporterExporter.cpp
@ -311,37 +311,6 @@ TEST_F(utFBXImporterExporter, sceneMetadata) {
    }
 }

-TEST_F(utFBXImporterExporter, importCustomAxes) {
-    // see https://github.com/assimp/assimp/issues/5494
-    Assimp::Importer importer;
-    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/embedded_ascii/box.FBX", aiProcess_ValidateDataStructure);
-    EXPECT_NE(nullptr, scene);
-
-    // The ASCII box has customised the Up and Forward axes, verify that the RootNode transform has applied it
-    ASSERT_FALSE(scene->mRootNode->mTransformation.IsIdentity()) << "Did not apply the custom axis transform";
-
-    aiVector3D upVec{ 0, 0, 1 }; // Up is +Z
-    aiVector3D forwardVec{ 0, -1, 0 }; // Forward is -Y
-    aiVector3D rightVec{ 1, 0, 0 }; // Right is +X
-    aiMatrix4x4 mat(rightVec.x, rightVec.y, rightVec.z, 0.0f,
-            upVec.x, upVec.y, upVec.z, 0.0f,
-            forwardVec.x, forwardVec.y, forwardVec.z, 0.0f,
-            0.0f, 0.0f, 0.0f, 1.0f);
-
-    EXPECT_EQ(mat, scene->mRootNode->mTransformation);
-}
-
-TEST_F(utFBXImporterExporter, importIgnoreCustomAxes) {
-    // see https://github.com/assimp/assimp/issues/5494
-    Assimp::Importer importer;
-    importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION, true);
-    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/embedded_ascii/box.FBX", aiProcess_ValidateDataStructure);
-    EXPECT_NE(nullptr, scene);
-
-    // Verify that the RootNode transform has NOT applied the custom axes
-    EXPECT_TRUE(scene->mRootNode->mTransformation.IsIdentity());
-}
-
 TEST_F(utFBXImporterExporter, importCubesWithOutOfRangeFloat) {
    Assimp::Importer importer;
    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/cubes_with_outofrange_float.fbx", aiProcess_ValidateDataStructure);
--- a/test/unit/utFindDegenerates.cpp
+++ b/test/unit/utFindDegenerates.cpp
@ -206,38 +206,3 @@ TEST_F(FindDegeneratesProcessTest, meshRemoval) {
    EXPECT_EQ(scene->mRootNode->mNumMeshes, 1u);
    EXPECT_EQ(scene->mRootNode->mMeshes[0], 0u);
 }
-
-TEST_F(FindDegeneratesProcessTest, invalidVertexIndex) {
-    mProcess->EnableAreaCheck(true);
-    mProcess->EnableInstantRemoval(true);
-    mProcess->ExecuteOnMesh(mMesh);
-
-    std::unique_ptr<aiScene> scene(new aiScene);
-    scene->mNumMeshes = 1;
-    scene->mMeshes = new aiMesh *[1];
-
-    std::unique_ptr<aiMesh> mesh(new aiMesh);
-    mesh->mNumVertices = 1;
-    mesh->mVertices = new aiVector3D[1];
-    mesh->mVertices[0] = aiVector3D{ 0.0f, 0.0f, 0.0f };
-    mesh->mNumFaces = 1;
-    mesh->mFaces = new aiFace[1];
-    mesh->mFaces[0].mNumIndices = 3;
-    mesh->mFaces[0].mIndices = new unsigned int[3];
-    mesh->mFaces[0].mIndices[0] = 0;
-    mesh->mFaces[0].mIndices[1] = 1;
-    mesh->mFaces[0].mIndices[2] = 99999;
-
-    scene->mMeshes[0] = mesh.release();
-
-    scene->mRootNode = new aiNode;
-    scene->mRootNode->mNumMeshes = 1;
-    scene->mRootNode->mMeshes = new unsigned int[1];
-    scene->mRootNode->mMeshes[0] = 0;
-
-    mProcess->Execute(scene.get());
-
-    EXPECT_EQ(scene->mNumMeshes, 1u);
-    EXPECT_EQ(scene->mRootNode->mNumMeshes, 1u);
-    EXPECT_EQ(scene->mRootNode->mMeshes[0], 0u);
-}
--- a/test/unit/utMaterialSystem.cpp
+++ b/test/unit/utMaterialSystem.cpp
@ -260,10 +260,6 @@ TEST_F(MaterialSystemTest, testMaterialTextureTypeEnum) {
        case aiTextureType_METALNESS:
        case aiTextureType_DIFFUSE_ROUGHNESS:
        case aiTextureType_AMBIENT_OCCLUSION:
-        case aiTextureType_MAYA_BASE:
-        case aiTextureType_MAYA_SPECULAR:
-        case aiTextureType_MAYA_SPECULAR_COLOR:
-        case aiTextureType_MAYA_SPECULAR_ROUGHNESS:
        case aiTextureType_SHEEN:
        case aiTextureType_CLEARCOAT:
        case aiTextureType_TRANSMISSION:
--- a/test/unit/utPLYImportExport.cpp
+++ b/test/unit/utPLYImportExport.cpp
@ -89,7 +89,7 @@ TEST_F(utPLYImportExport, exportTest_Success) {

 #endif // ASSIMP_BUILD_NO_EXPORT

-// Test issue 1623, crash when loading two PLY files in a row
+//Test issue 1623, crash when loading two PLY files in a row
 TEST_F(utPLYImportExport, importerMultipleTest) {
    Assimp::Importer importer;
    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/PLY/cube.ply", aiProcess_ValidateDataStructure);
@ -109,7 +109,7 @@ TEST_F(utPLYImportExport, importPLYwithUV) {

    EXPECT_NE(nullptr, scene);
    EXPECT_NE(nullptr, scene->mMeshes[0]);
-    // This test model is using n-gons, so 6 faces instead of 12 tris
+    //This test model is using n-gons, so 6 faces instead of 12 tris
    EXPECT_EQ(6u, scene->mMeshes[0]->mNumFaces);
    EXPECT_EQ(aiPrimitiveType_POLYGON, scene->mMeshes[0]->mPrimitiveTypes);
    EXPECT_EQ(true, scene->mMeshes[0]->HasTextureCoords(0));
@ -121,7 +121,7 @@ TEST_F(utPLYImportExport, importBinaryPLY) {

    EXPECT_NE(nullptr, scene);
    EXPECT_NE(nullptr, scene->mMeshes[0]);
-    // This test model is double sided, so 12 faces instead of 6
+    //This test model is double sided, so 12 faces instead of 6
    EXPECT_EQ(12u, scene->mMeshes[0]->mNumFaces);
 }

@ -160,7 +160,7 @@ TEST_F(utPLYImportExport, vertexColorTest) {
 TEST_F(utPLYImportExport, pointcloudTest) {
    Assimp::Importer importer;

-    // Could not use aiProcess_ValidateDataStructure since it's missing faces.
+    //Could not use aiProcess_ValidateDataStructure since it's missing faces.
    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/PLY/issue623.ply", 0);
    EXPECT_NE(nullptr, scene);

@ -192,7 +192,7 @@ static const char *test_file =

 TEST_F(utPLYImportExport, parseErrorTest) {
    Assimp::Importer importer;
-    // Could not use aiProcess_ValidateDataStructure since it's missing faces.
+    //Could not use aiProcess_ValidateDataStructure since it's missing faces.
    const aiScene *scene = importer.ReadFileFromMemory(test_file, strlen(test_file), 0);
    EXPECT_NE(nullptr, scene);
 }
@ -203,61 +203,3 @@ TEST_F(utPLYImportExport, parseInvalid) {
    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/invalid/crash-30d6d0f7c529b3b66b4131700b7a4580cd7082df.ply", 0);
    EXPECT_EQ(nullptr, scene);
 }
-
-TEST_F(utPLYImportExport, payload_JVN42386607) {
-    Assimp::Importer importer;
-    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/PLY/payload_JVN42386607", 0);
-    EXPECT_EQ(nullptr, scene);
-}
-
-// Tests Issue #5729. Test, if properties defined multiple times. Unclear what to do, better to abort than to crash entirely
-TEST_F(utPLYImportExport, parseInvalidDoubleProperty) {
-    const char data[] = "ply\n"
-                        "format ascii 1.0\n"
-                        "element vertex 4\n"
-                        "property float x\n"
-                        "property float y\n"
-                        "property float z\n"
-                        "element vertex 8\n"
-                        "property float x\n"
-                        "property float y\n"
-                        "property float z\n"
-                        "end_header\n"
-                        "0.0 0.0 0.0 0.0 0.0 0.0\n"
-                        "0.0 0.0 1.0 0.0 0.0 1.0\n"
-                        "0.0 1.0 0.0 0.0 1.0 0.0\n"
-                        "0.0 0.0 1.0\n"
-                        "0.0 1.0 0.0 0.0 0.0 1.0\n"
-                        "0.0 1.0 1.0 0.0 1.0 1.0\n";
-
-    Assimp::Importer importer;
-    const aiScene *scene = importer.ReadFileFromMemory(data, sizeof(data), 0);
-    EXPECT_EQ(nullptr, scene);
-}
-
-// Tests Issue #5729. Test, if properties defined multiple times. Unclear what to do, better to abort than to crash entirely
-TEST_F(utPLYImportExport, parseInvalidDoubleCustomProperty) {
-    const char data[] = "ply\n"
-                        "format ascii 1.0\n"
-                        "element vertex 4\n"
-                        "property float x\n"
-                        "property float y\n"
-                        "property float z\n"
-                        "element name 8\n"
-                        "property float x\n"
-                        "element name 5\n"
-                        "property float x\n"
-                        "end_header\n"
-                        "0.0 0.0 0.0 100.0 10.0\n"
-                        "0.0 0.0 1.0 200.0 20.0\n"
-                        "0.0 1.0 0.0 300.0 30.0\n"
-                        "0.0 1.0 1.0 400.0 40.0\n"
-                        "0.0 0.0 0.0 500.0 50.0\n"
-                        "0.0 0.0 1.0 600.0 60.0\n"
-                        "0.0 1.0 0.0 700.0 70.0\n"
-                        "0.0 1.0 1.0 800.0 80.0\n";
-
-    Assimp::Importer importer;
-    const aiScene *scene = importer.ReadFileFromMemory(data, sizeof(data), 0);
-    EXPECT_EQ(nullptr, scene);
-}
--- a/test/unit/utVersion.cpp
+++ b/test/unit/utVersion.cpp
@ -61,7 +61,7 @@ TEST_F( utVersion, aiGetVersionMinorTest ) {
 }

 TEST_F( utVersion, aiGetVersionPatchTest ) {
-    EXPECT_EQ(aiGetVersionPatch(), 3U );
+    EXPECT_EQ(aiGetVersionPatch(), 1U );
 }

 TEST_F( utVersion, aiGetCompileFlagsTest ) {
Author	SHA1	Message	Date
Kim Kulling	25759eaffa	Update USDLoader.h Fix review finding,	2024-07-18 21:06:03 +02:00
Kim Kulling	6362f86a7c	Update USDLoader.cpp Fix review finding	2024-07-18 21:05:02 +02:00
Kim Kulling	a52aabaf67	Merge branch 'master' into kimkulling/introduce_anim_interpolation_mode	2024-07-18 19:11:58 +02:00