Add allocator impl

See-also: https://bugs.gentoo.org/962559

Signed-off-by: Paul Zander <negril.nx+gentoo@gmail.com>

.clang-format

@@ -70,7 +70,7 @@ IncludeCategories:
   - Regex:           '^<.*'
     Priority:        3
 # IncludeIsMainRegex: '(Test)?$'
-IndentCaseLabels: false 
+IndentCaseLabels: false
 #IndentPPDirectives: AfterHash
 IndentWidth:     4
 # IndentWrappedFunctionNames: false

.coveralls.yml

@@ -1,2 +0,0 @@
-service_name: travis-pro
-repo_token: GZXuNlublKFy7HAewHAZLk5ZwgipTFAOA

.github/dependabot.yml

@@ -1,6 +1,11 @@
 version: 2
 updates:
-  - package-ecosystem: "github-actions"
+- package-ecosystem: "github-actions"
     directory: "/"
     schedule:
       interval: "weekly"
+  - package-ecosystem: "gitsubmodule"
+    directory: "/"  # the .gitmodules file must be placed at the top-level directory of a git working tree
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 15  # Assimp has 15 dependencies

.github/workflows/ccpp.yml

@@ -6,12 +6,148 @@ on:
   pull_request:
     branches: [ master ]
 
+permissions:
+  contents: write # to fetch code (actions/checkout),and release
+
 jobs:
-  job:
+  build:
     name: ${{ matrix.name }}-build-and-test
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
+      matrix:
+        name: [ubuntu-latest-g++, macos-latest-clang++, windows-latest-cl.exe, windows-latest-clang.exe, ubuntu-latest-clang++]
+        # For Windows msvc, for Linux and macOS let's use the clang compiler, use gcc for Linux.
+        include:
+          - name: windows-latest-clang.exe
+            os: windows-latest
+            cxx: clang++.exe
+            cc: clang.exe
+          - name: windows-latest-cl.exe
+            os: windows-latest
+            cxx: cl.exe
+            cc: cl.exe
+          - name: windows-hunter-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
+
+    steps:
+    - name: ccache
+      uses: hendrikmuhs/ccache-action@v1.2
+      
+    - uses: actions/checkout@v6
+      with:
+          submodules: true
+          
+    - uses: lukka/get-cmake@latest
+    
+    - uses: ilammy/msvc-dev-cmd@v1
+    
+    - name: Set Compiler Environment
+      uses: lukka/set-shell-env@v1
+      with:
+        CXX: ${{ matrix.cxx }}
+        CC: ${{ matrix.cc }}
+
+    - name: Cache DX SDK
+      id: dxcache
+      if: contains(matrix.name, 'windows')
+      uses: actions/cache@v4
+      with:
+        path: '${{ github.workspace }}/DX_SDK'
+        key: ${{ runner.os }}-DX_SDK
+        restore-keys: |
+          ${{ runner.os }}-DX_SDK
+
+    - name: Download DXSetup
+      if: contains(matrix.name, 'windows-latest-cl.exe') && steps.dxcache.outputs.cache-hit != 'true'
+      run: |
+        curl -s -o DXSDK_Jun10.exe --location https://download.microsoft.com/download/A/E/7/AE743F1F-632B-4809-87A9-AA1BB3458E31/DXSDK_Jun10.exe
+        cmd.exe /c start /wait .\DXSDK_Jun10.exe /U /O /F /S /P "${{ github.workspace }}\DX_SDK"
+
+    - name: Set Windows specific CMake arguments
+      if: contains(matrix.name, 'windows-latest-cl.exe')
+      id: windows_extra_cmake_args
+      run: echo ":set-output name=args::=-DASSIMP_BUILD_ASSIMP_TOOLS=1 -DASSIMP_BUILD_ASSIMP_VIEW=1" >> $GITHUB_OUTPUT
+    
+    - 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
+
+    - name: configure and build
+      uses: lukka/run-cmake@v3
+      env:
+        DXSDK_DIR: '${{ github.workspace }}/DX_SDK'
+
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        cmakeAppendedArgs: '-GNinja -DCMAKE_BUILD_TYPE=Release ${{ steps.windows_extra_cmake_args.outputs.args }} ${{ steps.hunter_extra_cmake_args.outputs.args }}'
+        buildWithCMakeArgs: '--parallel 24 -v'
+        buildDirectory: '${{ github.workspace }}/build/'
+        
+    - 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
+
+    - name: test
+      run: cd build/bin && ./unit ${{ steps.hunter_extra_test_args.outputs.args }}
+      shell: bash
+
+    - uses: actions/upload-artifact@v5
+      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@v5
+        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.
@@ -41,89 +177,24 @@ jobs:
           - 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: actions/checkout@v3
-    
-    - uses: lukka/get-cmake@latest
-    
-    - uses: ilammy/msvc-dev-cmd@v1
-    
-    - name: Set Compiler Environment
-      if: "!endsWith(matrix.name, 'hunter')"
-      uses: lukka/set-shell-env@v1
-      with:
-        CXX: ${{ matrix.cxx }}
-        CC: ${{ matrix.cc }}
-
-    - name: Set Compiler Environment for Hunter on Windows
-      if: startsWith(matrix.name, 'windows') && endsWith(matrix.name, 'hunter')
-      uses: lukka/set-shell-env@v1
-      with:
-        VS160COMNTOOLS: C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools
-
-    - name: Checkout Hunter toolchains
-      if: endsWith(matrix.name, 'hunter')
-      uses: actions/checkout@v3
-      with:
-        repository: cpp-pm/polly
-        path: cmake/polly
-
-    - name: Remove contrib directory for Hunter builds
-      if: contains(matrix.name, 'hunter')
-      uses: JesseTG/rm@v1.0.3
-      with:
-        path: contrib
-
-    - name: Cache DX SDK
-      id: dxcache
-      if: contains(matrix.name, 'windows')
-      uses: actions/cache@v3
-      with:
-        path: '${{ github.workspace }}/DX_SDK'
-        key: ${{ runner.os }}-DX_SDK
-        restore-keys: |
-          ${{ runner.os }}-DX_SDK
-
-    - name: Download DXSetup
-      if: contains(matrix.name, 'windows') && steps.dxcache.outputs.cache-hit != 'true'
-      run: |
-        curl -s -o DXSDK_Jun10.exe --location https://download.microsoft.com/download/A/E/7/AE743F1F-632B-4809-87A9-AA1BB3458E31/DXSDK_Jun10.exe
-        cmd.exe /c start /wait .\DXSDK_Jun10.exe /U /O /F /S /P "${{ github.workspace }}\DX_SDK"
-
-    - 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"
-    
-    - name: Set Hunter specific CMake arguments
-      if: contains(matrix.name, 'hunter')
-      id: hunter_extra_cmake_args
-      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
-      env:
-        DXSDK_DIR: '${{ github.workspace }}/DX_SDK'
-
-      with:
-        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
-        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
-        cmakeAppendedArgs: '-GNinja -DCMAKE_BUILD_TYPE=Release ${{ steps.windows_extra_cmake_args.outputs.args }} ${{ steps.hunter_extra_cmake_args.outputs.args }}'
-        buildWithCMakeArgs: '-- -j 24 -v'
-        buildDirectory: '${{ github.workspace }}/build/'
-        
-    - name: Exclude certain tests in Hunter specific builds
-      if: contains(matrix.name, 'hunter')
-      id: hunter_extra_test_args
-      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 }}
-      shell: bash
-
-    - uses: actions/upload-artifact@v3
-      if: matrix.name == 'windows-msvc'
-      with:
-        name: 'assimp-bins-${{ matrix.name }}-${{ github.sha }}'
-        path: build/bin
+      - 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@v6
+        with:
+          name: 'assimp-bins-${{ matrix.name }}-${{ github.sha }}'
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: '${{secrets.GITHUB_TOKEN}}'
+        with:
+          files: |
+            *.zip
+ 

.github/workflows/cd.yml

@@ -0,0 +1,52 @@
+name: Build and Publish Prebuilt Binaries
+
+on:
+  release:
+    types: [created]
+    
+jobs:
+  build:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: windows-x64
+            os: windows-latest
+            arch: x64
+          - name: windows-x86
+            os: windows-latest
+            arch: x86
+            cmake_args: -A Win32
+          - name: macos-x64
+            os: macos-13
+          - name: macos-arm64
+            os: macos-latest
+          - name: linux-x64
+            os: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: lukka/get-cmake@latest
+
+      - uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.arch }}
+      
+      - name: Build
+        run: |
+          cmake -B build -S . ${{ matrix.cmake_args }} -DCMAKE_BUILD_TYPE=Release -DASSIMP_BUILD_TESTS=OFF
+          cmake --build build --config Release
+
+      - uses: TheDoctor0/zip-release@0.7.6
+        with:
+          filename: ${{ matrix.name }}-${{ github.event.release.tag_name }}.zip
+          directory: build/bin/
+
+      - uses: softprops/action-gh-release@v2
+        with:
+          files: build/bin/${{ matrix.name }}-${{ github.event.release.tag_name }}.zip
+          append_body: true
+          fail_on_unmatched_files: true

.github/workflows/cifuzz.yml

@@ -0,0 +1,26 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'assimp'
+        dry-run: false
+        language: c++
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'assimp'
+        fuzz-seconds: 300
+        dry-run: false
+        language: c++
+    - name: Upload Crash
+      uses: actions/upload-artifact@v5
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts

.github/workflows/inno_setup

@@ -0,0 +1,51 @@
+name: Build Windows Installer
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+jobs:
+  build:
+    name: Build the Inno Setup Installer
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+      - uses: ilammy/msvc-dev-cmd@v1
+
+
+      - name: Cache DX SDK
+        id: dxcache
+        uses: actions/cache@v4
+        with:
+          path: '${{ github.workspace }}/DX_SDK'
+          key: ${{ runner.os }}-DX_SDK
+          restore-keys: |
+            ${{ runner.os }}-DX_SDK
+
+      - name: Download DXSetup
+        run: |
+          curl -s -o DXSDK_Jun10.exe --location https://download.microsoft.com/download/A/E/7/AE743F1F-632B-4809-87A9-AA1BB3458E31/DXSDK_Jun10.exe
+          cmd.exe /c start /wait .\DXSDK_Jun10.exe /U /O /F /S /P "${{ github.workspace }}\DX_SDK"
+
+      - name: Set Windows specific CMake arguments
+        id: windows_extra_cmake_args
+        run: echo "::set-output name=args::-DASSIMP_BUILD_ASSIMP_TOOLS=1 -DASSIMP_BUILD_ASSIMP_VIEW=1 -DASSIMP_BUILD_ZLIB=1"
+
+      - name: configure and build
+        uses: lukka/run-cmake@v3
+        env:
+          DXSDK_DIR: '${{ github.workspace }}/DX_SDK'
+
+        with:
+          cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+          cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+          cmakeAppendedArgs: '-GNinja -DCMAKE_BUILD_TYPE=Release ${{ steps.windows_extra_cmake_args.outputs.args }} ${{ steps.hunter_extra_cmake_args.outputs.args }}'
+          buildWithCMakeArgs: '--parallel 24 -v'
+          buildDirectory: '${{ github.workspace }}/build/'
+
+      - name: Compile .ISS to .EXE Installer
+        uses: Minionguyjpro/Inno-Setup-Action@v1.2.5
+        with:
+          path: packaging/windows-innosetup/script_x64.iss
+          options: /O+

.github/workflows/sanitizer.yml

@@ -6,12 +6,15 @@ on:
   pull_request:
     branches: [ master ]
 
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
 jobs:
   job1:
     name: adress-sanitizer
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v6
     - uses: lukka/get-cmake@latest    
     - uses: lukka/set-shell-env@v1
       with:
@@ -35,7 +38,7 @@ jobs:
     name: undefined-behavior-sanitizer
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v6
     - uses: lukka/get-cmake@latest    
     - uses: lukka/set-shell-env@v1
       with:
@@ -43,7 +46,7 @@ jobs:
         CC: clang
     
     - name: configure and build
-      uses: lukka/run-cmake@v2
+      uses: lukka/run-cmake@v3
       with:
         cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
         cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
@@ -54,3 +57,13 @@ jobs:
     - name: test
       run: cd build/bin && ./unit
       shell: bash
+
+  job3:
+    name: printf-sanitizer
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    
+    - name: run scan_printf script
+      run: ./scripts/scan_printf.sh
+      shell: bash

.gitignore

@@ -120,3 +120,9 @@ tools/assimp_qt_viewer/ui_mainwindow.h
 
 #Generated directory
 generated/*
+
+# 3rd party cloned repos/tarballs etc
+# meshlab repo, automatically cloned via CMake (to gain 2 source files for VRML file format conversion)
+contrib/meshlab/autoclone
+# tinyusdz repo, automatically cloned via CMake
+contrib/tinyusdz/autoclone

Build.md

@@ -1,36 +1,12 @@
 # Build / Install Instructions
 
-## Install on all platforms using vcpkg
-You can download and install assimp using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
-```bash
-    git clone https://github.com/Microsoft/vcpkg.git
-    cd vcpkg
-    ./bootstrap-vcpkg.sh
-    ./vcpkg integrate install
-    vcpkg install assimp
-```
-The assimp port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
-
-## Install on Ubuntu
-You can install the Asset-Importer-Lib via apt:
-```
-sudo apt-get update
-sudo apt-get install libassimp-dev
-```
-
-## Install pyassimp
-You need to have pip installed:
-```
-pip install pyassimp
-```
-
 ## Manual build instructions
-
-### Install CMake
-Asset-Importer-Lib can be build for a lot of different platforms. We are using cmake to generate the build environment for these via cmake. So you have to make sure that you have a working cmake-installation on your system. You can download it at https://cmake.org/ or for linux install it via
-```bash
-sudo apt-get install cmake
-```
+### Install prerequisites
+You need to install
+* cmake
+* Your compiler (must support C++17 and C99 at least)
+* For Windows
+  *  DX-SDK 9 if you want to use our 3D-Viewer
 
 ### Get the source
 Make sure you have a working git-installation. Open a command prompt and clone the Asset-Importer-Lib via:
@@ -38,37 +14,34 @@ Make sure you have a working git-installation. Open a command prompt and clone t
 git clone https://github.com/assimp/assimp.git
 ```
 ### Build from source:
+* For *assimp.lib* without any tools:
 ```bash
 cd assimp
-cmake CMakeLists.txt 
+cmake CMakeLists.txt
 cmake --build .
 ```
 
-### Build instructions for Windows with Visual-Studio
+* For assimp with the common tools like *assimp-cmd*
+```bash
+cd assimp
+cmake CMakeLists.txt -DASSIMP_BUILD_ASSIMP_TOOLS=ON
+cmake --build .
+```
+Note that by default this builds a shared library into the `bin` directory. If you want to build it as a static library see the build options at the bottom of this file.
 
-First you have to install Visual-Studio on your windows-system. You can get the Community-Version for free here: https://visualstudio.microsoft.com/de/downloads/
+### Build instructions for Windows with Visual-Studio
+First, you have to install Visual-Studio on your windows-system. You can get the Community-Version for free [here](https://visualstudio.microsoft.com/downloads/)
 To generate the build environment for your IDE open a command prompt, navigate to your repo and type:
 ```bash
 cmake CMakeLists.txt
 ```
-This will generate the project files for the visual studio. All dependencies used to build Asset-IMporter-Lib shall be part of the repo. If you want to use you own zlib.installation this is possible as well. Check the options for it.
+This will generate the project files for the visual studio. All dependencies used to build Asset-Importer-Lib shall be part of the repo. If you want to use you own zlib installation this is possible as well. Check the options for it.
 
 ### Build instructions for Windows with UWP
 See <https://stackoverflow.com/questions/40803170/cmake-uwp-using-cmake-to-build-universal-windows-app>
 
-### Build instructions for Linux / Unix
-Open a terminal and got to your repository. You can generate the makefiles and build the library via:
-
-```bash
-cmake CMakeLists.txt
-make -j4
-```
-The option -j descripes the number of parallel processes for the build. In this case make will try to use 4 cores for the build.
-
-If you want to use a IDE for linux you can try QTCreator for instance. 
-
 ### Build instructions for MinGW
- Older versions of MinGW's compiler (e.g. 5.1.0) do not support the -mbig_obj flag 
+ Older versions of MinGW's compiler (e.g. 5.1.0) do not support the -mbig_obj flag
 required to compile some of assimp's files, especially for debug builds.
 Version 7.3.0 of g++-mingw-w64 & gcc-mingw-w64 appears to work.
 
@@ -93,9 +66,9 @@ The cmake-build-environment provides options to configure the build. The followi
 - **ASSIMP_ANDROID_JNIIOSYSTEM (default OFF)**: Android JNI IOSystem support is active.
 - **ASSIMP_NO_EXPORT (default OFF)**: Disable Assimp's export functionality.
 - **ASSIMP_BUILD_ZLIB (default OFF)**: Build our own zlib.
-- **ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT (default ON)**: Build Assimp with all exporter senabled.
-- **ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT (default ON)**: Build Assimp with all importer senabled.
-- **ASSIMP_BUILD_ASSIMP_TOOLS (default ON)**: If the supplementary tools for Assimp are built in addition to the library.
+- **ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT (default ON)**: Build Assimp with all exporters enabled.
+- **ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT (default ON)**: Build Assimp with (most) importers enabled. Currently, USD importer is not included. See ASSIMP_BUILD_USD_IMPORTER.
+- **ASSIMP_BUILD_ASSIMP_TOOLS (default OFF)**: If the supplementary tools for Assimp are built in addition to the library.
 - **ASSIMP_BUILD_SAMPLES (default OFF)**: If the official samples are built as well (needs Glut).
 - **ASSIMP_BUILD_TESTS (default ON)**: If the test suite for Assimp is built in addition to the library.
 - **ASSIMP_COVERALLS (default OFF)**: Enable this to measure test coverage.
@@ -110,3 +83,32 @@ The cmake-build-environment provides options to configure the build. The followi
 - **USE_STATIC_CRT (default OFF)**: Link against the static MSVC runtime libraries.
 - **ASSIMP_BUILD_DRACO (default OFF)**: Build Draco libraries. Primarily for glTF.
 - **ASSIMP_BUILD_ASSIMP_VIEW (default ON, if DirectX found, OFF otherwise)**: Build Assimp view tool (requires DirectX).
+- **ASSIMP_BUILD_USD_IMPORTER (default OFF, requires ASSIMP_WARNINGS_AS_ERRORS to be OFF)**: Build USD importer, defaults to off for CI purposes
+
+### Install prebuild binaries
+## Install on all platforms using vcpkg
+You can download and install assimp using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+```bash
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    ./vcpkg install assimp
+```
+The assimp port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+### Install on Ubuntu
+You can install the Asset-Importer-Lib via apt:
+```
+sudo apt-get update
+sudo apt-get install libassimp-dev
+```
+
+### Install pyassimp
+You need to have pip installed:
+```
+pip install pyassimp
+```
+
+### Get the SDK from itch.io
+Just check [itch.io](https://kimkulling.itch.io/the-asset-importer-lib)

CHANGES

@@ -290,7 +290,7 @@ FEATURES:
 	- Added support for 64 bit version header introduced in FbxSdk2016
 	- Travis: enable coverall support.
 	- PyAssimp: New version of the pyASSIMP 3D viewer, with much improved 3D controls
-    - Morph animation support for collada	
+    - Morph animation support for collada
 	- Added support for parameters Ni and Tf in OBJ/MTL file format
 	- aiScene: add method to add children
 	- Added new option to IFC importer to control tessellation angle + removed unused IFC option
@@ -300,7 +300,7 @@ FEATURES:
 	- travis ci: enable sudo support.
 	- openddlparser: integrate release v0.4.0
 	- aiMetaData: Added support for metadata in assbin format
-	
+
 FIXES/HOUSEKEEPING:
     - Introduce usage of #pragma statement
 	- Put cmake-scripts into their own folder
@@ -352,7 +352,7 @@ FIXES/HOUSEKEEPING:
 	- add vertex color export support ( issue 809 )
 	- Fix memory leak in Collada importer ( issue 1169 )
 	- add stp to the list of supported extensions for step-files ( issue 1183 )
-	- fix clang build ( Issue-1169 ) 
+	- fix clang build ( Issue-1169 )
 	- fix for FreeBSD
 	- Import FindPkgMacros to main CMake Configuration
 	- Extended support for tessellation parameter to more IFC shapes
@@ -375,7 +375,7 @@ FIXES/HOUSEKEEPING:
 	- Obj-Importer: do not break when detecting an overflow ( issue 1244 )
 	- Obj-Importer: fix parsing of multible line data definitions
 	- Fixed bug where IFC models with multiple IFCSite only loaded 1 site instead of the complete model
-	- PLYImporter: - optimize memory and speed on ply importer / change parser to use a file stream - manage texture path in ply 
+	- PLYImporter: - optimize memory and speed on ply importer / change parser to use a file stream - manage texture path in ply
 	  import - manage texture coords on faces in ply import - correction on point cloud faces generation
 	- Utf8: integrate new lib ( issue 1158 )
 	- fixed CMAKE_MODULE_PATH overwriting previous values
@@ -400,7 +400,7 @@ FIXES/HOUSEKEEPING:
 	- Remove std functions deprecated by C++11.
 	- X-Importer: make it deal with lines
 	- use correct path for compilers ( issue 1335 )
-	- Collada: add workaround to deal with polygon with holes 
+	- Collada: add workaround to deal with polygon with holes
 	- update python readme
 	- Use unique node names when loading Collada files
 	- Fixed many FBX bugs
@@ -429,7 +429,7 @@ FEATURES:
     - C4D: update to latest Melange-SDK
     - Add a gitter channel
     - Coverity check enabled
-    - Switch to <...> include brackets for public headers 
+    - Switch to <...> include brackets for public headers
     - Enable export by pyAssimp
     - CI: check windows build
     - Add functionality to perform a singlepost-processing step
@@ -564,7 +564,7 @@ API CHANGES:
      currently used, however ...)
    - Some Assimp::Importer methods are const now.
 
-   
+
 1.1 (2010-04-17)
 This is the list of relevant changes from the 1.0 (r412) release to 1.1 (r700).
 

CMakeLists.txt

@@ -1,6 +1,6 @@
 # Open Asset Import Library (assimp)
 # ----------------------------------------------------------------------
-# Copyright (c) 2006-2022, assimp team
+# Copyright (c) 2006-2025, assimp team
 #
 # All rights reserved.
 #
@@ -38,25 +38,76 @@ SET(CMAKE_POLICY_DEFAULT_CMP0012 NEW)
 SET(CMAKE_POLICY_DEFAULT_CMP0074 NEW)
 SET(CMAKE_POLICY_DEFAULT_CMP0092 NEW)
 
-CMAKE_MINIMUM_REQUIRED( VERSION 3.10 )
+CMAKE_MINIMUM_REQUIRED( VERSION 3.22 )
+
+#================================================================================#
+#                    Model formats not enabled by default
+#
+#    3rd party projects may not adhere to strict standards enforced by assimp,
+#    in which case those formats must be opt-in; otherwise the 3rd party code
+#    would fail assimp CI checks
+#================================================================================#
+# M3D format import support (assimp integration no longer supported by M3D format author)
+# User may override these in their CMake script to provide M3D import/export support
+# (M3D importer/exporter was disabled for assimp release 5.1 or later)
+OPTION(ASSIMP_BUILD_M3D_IMPORTER "Enable M3D file import" off)
+OPTION(ASSIMP_BUILD_M3D_EXPORTER "Enable M3D file export" off)
+
+# Experimental USD importer: disabled, need to opt-in
+# Note: assimp github PR automatic checks will fail the PR due to compiler warnings in
+# the external, 3rd party tinyusdz code which isn't technically part of the PR since it's
+# 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)
+
+# VRML (.wrl/.x3dv) file import support by leveraging X3D importer and 3rd party file
+# format converter to convert .wrl/.x3dv files to X3D-compatible .xml
+# (Need to make this opt-in because 3rd party code triggers lots of CI code quality warnings)
+OPTION(ASSIMP_BUILD_VRML_IMPORTER "Enable VRML (.wrl/.x3dv) file import" off)
+
+#--------------------------------------------------------------------------------#
+#                  Internal impl for optional model formats
+#--------------------------------------------------------------------------------#
+# Internal/private M3D logic
+if (NOT ASSIMP_BUILD_M3D_IMPORTER)
+    ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_IMPORTER)
+endif () # if (not ASSIMP_BUILD_M3D_IMPORTER)
+if (NOT ASSIMP_BUILD_M3D_EXPORTER)
+    ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_EXPORTER)
+endif () # if (not ASSIMP_BUILD_M3D_EXPORTER)
+
+# Internal/private VRML logic
+if (NOT ASSIMP_BUILD_VRML_IMPORTER)
+    ADD_DEFINITIONS( -DASSIMP_BUILD_NO_VRML_IMPORTER)
+endif () # if (not ASSIMP_BUILD_VRML_IMPORTER)
+#================================================================================#
+
+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
-ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_IMPORTER)
-ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_EXPORTER)
 # Toggles the use of the hunter package manager
 option(ASSIMP_HUNTER_ENABLED "Enable Hunter package manager support" OFF)
 
 IF(ASSIMP_HUNTER_ENABLED)
   include("cmake-modules/HunterGate.cmake")
   HunterGate(
-    URL "https://github.com/cpp-pm/hunter/archive/v0.24.0.tar.gz"
-    SHA1 "a3d7f4372b1dcd52faa6ff4a3bd5358e1d0e5efd"
+    URL "https://github.com/cpp-pm/hunter/archive/v0.25.8.tar.gz"
+    SHA1 "26c79d587883ec910bce168e25f6ac4595f97033"
   )
-
-  add_definitions(-DASSIMP_USE_HUNTER)
+  ADD_DEFINITIONS(-DASSIMP_USE_HUNTER)
 ENDIF()
 
-PROJECT(Assimp VERSION 5.2.4)
+PROJECT(Assimp VERSION 6.0.2
+  LANGUAGES C CXX
+  DESCRIPTION "Open Asset Import Library (Assimp) is a library to import various well-known 3D model formats in a uniform manner."
+)
 
 # All supported options ###############################################
 
@@ -84,10 +135,6 @@ OPTION( ASSIMP_NO_EXPORT
   "Disable Assimp's export functionality."
   OFF
 )
-OPTION( ASSIMP_BUILD_ZLIB
-  "Build your own zlib"
-  OFF
-)
 OPTION( ASSIMP_BUILD_ASSIMP_TOOLS
   "If the supplementary tools for Assimp are built in addition to the library."
   OFF
@@ -135,24 +182,36 @@ OPTION ( ASSIMP_IGNORE_GIT_HASH
 )
 
 IF (WIN32)
-  # Use subset of Windows.h
+  OPTION( ASSIMP_BUILD_ZLIB
+    "Build your zlib"
+    ON
+  )
+ELSE()
+  OPTION( ASSIMP_BUILD_ZLIB
+    "Build your zlib"
+    OFF
+  )
+ENDIF()
+
+IF (WIN32)
+  # Use a subset of Windows.h
   ADD_DEFINITIONS( -DWIN32_LEAN_AND_MEAN )
 
   IF(MSVC)
     OPTION( ASSIMP_INSTALL_PDB
-      "Install MSVC debug files."
+      "Create MSVC debug symbol files and add to Install target."
       ON )
     IF(NOT (MSVC_VERSION LESS 1900))
-      # Multibyte character set is deprecated since at least MSVC2015 (possibly earlier)
+      # Multibyte character set has been deprecated since at least MSVC2015 (possibly earlier)
       ADD_DEFINITIONS( -DUNICODE -D_UNICODE )
     ENDIF()
 
-    # Link statically against c/c++ lib to avoid missing redistriburable such as
+    # Link statically against c/c++ lib to avoid missing redistributable such as
     # "VCRUNTIME140.dll not found. Try reinstalling the app.", but give users
     # a choice to opt for the shared runtime if they want.
     option(USE_STATIC_CRT "Link against the static runtime libraries." OFF)
 
-    # The CMAKE_CXX_FLAGS vars can be overriden by some Visual Studio generators, so we use an alternative
+    # The CMAKE_CXX_FLAGS vars can be overridden by some Visual Studio generators, so we use an alternative
     # global method here:
     if (${USE_STATIC_CRT})
       add_compile_options(
@@ -190,15 +249,12 @@ SET (ASSIMP_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
 SET (ASSIMP_VERSION_MINOR ${PROJECT_VERSION_MINOR})
 SET (ASSIMP_VERSION_PATCH ${PROJECT_VERSION_PATCH})
 SET (ASSIMP_VERSION ${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH})
-SET (ASSIMP_SOVERSION 5)
+SET (ASSIMP_SOVERSION 6)
 
 SET( ASSIMP_PACKAGE_VERSION "0" CACHE STRING "the package-specific version used for uploading the sources" )
-if(NOT ASSIMP_HUNTER_ENABLED)
-  # Enable C++17 support globally
-  set(CMAKE_CXX_STANDARD 17)
-  set(CMAKE_CXX_STANDARD_REQUIRED ON)
-  set(CMAKE_C_STANDARD 99)
-endif()
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_C_STANDARD 99)
 
 IF(NOT ASSIMP_IGNORE_GIT_HASH)
   # Get the current working branch
@@ -245,53 +301,77 @@ SET(ASSIMP_LIBRARY_SUFFIX "" CACHE STRING "Suffix to append to library names")
 IF( UNIX )
   # Use GNUInstallDirs for Unix predefined directories
   INCLUDE(GNUInstallDirs)
-  # Ensure that we do not run into issues like http://www.tcm.phy.cam.ac.uk/sw/inodes64.html on 32 bit linux
-  IF( ${OPERATING_SYSTEM} MATCHES "Android")
-  ELSE()
-    IF ( CMAKE_SIZEOF_VOID_P EQUAL 4) # only necessary for 32-bit linux
+  # Ensure that we do not run into issues like http://www.tcm.phy.cam.ac.uk/sw/inodes64.html on 32 bit Linux
+  IF(NOT ${OPERATING_SYSTEM} MATCHES "Android")
+    IF ( CMAKE_SIZEOF_VOID_P EQUAL 4) # only necessary for 32-bit Linux
       ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64 )
     ENDIF()
   ENDIF()
 ENDIF()
 
+IF(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND WIN32)
+  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
+  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
+ENDIF()
+
+IF( MSVC OR "${CMAKE_CXX_SIMULATE_ID}" MATCHES "MSVC") # clang with MSVC ABI
+  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
+  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
+endif ()
+
+
 # Grouped compiler settings ########################################
-IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT MINGW)
+IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT MINGW AND NOT HAIKU)
   IF(NOT ASSIMP_HUNTER_ENABLED)
-    SET(CMAKE_CXX_STANDARD 17)
     SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
   ENDIF()
+
+  IF(CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 13 AND CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+    MESSAGE(STATUS "GCC13 detected disabling \"-Wdangling-reference\" in Cpp files as it appears to be a false positive")
+    ADD_COMPILE_OPTIONS("$<$<COMPILE_LANGUAGE:CXX>:-Wno-dangling-reference>")
+  ENDIF()
   # hide all not-exported symbols
   IF(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "mips64" )
-	SET(CMAKE_CXX_FLAGS "-mxgot -fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}")
-	SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}")
-	SET(LIBSTDC++_LIBRARIES -lstdc++)
+    SET(CMAKE_CXX_FLAGS "-mxgot -fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}")
+    SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}")
+    SET(LIBSTDC++_LIBRARIES -lstdc++)
   ELSE()
-	SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}")
-	SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}")
-	SET(LIBSTDC++_LIBRARIES -lstdc++)
+    SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}")
+    SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}")
+    SET(LIBSTDC++_LIBRARIES -lstdc++)
   ENDIF()
 ELSEIF(MSVC)
   # enable multi-core compilation with MSVC
   IF(CMAKE_CXX_COMPILER_ID MATCHES "Clang" ) # clang-cl
-    ADD_COMPILE_OPTIONS(/bigobj /W4 /WX )
+    ADD_COMPILE_OPTIONS(/bigobj)
   ELSE() # msvc
-    ADD_COMPILE_OPTIONS(/MP /bigobj /W4 /WX)
+    ADD_COMPILE_OPTIONS(/MP /bigobj)
   ENDIF()
+
   # disable "elements of array '' will be default initialized" warning on MSVC2013
   IF(MSVC12)
-    ADD_COMPILE_OPTIONS(/wd4351)	
+    ADD_COMPILE_OPTIONS(/wd4351)
   ENDIF()
-  ADD_COMPILE_OPTIONS(/wd4244) #supress warning for double to float conversion if Double precission is activated
+  # 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")
-  SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
-  SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG:FULL /PDBALTPATH:%_PDB% /OPT:REF /OPT:ICF")
+  # Allow user to disable PDBs
+  if(ASSIMP_INSTALL_PDB)
+    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+    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()
+  if(NOT /utf-8 IN_LIST CMAKE_CXX_FLAGS)
+    # Source code is encoded in UTF-8
+    ADD_COMPILE_OPTIONS(/source-charset:utf-8)
+  endif()
 ELSEIF (CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
   IF(NOT ASSIMP_HUNTER_ENABLED)
-    SET(CMAKE_CXX_STANDARD 17)
     SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
   ENDIF()
-  SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long ${CMAKE_CXX_FLAGS}" )
-  SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}")
+  SET(CMAKE_CXX_FLAGS "-Wno-deprecated-non-prototype -fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long ${CMAKE_CXX_FLAGS}" )
+  SET(CMAKE_C_FLAGS "-Wno-deprecated-non-prototype -fno-strict-aliasing ${CMAKE_C_FLAGS}")
 ELSEIF( MINGW )
   IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0)
     message(FATAL_ERROR "MinGW is too old to be supported. Please update MinGW and try again.")
@@ -303,26 +383,26 @@ ELSEIF( MINGW )
     SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}")
   ENDIF()
     IF (CMAKE_BUILD_TYPE STREQUAL "Debug")
-      SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -Wa,-mbig-obj -g ${CMAKE_CXX_FLAGS}")
+      SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wno-dangling-reference -Wall -Wno-long-long -Wa,-mbig-obj -g ${CMAKE_CXX_FLAGS}")
     ELSE()
-      SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -Wa,-mbig-obj -O3 ${CMAKE_CXX_FLAGS}")
+      SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wno-dangling-reference -Wall -Wno-long-long -Wa,-mbig-obj -O3 ${CMAKE_CXX_FLAGS}")
     ENDIF()
     SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}")
 ENDIF()
 
 IF ( IOS AND NOT ASSIMP_HUNTER_ENABLED)
   IF (CMAKE_BUILD_TYPE STREQUAL "Debug")
-    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fembed-bitcode -Og")
+    SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fembed-bitcode -Og")
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fembed-bitcode -Og")
   ELSE()
-    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fembed-bitcode -O3")
+    SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fembed-bitcode -O3")
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fembed-bitcode -O3")
-    # Experimental for pdb generation
   ENDIF()
 ENDIF()
 
 IF (ASSIMP_COVERALLS)
   MESSAGE(STATUS "Coveralls enabled")
+
   INCLUDE(Coveralls)
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
@@ -330,14 +410,16 @@ ENDIF()
 
 IF (ASSIMP_ASAN)
   MESSAGE(STATUS "AddressSanitizer enabled")
+
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address")
+  SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fsanitize=address")
 ENDIF()
 
 IF (ASSIMP_UBSAN)
   MESSAGE(STATUS "Undefined Behavior sanitizer enabled")
+
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined,shift,shift-exponent,integer-divide-by-zero,unreachable,vla-bound,null,return,signed-integer-overflow,bounds,float-divide-by-zero,float-cast-overflow,nonnull-attribute,returns-nonnull-attribute,bool,enum,vptr,pointer-overflow,builtin -fno-sanitize-recover=all")
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined,shift,shift-exponent,integer-divide-by-zero,unreachable,vla-bound,null,return,signed-integer-overflow,bounds,float-divide-by-zero,float-cast-overflow,nonnull-attribute,returns-nonnull-attribute,bool,enum,vptr,pointer-overflow,builtin -fno-sanitize-recover=all")
+  SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fsanitize=undefined,shift,shift-exponent,integer-divide-by-zero,unreachable,vla-bound,null,return,signed-integer-overflow,bounds,float-divide-by-zero,float-cast-overflow,nonnull-attribute,returns-nonnull-attribute,bool,enum,vptr,pointer-overflow,builtin -fno-sanitize-recover=all")
 ENDIF()
 
 INCLUDE (FindPkgMacros)
@@ -388,13 +470,6 @@ IF (NOT TARGET uninstall AND ASSIMP_INSTALL)
   ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 ENDIF()
 
-# cmake configuration files
-if(${BUILD_SHARED_LIBS})
-  set(BUILD_LIB_TYPE SHARED)
-else()
-  set(BUILD_LIB_TYPE STATIC)
-endif()
-
 IF( UNIX )
   # Use GNUInstallDirs for Unix predefined directories
   INCLUDE(GNUInstallDirs)
@@ -419,20 +494,20 @@ ENDIF()
 set(GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
 
 IF(ASSIMP_HUNTER_ENABLED)
-  set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}")
-  set(CMAKE_CONFIG_TEMPLATE_FILE "cmake-modules/assimp-hunter-config.cmake.in")
-  set(NAMESPACE "${PROJECT_NAME}::")
-  set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
-  set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
-  set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake")
+  SET(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}")
+  SET(CMAKE_CONFIG_TEMPLATE_FILE "cmake-modules/assimp-hunter-config.cmake.in")
+  SET(NAMESPACE "${PROJECT_NAME}::")
+  SET(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+  SET(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
+  SET(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake")
 ELSE()
-  set(CONFIG_INSTALL_DIR "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}")
-  set(CMAKE_CONFIG_TEMPLATE_FILE "cmake-modules/assimp-plain-config.cmake.in")
+  SET(CONFIG_INSTALL_DIR "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}")
+  SET(CMAKE_CONFIG_TEMPLATE_FILE "cmake-modules/assimp-plain-config.cmake.in")
   string(TOLOWER ${PROJECT_NAME} PROJECT_NAME_LOWERCASE)
-  set(NAMESPACE "${PROJECT_NAME_LOWERCASE}::")
-  set(TARGETS_EXPORT_NAME "${PROJECT_NAME_LOWERCASE}Targets")
-  set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME_LOWERCASE}ConfigVersion.cmake")
-  set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME_LOWERCASE}Config.cmake")
+  SET(NAMESPACE "${PROJECT_NAME_LOWERCASE}::")
+  SET(TARGETS_EXPORT_NAME "${PROJECT_NAME_LOWERCASE}Targets")
+  SET(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME_LOWERCASE}ConfigVersion.cmake")
+  SET(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME_LOWERCASE}Config.cmake")
 ENDIF()
 
 set(INCLUDE_INSTALL_DIR "include")
@@ -449,18 +524,20 @@ configure_package_config_file(
     INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}"
 )
 
-install(
-    FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}"
-    DESTINATION "${CONFIG_INSTALL_DIR}"
-    COMPONENT ${LIBASSIMP-DEV_COMPONENT}
-)
+IF(ASSIMP_INSTALL)
+  INSTALL(
+      FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}"
+      DESTINATION "${CONFIG_INSTALL_DIR}"
+      COMPONENT ${LIBASSIMP-DEV_COMPONENT}
+  )
 
-install(
-    EXPORT "${TARGETS_EXPORT_NAME}"
-    NAMESPACE "${NAMESPACE}"
-    DESTINATION "${CONFIG_INSTALL_DIR}"
-    COMPONENT ${LIBASSIMP-DEV_COMPONENT}
-)
+  INSTALL(
+      EXPORT "${TARGETS_EXPORT_NAME}"
+      NAMESPACE "${NAMESPACE}"
+      DESTINATION "${CONFIG_INSTALL_DIR}"
+      COMPONENT ${LIBASSIMP-DEV_COMPONENT}
+  )
+ENDIF()
 
 IF( ASSIMP_BUILD_DOCS )
   ADD_SUBDIRECTORY(doc)
@@ -473,12 +550,12 @@ IF(ASSIMP_HUNTER_ENABLED)
   find_package(ZLIB CONFIG REQUIRED)
 
   add_definitions(-DASSIMP_BUILD_NO_OWN_ZLIB)
-  set(ZLIB_FOUND TRUE)
-  set(ZLIB_LIBRARIES ZLIB::zlib)
-  set(ASSIMP_BUILD_MINIZIP TRUE)
+  SET(ZLIB_FOUND TRUE)
+  SET(ZLIB_LIBRARIES ZLIB::zlib)
+  SET(ASSIMP_BUILD_MINIZIP TRUE)
 ELSE()
   # If the zlib is already found outside, add an export in case assimpTargets can't find it.
-  IF( ZLIB_FOUND )
+  IF( ZLIB_FOUND AND ASSIMP_INSTALL)
     INSTALL( TARGETS zlib zlibstatic
         EXPORT "${TARGETS_EXPORT_NAME}")
   ENDIF()
@@ -487,7 +564,11 @@ ELSE()
     FIND_PACKAGE(ZLIB)
   ENDIF()
 
-  IF( NOT ZLIB_FOUND )
+  IF ( NOT ZLIB_FOUND AND NOT ASSIMP_BUILD_ZLIB )
+    message( FATAL_ERROR
+      "Build configured with -DASSIMP_BUILD_ZLIB=OFF but unable to find zlib"
+    )
+  ELSEIF( NOT ZLIB_FOUND )
     MESSAGE(STATUS "compiling zlib from sources")
     INCLUDE(CheckIncludeFile)
     INCLUDE(CheckTypeSize)
@@ -498,8 +579,8 @@ ELSE()
     #		https://github.com/madler/zlib/issues/41#issuecomment-125848075
     # Also prevents these options from "polluting" the cmake options if assimp is being
     # included as a submodule.
-    set( ASM686 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE )
-    set( AMD64 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE )
+    SET(ASM686 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE )
+    SET(AMD64 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE )
 
     # compile from sources
     ADD_SUBDIRECTORY(contrib/zlib)
@@ -510,7 +591,7 @@ ELSE()
     SET(ASSIMP_BUILD_MINIZIP 1)
   ELSE()
     ADD_DEFINITIONS(-DASSIMP_BUILD_NO_OWN_ZLIB)
-    SET(ZLIB_LIBRARIES_LINKED -lz)
+    SET(ZLIB_LIBRARIES_LINKED -l${ZLIB_LIBRARIES})
   ENDIF()
   INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
 ENDIF()
@@ -522,7 +603,7 @@ IF( NOT IOS )
 ELSE ()
   IF( NOT BUILD_SHARED_LIBS )
     IF( NOT ASSIMP_BUILD_MINIZIP )
-      use_pkgconfig(UNZIP minizip)
+      USE_PKGCONFIG(UNZIP minizip)
     ENDIF()
   ENDIF ()
 ENDIF ()
@@ -556,11 +637,15 @@ SET ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER OFF CACHE BOOL
 )
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
-  IF ( MSVC )
-    SET(C4D_INCLUDES "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Cineware/includes")
+  SET(C4D_INCLUDES "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Cineware/includes")
 
+  IF (WIN32)
     # pick the correct prebuilt library
-    IF(MSVC15)
+    IF(MSVC143)
+      SET(C4D_LIB_POSTFIX "_2022")
+    ELSEIF(MSV142)
+      SET(C4D_LIB_POSTFIX "_2019")
+    ELSEIF(MSVC15)
       SET(C4D_LIB_POSTFIX "_2017")
     ELSEIF(MSVC14)
       SET(C4D_LIB_POSTFIX "_2015")
@@ -572,7 +657,7 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
       SET(C4D_LIB_POSTFIX "_2010")
     ELSE()
       MESSAGE( FATAL_ERROR
-        "C4D is currently only supported with MSVC 10, 11, 12, 14"
+        "C4D for Windows is currently only supported with MSVC 10, 11, 12, 14, 14.2, 14.3"
       )
     ENDIF()
 
@@ -590,98 +675,121 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
     # winsock and winmm are necessary (and undocumented) dependencies of Cineware SDK because
     # it can be used to communicate with a running Cinema 4D instance
     SET(C4D_EXTRA_LIBRARIES WSock32.lib Winmm.lib)
-  ELSE ()
-    MESSAGE( FATAL_ERROR
-      "C4D is currently only available on Windows with Cineware SDK installed in contrib/Cineware"
+  ELSEIF (APPLE)
+    SET(C4D_LIB_BASE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Cineware/libraries/osx")
+
+    SET(C4D_DEBUG_LIBRARIES
+      "${C4D_LIB_BASE_PATH}/debug/libcinewarelib.a"
+      "${C4D_LIB_BASE_PATH}/debug/libjpeglib.a"
     )
-  ENDIF ()
+    SET(C4D_RELEASE_LIBRARIES
+      "${C4D_LIB_BASE_PATH}/release/libcinewarelib.a"
+      "${C4D_LIB_BASE_PATH}/release/libjpeglib.a"
+    )
+  ELSE()
+    MESSAGE( FATAL_ERROR
+      "C4D is currently only available on Windows and macOS with Cineware SDK installed in contrib/Cineware"
+    )
+  ENDIF()
 ELSE ()
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
 ENDIF ()
 
+IF(ASSIMP_BUILD_DRACO_STATIC)
+  SET(ASSIMP_BUILD_DRACO ON)
+ENDIF()
+
 # Draco requires cmake 3.12
 IF (DEFINED CMAKE_VERSION AND "${CMAKE_VERSION}" VERSION_LESS "3.12")
-  message(NOTICE "draco requires cmake 3.12 or newer, cmake is ${CMAKE_VERSION} . Draco is disabled")
+  MESSAGE(NOTICE "draco requires cmake 3.12 or newer, cmake is ${CMAKE_VERSION} . Draco is disabled")
   SET ( ASSIMP_BUILD_DRACO OFF CACHE BOOL "Disabled: Draco requires newer cmake" FORCE )
 ELSE()
   OPTION ( ASSIMP_BUILD_DRACO "If the Draco libraries are to be built. Primarily for glTF" OFF )
   IF ( ASSIMP_BUILD_DRACO )
     # Primarily for glTF v2
     # Enable Draco glTF feature set
-    set(DRACO_GLTF ON CACHE BOOL "" FORCE)
+    SET(DRACO_GLTF_BITSTREAM ON CACHE BOOL "" FORCE)
     # Disable unnecessary or omitted components
-    set(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
-    set(DRACO_WASM OFF CACHE BOOL "" FORCE)
-    set(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
-    set(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
-    set(DRACO_TESTS OFF CACHE BOOL "" FORCE)
+    SET(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
+    SET(DRACO_WASM OFF CACHE BOOL "" FORCE)
+    SET(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
+    SET(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
+    SET(DRACO_TESTS OFF CACHE BOOL "" FORCE)
 
     IF(ASSIMP_HUNTER_ENABLED)
       hunter_add_package(draco)
       find_package(draco CONFIG REQUIRED)
-      set(draco_LIBRARIES draco::draco)
+      SET(draco_LIBRARIES draco::draco)
     ELSE()
       # Draco 1.4.1 has many warnings and will not build with /WX or -Werror
       # See https://github.com/google/draco/issues/672
       # and https://github.com/google/draco/issues/673
       IF(MSVC)
-        set(DRACO_CXX_FLAGS "/W0")
+        SET(DRACO_CXX_FLAGS "/W0")
       ELSE()
-        list(APPEND DRACO_CXX_FLAGS
+        LIST(APPEND DRACO_CXX_FLAGS
           "-Wno-bool-compare"
           "-Wno-comment"
           "-Wno-maybe-uninitialized"
           "-Wno-sign-compare"
           "-Wno-unused-local-typedefs"
         )
-        # Draco 1.4.1 does not explicitly export any symbols under GCC/clang
-        list(APPEND DRACO_CXX_FLAGS
-          "-fvisibility=default"
-        )
+
+        IF(NOT ASSIMP_BUILD_DRACO_STATIC)
+          # Draco 1.4.1 does not explicitly export any symbols under GCC/clang
+          LIST(APPEND DRACO_CXX_FLAGS
+            "-fvisibility=default"
+          )
+        ENDIF()
       ENDIF()
 
       # Don't build or install all of Draco by default
       ADD_SUBDIRECTORY( "contrib/draco" EXCLUDE_FROM_ALL )
 
-      if(MSVC OR WIN32)
-        set(draco_LIBRARIES "draco")
-      else()
-        if(BUILD_SHARED_LIBS)
-          set(draco_LIBRARIES "draco_shared")
-        else()
-          set(draco_LIBRARIES "draco_static")
-        endif()
-      endif()
+      IF(ASSIMP_BUILD_DRACO_STATIC)
+        set_property(DIRECTORY "contrib/draco" PROPERTY BUILD_SHARED_LIBS OFF)
+      ENDIF()
+
+      IF(MSVC OR WIN32)
+        SET(draco_LIBRARIES "draco")
+      ELSE()
+        IF(ASSIMP_BUILD_DRACO_STATIC)
+          SET(draco_LIBRARIES "draco_static")
+        ELSE()
+          SET(draco_LIBRARIES "draco_shared")
+        ENDIF()
+      ENDIF()
 
       # Don't build the draco command-line tools by default
       set_target_properties(draco_encoder draco_decoder PROPERTIES
         EXCLUDE_FROM_ALL TRUE
         EXCLUDE_FROM_DEFAULT_BUILD TRUE
-        )
+      )
 
       # Do build the draco shared library
       set_target_properties(${draco_LIBRARIES} PROPERTIES
         EXCLUDE_FROM_ALL FALSE
         EXCLUDE_FROM_DEFAULT_BUILD FALSE
-        )
+      )
 
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)
 
-      set(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
+      SET(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
 
       # This is probably wrong
-      INSTALL( TARGETS ${draco_LIBRARIES}
-        EXPORT "${TARGETS_EXPORT_NAME}"
-        LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-        ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-        RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
-        FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-        COMPONENT ${LIBASSIMP_COMPONENT}
-        INCLUDES DESTINATION include
-    )
-
+      IF (ASSIMP_INSTALL)
+        INSTALL( TARGETS ${draco_LIBRARIES}
+          EXPORT "${TARGETS_EXPORT_NAME}"
+          LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+          ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+          RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
+          FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+          COMPONENT ${LIBASSIMP_COMPONENT}
+          INCLUDES DESTINATION include
+        )
+      ENDIF()
     ENDIF()
   ENDIF()
 ENDIF()
@@ -725,8 +833,8 @@ IF ( ASSIMP_INSTALL )
 ENDIF()
 
 CONFIGURE_FILE(
-  ${CMAKE_CURRENT_LIST_DIR}/revision.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/revision.h
+  ${CMAKE_CURRENT_LIST_DIR}/include/assimp/revision.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/include/assimp/revision.h
 )
 
 CONFIGURE_FILE(
@@ -767,7 +875,7 @@ IF ( ASSIMP_INSTALL )
     SET(CPACK_DEBIAN_PACKAGE_SECTION  "libs" )
     SET(CPACK_DEBIAN_PACKAGE_DEPENDS  "${CPACK_COMPONENTS_ALL}")
     SET(CPACK_DEBIAN_PACKAGE_SUGGESTS)
-    SET(cPACK_DEBIAN_PACKAGE_NAME     "assimp")
+    SET(CPACK_DEBIAN_PACKAGE_NAME     "assimp")
     SET(CPACK_DEBIAN_PACKAGE_REMOVE_SOURCE_FILES contrib/gtest contrib/zlib workspaces test doc obj samples packaging)
     SET(CPACK_DEBIAN_PACKAGE_SOURCE_COPY svn export --force)
     SET(CPACK_DEBIAN_CHANGELOG)
@@ -804,30 +912,34 @@ if(WIN32)
       SET(ASSIMP_MSVC_VERSION "vc140")
     ELSEIF(MSVC15)
       SET(ASSIMP_MSVC_VERSION "vc141")
+    ELSEIF(MSV142)
+      SET(ASSIMP_MSVC_VERSION "vc142")
+    ELSEIF(MSVC143)
+      SET(ASSIMP_MSVC_VERSION "vc143")
     ENDIF()
   ENDIF()
 
   IF(MSVC12 OR MSVC14 OR MSVC15 )
     ADD_CUSTOM_TARGET(UpdateAssimpLibsDebugSymbolsAndDLLs COMMENT "Copying Assimp Libraries ..." VERBATIM)
     IF(CMAKE_GENERATOR MATCHES "^Visual Studio")
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.exp	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.exp VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.lib	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.lib VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll		${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.dll  VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.exp		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.exp VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.lib		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.lib VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.exp	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.exp VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.lib	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.lib VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll		${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.dll  VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.exp		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.exp VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.lib		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.lib VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
     ELSE()
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.exp	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.exp VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.lib	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.lib VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll		${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.dll  VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.exp		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.exp VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.lib		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.lib VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
-      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.exp	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.exp VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.lib	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.lib VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll		${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.dll  VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.exp		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.exp VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.lib		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.lib VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
+      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
     ENDIF()
   ENDIF()
 ENDIF ()

CMakePresets.json

@@ -0,0 +1,34 @@
+{
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 20,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "assimp",
+      "binaryDir": "${sourceDir}",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "ASSIMP_BUILD_ASSIMP_TOOLS": "OFF"
+      }
+    },
+    {
+      "name": "assimp_double_precision",
+      "binaryDir": "${sourceDir}",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "ASSIMP_BUILD_ASSIMP_TOOLS": "OFF",
+        "ASSIMP_DOUBLE_PRECISION": "ON"
+      }
+    },
+    {
+      "name": "assimp_with_tools",
+      "binaryDir": "${sourceDir}",
+      "cacheVariables": {
+        "ASSIMP_BUILD_ASSIMP_TOOLS": "ON"
+      }
+    }
+  ]
+}

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CREDITS

@@ -60,7 +60,7 @@ The GUY who performed some of the CSM mocaps.
 Contributed fixes for the documentation and the doxygen markup
 
 - Zhao Lei
-Contributed several bugfixes fixing memory leaks and improving float parsing 
+Contributed several bugfixes fixing memory leaks and improving float parsing
 
 - sueastside
 Updated PyAssimp to the latest Assimp data structures and provided a script to keep the Python binding up-to-date.
@@ -129,7 +129,7 @@ Contributed a patch to fix the VertexTriangleAdjacency postprocessing step.
 Contributed the Debian build fixes ( architecture macro ).
 
 - gellule
-Several LWO and LWS fixes (pivoting). 
+Several LWO and LWS fixes (pivoting).
 
 - Marcel Metz
 GCC/Linux fixes for the SimpleOpenGL sample.

Dockerfile

@@ -1,25 +1,17 @@
-FROM ubuntu:14.04
+FROM gcc:1.5.1.0
 
-RUN apt-get update && apt-get install -y \
-    git cmake build-essential software-properties-common
+RUN apt-get update \
+    apt-get install --no-install-recommends -y ninja-build cmake zlib1g-dev
 
-RUN add-apt-repository ppa:ubuntu-toolchain-r/test && apt-get update && apt-get install -y gcc-4.9 g++-4.9 && \
-    cd /usr/bin && \
-    rm gcc g++ cpp && \
-    ln -s gcc-4.9 gcc && \
-    ln -s g++-4.9 g++ && \
-    ln -s cpp-4.9 cpp
+WORKDIR /app
 
-WORKDIR /opt
+COPY . .
 
-# Build Assimp
-RUN git clone https://github.com/assimp/assimp.git /opt/assimp
-
-WORKDIR /opt/assimp
-
-RUN git checkout master \
-    && mkdir build && cd build && \
-    cmake \
+RUN mkdir build && cd build && \
+    cmake -G 'Ninja' \
     -DCMAKE_BUILD_TYPE=Release \
+    -DASSIMP_BUILD_ASSIMP_TOOLS=ON \
     .. && \
-    make && make install
+    ninja -j4 && ninja install
+
+CMD ["/app/build/bin/unit"]

INSTALL

@@ -1,17 +1,17 @@
-	
+
 ========================================================================
-Open Asset Import Library (assimp) INSTALL 
+Open Asset Import Library (assimp) INSTALL
 ========================================================================
 
 ------------------------------
 Getting the documentation
 ------------------------------
 
-A regularly-updated copy is available at 
+A regularly-updated copy is available at
 https://assimp-docs.readthedocs.io/en/latest/
 
 ------------------------------
-Building Assimp 
+Building Assimp
 ------------------------------
 
 Just check the build-instructions which you can find here: https://github.com/assimp/assimp/blob/master/Build.md

LICENSE

@@ -1,6 +1,6 @@
 Open Asset Import Library (assimp)
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2025, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,

Readme.md

@@ -1,92 +1,93 @@
 Open Asset Import Library (assimp)
 ==================================
-A library to import and export various 3d-model-formats including scene-post-processing to generate missing render data.
-### Current project status ###
-[![Financial Contributors on Open Collective](https://opencollective.com/assimp/all/badge.svg?label=financial+contributors)](https://opencollective.com/assimp) 
-![C/C++ CI](https://github.com/assimp/assimp/workflows/C/C++%20CI/badge.svg)
-<a href="https://scan.coverity.com/projects/5607">
-  <img alt="Coverity Scan Build Status"
-       src="https://scan.coverity.com/projects/5607/badge.svg"/>
-</a>
-[![Codacy Badge](https://app.codacy.com/project/badge/Grade/9973693b7bdd4543b07084d5d9cf4745)](https://www.codacy.com/gh/assimp/assimp/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=assimp/assimp&amp;utm_campaign=Badge_Grade)
 
-[![Coverage Status](https://coveralls.io/repos/github/assimp/assimp/badge.svg?branch=master)](https://coveralls.io/github/assimp/assimp?branch=master)
-[![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+Open Asset Import Library is a library that loads various 3D file formats into a shared, in-memory format. It supports more than __40 file formats__ for import and a growing selection of file formats for export.
+
+### Current project status
+![C/C++ CI](https://github.com/assimp/assimp/workflows/C/C++%20CI/badge.svg)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/9973693b7bdd4543b07084d5d9cf4745)](https://www.codacy.com/gh/assimp/assimp/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=assimp/assimp&amp;utm_campaign=Badge_Grade)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=assimp_assimp&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=assimp_assimp)
 [![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/assimp/assimp.svg)](http://isitmaintained.com/project/assimp/assimp "Average time to resolve an issue")
 [![Percentage of issues still open](http://isitmaintained.com/badge/open/assimp/assimp.svg)](http://isitmaintained.com/project/assimp/assimp "Percentage of issues still open")
-[![Total alerts](https://img.shields.io/lgtm/alerts/g/assimp/assimp.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/assimp/assimp/alerts/)
+[![Gurubase](https://img.shields.io/badge/Gurubase-Ask%20assimp%20Guru-006BFF)](https://gurubase.io/g/assimp)
+[![Financial Contributors on Open Collective](https://opencollective.com/assimp/all/badge.svg?label=financial+contributors)](https://opencollective.com/assimp)
 <br>
 
-APIs are provided for C and C++. There are various bindings to other languages (C#, Java, Python, Delphi, D). Assimp also runs on Android and iOS.
-Additionally, assimp features various __mesh post processing tools__: normals and tangent space generation, triangulation, vertex cache locality optimization, removal of degenerate primitives and duplicate vertices, sorting by primitive type, merging of redundant materials and many more.
+APIs are provided for C and C++. Various bindings exist to other languages (C#, Java, Python, Delphi, D). Assimp also runs on Android and iOS.
+Additionally, assimp features various __mesh post-processing tools__: normals and tangent space generation, triangulation, vertex cache locality optimization, removal of degenerate primitives and duplicate vertices, sorting by primitive type, merging of redundant materials and many more.
 
-### Latest Doc's ###
-Please check the latest documents at [Asset-Importer-Lib-Doc](https://assimp-docs.readthedocs.io/en/latest/). 
+## Project activity
+![Alt](https://repobeats.axiom.co/api/embed/997f84e5f9fcf772da1e687f3a4f3a8afdbf4cf0.svg "Repobeats analytics image")
 
-### Get involved ###
-This is the development repo containing the latest features and bugfixes. For productive use though, we recommend one of the stable releases available from [Github Assimp Releases](https://github.com/assimp/assimp/releases).
-<br>
-You find a bug in the docs? Use [Doc-Repo](https://github.com/assimp/assimp-docs).
-<br>
-Please check our Wiki as well: https://github.com/assimp/assimp/wiki
+### Documentation
+Read [our latest documentation](https://the-asset-importer-lib-documentation.readthedocs.io/en/latest/).
 
-If you want to check our Model-Database, use the following repo: https://github.com/assimp/assimp-mdb
+### Pre-built binaries
+Download binaries from [our Itch Projectspace](https://kimkulling.itch.io/the-asset-importer-lib).
 
-#### Supported file formats ####
-You can find the complete list of supported file-formats [here](https://github.com/assimp/assimp/blob/master/doc/Fileformats.md)
+### Test data
+Clone [our model database for testing purposes](https://github.com/assimp/assimp-mdb).
 
-### Building ###
-Take a look into the https://github.com/assimp/assimp/blob/master/Build.md file. We are available in vcpkg, and our build system is CMake; if you used CMake before there is a good chance you know what to do.
+### Communities
+- Ask questions at [the Assimp Discussion Board](https://github.com/assimp/assimp/discussions).
+- Find us on [discord](https://discord.gg/kKazXMXDy2)
+- Ask [the Assimp community on Reddit](https://www.reddit.com/r/Assimp/).
+- Ask on [StackOverflow with the assimp-tag](http://stackoverflow.com/questions/tagged/assimp?sort=newest).
+- Nothing has worked? File a question or an issue report at [The Assimp-Issue Tracker](https://github.com/assimp/assimp/issues)
 
-### Ports ###
+#### Supported file formats
+See [the complete list of supported formats](https://github.com/assimp/assimp/blob/master/doc/Fileformats.md).
+
+### Building
+Start by reading [our build instructions](https://github.com/assimp/assimp/blob/master/Build.md). We are available in vcpkg, and our build system is CMake; if you used CMake before there is a good chance you know what to do.
+
+### Ports
 * [Android](port/AndroidJNI/README.md)
 * [Python](port/PyAssimp/README.md)
-* [.NET](https://bitbucket.org/Starnick/assimpnet/src/master/)
+* [.NET](https://github.com/Saalvage/AssimpNetter)
 * [Pascal](port/AssimpPascal/Readme.md)
 * [Javascript (Alpha)](https://github.com/makc/assimp2json)
 * [Javascript/Node.js Interface](https://github.com/kovacsv/assimpjs)
 * [Unity 3d Plugin](https://ricardoreis.net/trilib-2/)
 * [Unreal Engine Plugin](https://github.com/irajsb/UE4_Assimp/)
-* [JVM](https://github.com/kotlin-graphics/assimp) Full jvm port (current [status](https://github.com/kotlin-graphics/assimp/wiki/Status))
+* [JVM](https://github.com/kotlin-graphics/assimp) Full JVM port (current [status](https://github.com/kotlin-graphics/assimp/wiki/Status))
 * [HAXE-Port](https://github.com/longde123/assimp-haxe) The Assimp-HAXE-port.
 * [Rust](https://github.com/jkvargas/russimp)
 
-### Other tools ###
-[open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities.
+### Other tools
+[Qt5-ModelViewer](https://github.com/sharjith/ModelViewer-Qt5) is a powerful viewer based on Qt5 and Assimp's import and export abilities.<br>
+[Assimp-Viewer](https://github.com/assimp/assimp_view) is an experimental implementation for an Asset-Viewer based on ImGUI and Assimp (experimental).
 
 #### Repository structure ####
-Open Asset Import Library is implemented in C++. The directory structure looks like:
+Open Asset Import Library is implemented in C++. The directory structure looks like this:
 
-	/code		Source code
-	/contrib	Third-party libraries
-	/doc		Documentation (doxysource and pre-compiled docs)
-	/fuzz           Contains the test-code for the Google-Fuzzer project
-	/include	Public header C and C++ header files
-	/scripts 	Scripts used to generate the loading code for some formats
-	/port		Ports to other languages and scripts to maintain those.
-	/test		Unit- and regression tests, test suite of models
-	/tools		Tools (old assimp viewer, command line `assimp`)
-	/samples	A small number of samples to illustrate possible
-                        use cases for Assimp
+```txt
+code				Source code
+├── AssetLib/		The asset-importer and exporter lib
+├── CApi/			C-API files
+├── Common/			Common code used from all modules
+├── Geometry/		Geometry utilities
+├── Material/		Common materials
+├── Pbrt/			Physical based materials
+├── PostProcessing/	Post-processing steps
+├── res				Resouce files
+contrib				Third-party libraries
+doc					Documentation (Doxygen source and pre-compiled docs)
+fuzz       			Contains the test code for the Google Fuzzer project
+include				Public header C and C++ header files
+scripts 			Scripts are used to generate the loading code for some formats
+port				Ports to other languages and scripts to maintain those.
+test				Unit- and regression tests, test suite of models
+├── headercheck		Implements headerchecks
+├── models-nonbsd	Non-BSP licensed headers
+├── models			BSP-licensed models
+├── unit			Unit tests
+tools				Tools (old assimp viewer, command line `assimp`)
+samples				Small number of samples to illustrate possible use cases for Assimp
+```
+### Contributing
 
-The source code is organized in the following way:
-
-	code/Common			The base implementation for importers and the infrastructure
-	code/PostProcessing		The post-processing steps
-	code/AssetLib/<FormatName>	Implementation for import and export for the format
-
-### Where to get help ###
-For more information, visit [our website](http://assimp.org/). Or check out the `./doc`- folder, which contains the official documentation in HTML format.
-(CHMs for Windows are included in some release packages and should be located right here in the root folder).
-
-If the docs don't solve your problem, ask on [StackOverflow with the assimp-tag](http://stackoverflow.com/questions/tagged/assimp?sort=newest). If you think you found a bug, please open an issue on Github.
-
-Open Asset Import Library is a library to load various 3d file formats into a shared, in-memory format. It supports more than __40 file formats__ for import and a growing selection of file formats for export.
-
-And we also have a Gitter-channel:Gitter [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
-
-### Contributing ###
-Contributions to assimp are highly appreciated. The easiest way to get involved is to submit
+We would greatly appreciate for you to contribute to assimp. The easiest way to get involved is to submit
 a pull request with your changes against the main repository's `master` branch.
 
 ## Contributors
@@ -108,7 +109,7 @@ Become a financial contributor and help us sustain our community. [[Contribute](
 
 #### Organizations
 
-Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/assimp/contribute)]
+You can support the project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/assimp/contribute)]
 
 <a href="https://opencollective.com/assimp/organization/0/website"><img src="https://opencollective.com/assimp/organization/0/avatar.svg"></a>
 
@@ -118,6 +119,3 @@ Our license is based on the modified, __3-clause BSD__-License.
 An _informal_ summary is: do whatever you want, but include Assimp's license text with your product -
 and don't sue us if our code doesn't work. Note that, unlike LGPLed code, you may link statically to Assimp.
 For the legal details, see the `LICENSE` file.
-
-### Why this name ###
-Sorry, we're germans :-), no english native speakers ...

SECURITY.md

@@ -2,15 +2,14 @@
 
 ## Supported Versions
 
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
+The current version of Assimp that's being supported with security updates:
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 5.2.4   | :white_check_mark: |
+| 6.0.2   | :white_check_mark: |
 
 ## Reporting a Vulnerability
 
-If you have found any security vulnerability you can contact us via 
-kim.kulling@googlemail.com
+If you have found any security vulnerability you can contact us via
+kim.kulling@assimp.org
 

cmake-modules/DebSourcePPA.cmake

@@ -6,7 +6,7 @@
 # Creates source debian files and manages library dependencies
 #
 # Features:
-# 
+#
 # - Automatically generates symbols and run-time dependencies from the build dependencies
 # - Custom copy of source directory via CPACK_DEBIAN_PACKAGE_SOURCE_COPY
 # - Simultaneous output of multiple debian source packages for each distribution
@@ -114,7 +114,6 @@ foreach(RELEASE ${CPACK_DEBIAN_DISTRIBUTION_RELEASES})
     endif( CPACK_DEBIAN_BUILD_DEPENDS_${DISTRIBUTION_NAME_UPPER} )
   endif( CPACK_DEBIAN_BUILD_DEPENDS_${DISTRIBUTION_NAME_UPPER}_${RELEASE_UPPER} )
 
-    
   file(APPEND ${DEBIAN_CONTROL} "\n"
     "Standards-Version: 3.8.4\n"
     "Homepage: ${CPACK_PACKAGE_VENDOR}\n"
@@ -173,7 +172,7 @@ foreach(RELEASE ${CPACK_DEBIAN_DISTRIBUTION_RELEASES})
       endforeach(DEP ${CPACK_DEBIAN_PACKAGE_SUGGESTS})
     endif( CPACK_DEBIAN_PACKAGE_SUGGESTS_${DISTRIBUTION_NAME_UPPER} )
   endif( CPACK_DEBIAN_PACKAGE_SUGGESTS_${DISTRIBUTION_NAME_UPPER}_${RELEASE_UPPER} )
-  
+
   file(APPEND ${DEBIAN_CONTROL} "\n"
     "Description: ${CPACK_PACKAGE_DISPLAY_NAME} ${CPACK_PACKAGE_DESCRIPTION_SUMMARY}\n"
     "${DEB_LONG_DESCRIPTION}"

cmake-modules/FindDirectX.cmake

@@ -26,7 +26,7 @@ if(WIN32) # The only platform it makes sense to check for DirectX SDK
   getenv_path(DIRECTX_BASE)
 
   # construct search paths
-  set(DirectX_PREFIX_PATH 
+  set(DirectX_PREFIX_PATH
     "${DXSDK_DIR}" "${ENV_DXSDK_DIR}"
     "${DIRECTX_HOME}" "${ENV_DIRECTX_HOME}"
     "${DIRECTX_ROOT}" "${ENV_DIRECTX_ROOT}"
@@ -66,7 +66,7 @@ if(WIN32) # The only platform it makes sense to check for DirectX SDK
   find_library(DirectX_D3DCOMPILER_LIBRARY NAMES d3dcompiler HINTS ${DirectX_LIB_SEARCH_PATH} PATH_SUFFIXES ${DirectX_LIBPATH_SUFFIX})
 
   findpkg_finish(DirectX)
-  set(DirectX_LIBRARIES ${DirectX_LIBRARIES} 
+  set(DirectX_LIBRARIES ${DirectX_LIBRARIES}
     ${DirectX_D3DX9_LIBRARY}
     ${DirectX_DXERR_LIBRARY}
     ${DirectX_DXGUID_LIBRARY}
@@ -82,7 +82,7 @@ if(WIN32) # The only platform it makes sense to check for DirectX SDK
       get_filename_component(DirectX_LIBRARY_DIR "${DirectX_LIBRARY}" PATH)
       message(STATUS "DX lib dir: ${DirectX_LIBRARY_DIR}")
     find_library(DirectX_D3D11_LIBRARY NAMES d3d11 HINTS ${DirectX_LIB_SEARCH_PATH} PATH_SUFFIXES ${DirectX_LIBPATH_SUFFIX})
-    find_library(DirectX_D3DX11_LIBRARY NAMES d3dx11 HINTS ${DirectX_LIB_SEARCH_PATH} PATH_SUFFIXES ${DirectX_LIBPATH_SUFFIX})	
+    find_library(DirectX_D3DX11_LIBRARY NAMES d3dx11 HINTS ${DirectX_LIB_SEARCH_PATH} PATH_SUFFIXES ${DirectX_LIBPATH_SUFFIX})
     if (DirectX_D3D11_INCLUDE_DIR AND DirectX_D3D11_LIBRARY)
       set(DirectX_D3D11_FOUND TRUE)
       set(DirectX_D3D11_INCLUDE_DIR ${DirectX_D3D11_INCLUDE_DIR})
@@ -92,8 +92,8 @@ if(WIN32) # The only platform it makes sense to check for DirectX SDK
 	${DirectX_DXGI_LIBRARY}
 	${DirectX_DXERR_LIBRARY}
 	${DirectX_DXGUID_LIBRARY}
-	${DirectX_D3DCOMPILER_LIBRARY}        	  
-      )	
+	${DirectX_D3DCOMPILER_LIBRARY}
+      )
     endif ()
     mark_as_advanced(DirectX_D3D11_INCLUDE_DIR DirectX_D3D11_LIBRARY DirectX_D3DX11_LIBRARY)
   endif ()

cmake-modules/Findassimp.cmake

@@ -3,7 +3,7 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
 	set(ASSIMP_ARCHITECTURE "32")
 endif(CMAKE_SIZEOF_VOID_P EQUAL 8)
-	
+
 if(WIN32)
 	set(ASSIMP_ROOT_DIR CACHE PATH "ASSIMP root directory")
 
@@ -17,29 +17,29 @@ if(WIN32)
 
 	if(MSVC12)
 		set(ASSIMP_MSVC_VERSION "vc120")
-	elseif(MSVC14)	
+	elseif(MSVC14)
 		set(ASSIMP_MSVC_VERSION "vc140")
 	endif(MSVC12)
-	
+
 	if(MSVC12 OR MSVC14)
-	
+
 		find_path(ASSIMP_LIBRARY_DIR
 			NAMES
 				assimp-${ASSIMP_MSVC_VERSION}-mt.lib
 			HINTS
 				${ASSIMP_ROOT_DIR}/lib${ASSIMP_ARCHITECTURE}
 		)
-		
+
 		find_library(ASSIMP_LIBRARY_RELEASE				assimp-${ASSIMP_MSVC_VERSION}-mt.lib 			PATHS ${ASSIMP_LIBRARY_DIR})
 		find_library(ASSIMP_LIBRARY_DEBUG				assimp-${ASSIMP_MSVC_VERSION}-mtd.lib			PATHS ${ASSIMP_LIBRARY_DIR})
-		
-		set(ASSIMP_LIBRARY 
+
+		set(ASSIMP_LIBRARY
 			optimized 	${ASSIMP_LIBRARY_RELEASE}
 			debug		${ASSIMP_LIBRARY_DEBUG}
 		)
-		
+
 		set(ASSIMP_LIBRARIES "ASSIMP_LIBRARY_RELEASE" "ASSIMP_LIBRARY_DEBUG")
-	
+
 		FUNCTION(ASSIMP_COPY_BINARIES TargetDirectory)
 			ADD_CUSTOM_TARGET(AssimpCopyBinaries
 				COMMAND ${CMAKE_COMMAND} -E copy ${ASSIMP_ROOT_DIR}/bin${ASSIMP_ARCHITECTURE}/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll 	${TargetDirectory}/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll
@@ -47,9 +47,37 @@ if(WIN32)
 			COMMENT "Copying Assimp binaries to '${TargetDirectory}'"
 			VERBATIM)
 		ENDFUNCTION(ASSIMP_COPY_BINARIES)
-	
+
+		if (NOT TARGET ASSIMP)
+			set(INCLUDE_DIRS ${ASSIMP_ROOT_DIR}/include)
+
+			find_library(ASSIMP_LIB_DEBUG
+				NAMES assimp-${ASSIMP_MSVC_VERSION}-mtd.lib
+				PATHS ${ASSIMP_LIBRARY_DIR})
+
+			find_file(ASSIMP_DLL_DEBUG
+				NAMES assimp-${ASSIMP_MSVC_VERSION}-mtd.dll
+				PATHS ${ASSIMP_ROOT_DIR}/bin${ASSIMP_ARCHITECTURE})
+
+			find_library(ASSIMP_LIB_RELEASE
+				NAMES assimp-${ASSIMP_MSVC_VERSION}-mt.lib
+				PATHS ${ASSIMP_LIBRARY_DIR})
+
+			find_file(ASSIMP_DLL_RELEASE
+				NAMES assimp-${ASSIMP_MSVC_VERSION}-mt.dll
+				PATHS ${ASSIMP_ROOT_DIR}/bin${ASSIMP_ARCHITECTURE})
+
+			add_library(ASSIMP SHARED IMPORTED)
+			set_target_properties(ASSIMP PROPERTIES
+				INTERFACE_INCLUDE_DIRECTORIES "${INCLUDE_DIRS}"
+				IMPORTED_IMPLIB_DEBUG ${ASSIMP_LIB_DEBUG}
+				IMPORTED_IMPLIB_RELEASE ${ASSIMP_LIB_RELEASE}
+				IMPORTED_LOCATION_DEBUG ${ASSIMP_DLL_DEBUG}
+				IMPORTED_LOCATION_RELEASE ${ASSIMP_DLL_RELEASE}
+			)
+		endif()
 	endif()
-	
+
 else(WIN32)
 
 	find_path(
@@ -81,5 +109,5 @@ else(WIN32)
 		message(FATAL_ERROR "Could not find asset importer library")
 	  endif (assimp_FIND_REQUIRED)
 	endif (assimp_FOUND)
-	
+
 endif(WIN32)

cmake-modules/HunterGate.cmake

@@ -22,45 +22,16 @@
 # 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.
 
-# This is a gate file to Hunter package manager.
-# Include this file using `include` command and add package you need, example:
-#
-#     cmake_minimum_required(VERSION 3.2)
-#
-#     include("cmake/HunterGate.cmake")
-#     HunterGate(
-#         URL "https://github.com/path/to/hunter/archive.tar.gz"
-#         SHA1 "798501e983f14b28b10cda16afa4de69eee1da1d"
-#     )
-#
-#     project(MyProject)
-#
-#     hunter_add_package(Foo)
-#     hunter_add_package(Boo COMPONENTS Bar Baz)
-#
-# Projects:
-#     * https://github.com/hunter-packages/gate/
-#     * https://github.com/ruslo/hunter
 
 option(HUNTER_ENABLED "Enable Hunter package manager support" ON)
 
-if(HUNTER_ENABLED)
-  if(CMAKE_VERSION VERSION_LESS "3.2")
-    message(
-        FATAL_ERROR
-        "At least CMake version 3.2 required for Hunter dependency management."
-        " Update CMake or set HUNTER_ENABLED to OFF."
-    )
-  endif()
-endif()
-
 include(CMakeParseArguments) # cmake_parse_arguments
 
 option(HUNTER_STATUS_PRINT "Print working status" ON)
 option(HUNTER_STATUS_DEBUG "Print a lot info" OFF)
 option(HUNTER_TLS_VERIFY "Enable/disable TLS certificate checking on downloads" ON)
 
-set(HUNTER_ERROR_PAGE "https://docs.hunter.sh/en/latest/reference/errors")
+set(HUNTER_ERROR_PAGE "https://hunter.readthedocs.io/en/latest/reference/errors")
 
 function(hunter_gate_status_print)
   if(HUNTER_STATUS_PRINT OR HUNTER_STATUS_DEBUG)

cmake-modules/PrecompiledHeader.cmake

@@ -9,14 +9,14 @@ MACRO(ADD_MSVC_PRECOMPILED_HEADER PrecompiledHeader PrecompiledSource SourcesVar
       OBJECT_OUTPUTS "${PrecompiledBinary}")
 
     # Do not consider .c files
-    foreach(fname ${Sources}) 
+    foreach(fname ${Sources})
       GET_FILENAME_COMPONENT(fext ${fname} EXT)
       if(fext STREQUAL ".cpp")
 	SET_SOURCE_FILES_PROPERTIES(${fname}
 	  PROPERTIES COMPILE_FLAGS "/Yu\"${PrecompiledBinary}\" /FI\"${PrecompiledBinary}\" /Fp\"${PrecompiledBinary}\""
-          OBJECT_DEPENDS "${PrecompiledBinary}")     
+          OBJECT_DEPENDS "${PrecompiledBinary}")
       endif(fext STREQUAL ".cpp")
-    endforeach(fname) 
+    endforeach(fname)
 
   ENDIF(MSVC)
   # Add precompiled header to SourcesVar

code/.editorconfig

@@ -1,8 +0,0 @@
-# See <http://EditorConfig.org> for details
-
-[*.{h,hpp,c,cpp}]
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_size = 4
-indent_style = space

code/AssetLib/3DS/3DSConverter.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -52,27 +52,31 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cctype>
 #include <memory>
 
-using namespace Assimp;
+namespace Assimp {
 
-static const unsigned int NotSet = 0xcdcdcdcd;
+static constexpr unsigned int NotSet = 0xcdcdcdcd;
+
+using namespace D3DS;
 
 // ------------------------------------------------------------------------------------------------
-// Setup final material indices, generae a default material if necessary
+// Setup final material indices, generate a default material if necessary
 void Discreet3DSImporter::ReplaceDefaultMaterial() {
     // Try to find an existing material that matches the
     // typical default material setting:
     // - no textures
     // - diffuse color (in grey!)
-    // NOTE: This is here to workaround the fact that some
+    // NOTE: This is here to work-around the fact that some
     // exporters are writing a default material, too.
     unsigned int idx(NotSet);
     for (unsigned int i = 0; i < mScene->mMaterials.size(); ++i) {
-        std::string s = mScene->mMaterials[i].mName;
-        for (char & it : s) {
+        auto s = mScene->mMaterials[i].mName;
+        for (char &it : s) {
             it = static_cast<char>(::tolower(static_cast<unsigned char>(it)));
         }
 
-        if (std::string::npos == s.find("default")) continue;
+        if (std::string::npos == s.find("default")) {
+            continue;
+        }
 
         if (mScene->mMaterials[i].mDiffuse.r !=
                         mScene->mMaterials[i].mDiffuse.g ||
@@ -85,25 +89,22 @@ void Discreet3DSImporter::ReplaceDefaultMaterial() {
         idx = i;
     }
     if (NotSet == idx) {
-        idx = (unsigned int)mScene->mMaterials.size();
+        idx = static_cast<unsigned int>(mScene->mMaterials.size());
     }
 
     // now iterate through all meshes and through all faces and
     // find all faces that are using the default material
     unsigned int cnt = 0;
-    for (std::vector<D3DS::Mesh>::iterator
-                    i = mScene->mMeshes.begin();
-            i != mScene->mMeshes.end(); ++i) {
-        for (std::vector<unsigned int>::iterator
-                        a = (*i).mFaceMaterials.begin();
-                a != (*i).mFaceMaterials.end(); ++a) {
+    for (auto i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) {
+        for (auto a = i->mFaceMaterials.begin(); a != i->mFaceMaterials.end(); ++a) {
             // NOTE: The additional check seems to be necessary,
             // some exporters seem to generate invalid data here
-            if (0xcdcdcdcd == (*a)) {
-                (*a) = idx;
+
+            if (NotSet == *a) {
+                *a = idx;
                 ++cnt;
             } else if ((*a) >= mScene->mMaterials.size()) {
-                (*a) = idx;
+                *a = idx;
                 ASSIMP_LOG_WARN("Material index overflow in 3DS file. Using default material");
                 ++cnt;
             }
@@ -111,7 +112,7 @@ void Discreet3DSImporter::ReplaceDefaultMaterial() {
     }
     if (cnt && idx == mScene->mMaterials.size()) {
         // We need to create our own default material
-        D3DS::Material sMat("%%%DEFAULT");
+        Material sMat("%%%DEFAULT");
         sMat.mDiffuse = aiColor3D(0.3f, 0.3f, 0.3f);
         mScene->mMaterials.push_back(sMat);
 
@@ -121,17 +122,17 @@ void Discreet3DSImporter::ReplaceDefaultMaterial() {
 
 // ------------------------------------------------------------------------------------------------
 // Check whether all indices are valid. Otherwise we'd crash before the validation step is reached
-void Discreet3DSImporter::CheckIndices(D3DS::Mesh &sMesh) {
-    for (std::vector<D3DS::Face>::iterator i = sMesh.mFaces.begin(); i != sMesh.mFaces.end(); ++i) {
+void Discreet3DSImporter::CheckIndices(Mesh &sMesh) {
+    for (auto i = sMesh.mFaces.begin(); i != sMesh.mFaces.end(); ++i) {
         // check whether all indices are in range
         for (unsigned int a = 0; a < 3; ++a) {
             if ((*i).mIndices[a] >= sMesh.mPositions.size()) {
                 ASSIMP_LOG_WARN("3DS: Vertex index overflow)");
-                (*i).mIndices[a] = (uint32_t)sMesh.mPositions.size() - 1;
+                (*i).mIndices[a] = static_cast<uint32_t>(sMesh.mPositions.size() - 1);
             }
             if (!sMesh.mTexCoords.empty() && (*i).mIndices[a] >= sMesh.mTexCoords.size()) {
                 ASSIMP_LOG_WARN("3DS: Texture coordinate index overflow)");
-                (*i).mIndices[a] = (uint32_t)sMesh.mTexCoords.size() - 1;
+                (*i).mIndices[a] = static_cast<uint32_t>(sMesh.mTexCoords.size() - 1);
             }
         }
     }
@@ -139,7 +140,7 @@ void Discreet3DSImporter::CheckIndices(D3DS::Mesh &sMesh) {
 
 // ------------------------------------------------------------------------------------------------
 // Generate out unique verbose format representation
-void Discreet3DSImporter::MakeUnique(D3DS::Mesh &sMesh) {
+void Discreet3DSImporter::MakeUnique(Mesh &sMesh) {
     // TODO: really necessary? I don't think. Just a waste of memory and time
     // to do it now in a separate buffer.
 
@@ -150,7 +151,7 @@ void Discreet3DSImporter::MakeUnique(D3DS::Mesh &sMesh) {
         vNew2.resize(sMesh.mFaces.size() * 3);
 
     for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size(); ++i) {
-        D3DS::Face &face = sMesh.mFaces[i];
+        Face &face = sMesh.mFaces[i];
 
         // Positions
         for (unsigned int a = 0; a < 3; ++a, ++base) {
@@ -167,10 +168,9 @@ void Discreet3DSImporter::MakeUnique(D3DS::Mesh &sMesh) {
 
 // ------------------------------------------------------------------------------------------------
 // Convert a 3DS texture to texture keys in an aiMaterial
-void CopyTexture(aiMaterial &mat, D3DS::Texture &texture, aiTextureType type) {
+void CopyTexture(aiMaterial &mat, Texture &texture, aiTextureType type) {
     // Setup the texture name
-    aiString tex;
-    tex.Set(texture.mMapName);
+    aiString tex(texture.mMapName);
     mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));
 
     // Setup the texture blend factor
@@ -178,7 +178,7 @@ void CopyTexture(aiMaterial &mat, D3DS::Texture &texture, aiTextureType type) {
         mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));
 
     // Setup the texture mapping mode
-    int mapMode = static_cast<int>(texture.mMapMode);
+    auto mapMode = static_cast<int>(texture.mMapMode);
     mat.AddProperty<int>(&mapMode, 1, AI_MATKEY_MAPPINGMODE_U(type, 0));
     mat.AddProperty<int>(&mapMode, 1, AI_MATKEY_MAPPINGMODE_V(type, 0));
 
@@ -197,13 +197,11 @@ void CopyTexture(aiMaterial &mat, D3DS::Texture &texture, aiTextureType type) {
 
 // ------------------------------------------------------------------------------------------------
 // Convert a 3DS material to an aiMaterial
-void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat,
-        aiMaterial &mat) {
+void Discreet3DSImporter::ConvertMaterial(Material &oldMat, aiMaterial &mat) {
     // NOTE: Pass the background image to the viewer by bypassing the
     // material system. This is an evil hack, never do it again!
-    if (0 != mBackgroundImage.length() && bHasBG) {
-        aiString tex;
-        tex.Set(mBackgroundImage);
+    if (mBackgroundImage.empty() && bHasBG) {
+        aiString tex(mBackgroundImage);
         mat.AddProperty(&tex, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE);
 
         // Be sure this is only done for the first material
@@ -215,8 +213,7 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat,
     oldMat.mAmbient.g += mClrAmbient.g;
     oldMat.mAmbient.b += mClrAmbient.b;
 
-    aiString name;
-    name.Set(oldMat.mName);
+    aiString name(oldMat.mName);
     mat.AddProperty(&name, AI_MATKEY_NAME);
 
     // Material colors
@@ -226,10 +223,9 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat,
     mat.AddProperty(&oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
 
     // Phong shininess and shininess strength
-    if (D3DS::Discreet3DS::Phong == oldMat.mShading ||
-            D3DS::Discreet3DS::Metal == oldMat.mShading) {
+    if (Discreet3DS::Phong == oldMat.mShading || Discreet3DS::Metal == oldMat.mShading) {
         if (!oldMat.mSpecularExponent || !oldMat.mShininessStrength) {
-            oldMat.mShading = D3DS::Discreet3DS::Gouraud;
+            oldMat.mShading = Discreet3DS::Gouraud;
         } else {
             mat.AddProperty(&oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
             mat.AddProperty(&oldMat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
@@ -251,40 +247,41 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat,
     // Shading mode
     aiShadingMode eShading = aiShadingMode_NoShading;
     switch (oldMat.mShading) {
-    case D3DS::Discreet3DS::Flat:
+    case Discreet3DS::Flat:
         eShading = aiShadingMode_Flat;
         break;
 
     // I don't know what "Wire" shading should be,
     // assume it is simple lambertian diffuse shading
-    case D3DS::Discreet3DS::Wire: {
+    case Discreet3DS::Wire: {
         // Set the wireframe flag
         unsigned int iWire = 1;
         mat.AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);
     }
-    [[fallthrough]];
+        [[fallthrough]];
 
-    case D3DS::Discreet3DS::Gouraud:
+    case Discreet3DS::Gouraud:
         eShading = aiShadingMode_Gouraud;
         break;
 
     // assume cook-torrance shading for metals.
-    case D3DS::Discreet3DS::Phong:
+    case Discreet3DS::Phong:
         eShading = aiShadingMode_Phong;
         break;
 
-    case D3DS::Discreet3DS::Metal:
+    case Discreet3DS::Metal:
         eShading = aiShadingMode_CookTorrance;
         break;
 
         // FIX to workaround a warning with GCC 4 who complained
         // about a missing case Blinn: here - Blinn isn't a valid
         // value in the 3DS Loader, it is just needed for ASE
-    case D3DS::Discreet3DS::Blinn:
+    case Discreet3DS::Blinn:
         eShading = aiShadingMode_Blinn;
         break;
     }
-    int eShading_ = static_cast<int>(eShading);
+
+    const int eShading_ = eShading;
     mat.AddProperty<int>(&eShading_, 1, AI_MATKEY_SHADING_MODEL);
 
     // DIFFUSE texture
@@ -333,10 +330,11 @@ void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) {
     aiString name;
 
     // we need to split all meshes by their materials
-    for (std::vector<D3DS::Mesh>::iterator i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) {
+    for (auto i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) {
         std::unique_ptr<std::vector<unsigned int>[]> aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
 
-        name.length = ASSIMP_itoa10(name.data, num++);
+        name.length = ASSIMP_itoa10(name.data, num);
+        ++num;
 
         unsigned int iNum = 0;
         for (std::vector<unsigned int>::const_iterator a = (*i).mFaceMaterials.begin();
@@ -348,7 +346,7 @@ void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) {
             if (aiSplit[p].empty()) {
                 continue;
             }
-            aiMesh *meshOut = new aiMesh();
+            auto *meshOut = new aiMesh();
             meshOut->mName = name;
             meshOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
@@ -360,7 +358,7 @@ void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) {
             avOutMeshes.push_back(meshOut);
 
             // convert vertices
-            meshOut->mNumFaces = (unsigned int)aiSplit[p].size();
+            meshOut->mNumFaces = static_cast<unsigned int>(aiSplit[p].size());
             meshOut->mNumVertices = meshOut->mNumFaces * 3;
 
             // allocate enough storage for faces
@@ -408,8 +406,7 @@ void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) {
 
 // ------------------------------------------------------------------------------------------------
 // Add a node to the scenegraph and setup its final transformation
-void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
-        D3DS::Node *pcIn, aiMatrix4x4 & /*absTrafo*/) {
+void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut, D3DS::Node *pcIn, aiMatrix4x4 & /*absTrafo*/) {
     std::vector<unsigned int> iArray;
     iArray.reserve(3);
 
@@ -417,7 +414,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
 
     // Find all meshes with the same name as the node
     for (unsigned int a = 0; a < pcSOut->mNumMeshes; ++a) {
-        const D3DS::Mesh *pcMesh = (const D3DS::Mesh *)pcSOut->mMeshes[a]->mColors[0];
+        const auto *pcMesh = (const D3DS::Mesh *)pcSOut->mMeshes[a]->mColors[0];
         ai_assert(nullptr != pcMesh);
 
         if (pcIn->mName == pcMesh->mName)
@@ -426,7 +423,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
     if (!iArray.empty()) {
         // The matrix should be identical for all meshes with the
         // same name. It HAS to be identical for all meshes .....
-        D3DS::Mesh *imesh = ((D3DS::Mesh *)pcSOut->mMeshes[iArray[0]]->mColors[0]);
+        auto *imesh = ((D3DS::Mesh *)pcSOut->mMeshes[iArray[0]]->mColors[0]);
 
         // Compute the inverse of the transformation matrix to move the
         // vertices back to their relative and local space
@@ -435,7 +432,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
         mInvTransposed.Transpose();
         aiVector3D pivot = pcIn->vPivot;
 
-        pcOut->mNumMeshes = (unsigned int)iArray.size();
+        pcOut->mNumMeshes = static_cast<unsigned int>(iArray.size());
         pcOut->mMeshes = new unsigned int[iArray.size()];
         for (unsigned int i = 0; i < iArray.size(); ++i) {
             const unsigned int iIndex = iArray[i];
@@ -454,7 +451,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
 
                 // Handle negative transformation matrix determinant -> invert vertex x
                 if (imesh->mMat.Determinant() < 0.0f) {
-                    /* we *must* have normals */
+                    // we *must* have normals
                     for (pvCurrent = mesh->mVertices, t2 = mesh->mNormals; pvCurrent != pvEnd; ++pvCurrent, ++t2) {
                         pvCurrent->x *= -1.f;
                         t2->x *= -1.f;
@@ -481,7 +478,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
     // Setup the name of the node
     // First instance keeps its name otherwise something might break, all others will be postfixed with their instance number
     if (pcIn->mInstanceNumber > 1) {
-        char tmp[12];
+        char tmp[12] = {'\0'};
         ASSIMP_itoa10(tmp, pcIn->mInstanceNumber);
         std::string tempStr = pcIn->mName + "_inst_";
         tempStr += tmp;
@@ -494,7 +491,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
     if (pcIn->aRotationKeys.size()) {
 
         // FIX to get to Assimp's quaternion conventions
-        for (std::vector<aiQuatKey>::iterator it = pcIn->aRotationKeys.begin(); it != pcIn->aRotationKeys.end(); ++it) {
+        for (auto it = pcIn->aRotationKeys.begin(); it != pcIn->aRotationKeys.end(); ++it) {
             (*it).mValue.w *= -1.f;
         }
 
@@ -593,7 +590,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
 
         // Cameras or lights define their transformation in their parent node and in the
         // corresponding light or camera chunks. However, we read and process the latter
-        // to to be able to return valid cameras/lights even if no scenegraph is given.
+        // to be able to return valid cameras/lights even if no scenegraph is given.
         for (unsigned int n = 0; n < pcSOut->mNumCameras; ++n) {
             if (pcSOut->mCameras[n]->mName == pcOut->mName) {
                 pcSOut->mCameras[n]->mLookAt = aiVector3D(0.f, 0.f, 1.f);
@@ -606,11 +603,11 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
         }
 
         // Allocate a new node anim and setup its name
-        aiNodeAnim *nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
+        auto *nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
         nda->mNodeName.Set(pcIn->mName);
 
         // POSITION keys
-        if (pcIn->aPositionKeys.size() > 0) {
+        if (!pcIn->aPositionKeys.empty()) {
             nda->mNumPositionKeys = (unsigned int)pcIn->aPositionKeys.size();
             nda->mPositionKeys = new aiVectorKey[nda->mNumPositionKeys];
             ::memcpy(nda->mPositionKeys, &pcIn->aPositionKeys[0],
@@ -618,7 +615,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
         }
 
         // ROTATION keys
-        if (pcIn->aRotationKeys.size() > 0) {
+        if (!pcIn->aRotationKeys.empty()) {
             nda->mNumRotationKeys = (unsigned int)pcIn->aRotationKeys.size();
             nda->mRotationKeys = new aiQuatKey[nda->mNumRotationKeys];
 
@@ -634,7 +631,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
         }
 
         // SCALING keys
-        if (pcIn->aScalingKeys.size() > 0) {
+        if (!pcIn->aScalingKeys.empty()) {
             nda->mNumScalingKeys = (unsigned int)pcIn->aScalingKeys.size();
             nda->mScalingKeys = new aiVectorKey[nda->mNumScalingKeys];
             ::memcpy(nda->mScalingKeys, &pcIn->aScalingKeys[0],
@@ -643,11 +640,17 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
     }
 
     // Allocate storage for children
-    pcOut->mNumChildren = (unsigned int)pcIn->mChildren.size();
+    const auto size = static_cast<unsigned int>(pcIn->mChildren.size());
+
+    pcOut->mNumChildren = size;
+    if (size == 0) {
+        return;
+    }
+
     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;
@@ -680,7 +683,7 @@ void CountTracks(D3DS::Node *node, unsigned int &cnt) {
 // Generate the output node graph
 void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
     pcOut->mRootNode = new aiNode();
-    if (0 == mRootNode->mChildren.size()) {
+    if (mRootNode->mChildren.empty()) {
         //////////////////////////////////////////////////////////////////////////////
         // It seems the file is so messed up that it has not even a hierarchy.
         // generate a flat hiearachy which looks like this:
@@ -702,19 +705,20 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
         // Build dummy nodes for all meshes
         unsigned int a = 0;
         for (unsigned int i = 0; i < pcOut->mNumMeshes; ++i, ++a) {
-            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+            pcOut->mRootNode->mChildren[a] = new aiNode();  
+            auto *pcNode = pcOut->mRootNode->mChildren[a];
             pcNode->mParent = pcOut->mRootNode;
             pcNode->mMeshes = new unsigned int[1];
             pcNode->mMeshes[0] = i;
             pcNode->mNumMeshes = 1;
 
             // Build a name for the node
-            pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "3DSMesh_%u", i);
+            pcNode->mName.length = ai_snprintf(pcNode->mName.data, AI_MAXLEN, "3DSMesh_%u", i);
         }
 
         // Build dummy nodes for all cameras
         for (unsigned int i = 0; i < (unsigned int)mScene->mCameras.size(); ++i, ++a) {
-            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+            auto *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
 
             // Build a name for the node
@@ -723,7 +727,7 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
 
         // Build dummy nodes for all lights
         for (unsigned int i = 0; i < (unsigned int)mScene->mLights.size(); ++i, ++a) {
-            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+            auto *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
 
             // Build a name for the node
@@ -739,7 +743,7 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
             // Allocate a primary animation channel
             pcOut->mNumAnimations = 1;
             pcOut->mAnimations = new aiAnimation *[1];
-            aiAnimation *anim = pcOut->mAnimations[0] = new aiAnimation();
+            auto *anim = pcOut->mAnimations[0] = new aiAnimation();
 
             anim->mName.Set("3DSMasterAnim");
 
@@ -777,12 +781,12 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
 // Convert all meshes in the scene and generate the final output scene.
 void Discreet3DSImporter::ConvertScene(aiScene *pcOut) {
     // Allocate enough storage for all output materials
-    pcOut->mNumMaterials = (unsigned int)mScene->mMaterials.size();
+    pcOut->mNumMaterials = static_cast<unsigned int>(mScene->mMaterials.size());
     pcOut->mMaterials = new aiMaterial *[pcOut->mNumMaterials];
 
     //  ... and convert the 3DS materials to aiMaterial's
     for (unsigned int i = 0; i < pcOut->mNumMaterials; ++i) {
-        aiMaterial *pcNew = new aiMaterial();
+        auto *pcNew = new aiMaterial();
         ConvertMaterial(mScene->mMaterials[i], *pcNew);
         pcOut->mMaterials[i] = pcNew;
     }
@@ -791,18 +795,20 @@ void Discreet3DSImporter::ConvertScene(aiScene *pcOut) {
     ConvertMeshes(pcOut);
 
     // Now copy all light sources to the output scene
-    pcOut->mNumLights = (unsigned int)mScene->mLights.size();
+    pcOut->mNumLights = static_cast<unsigned int>(mScene->mLights.size());
     if (pcOut->mNumLights) {
         pcOut->mLights = new aiLight *[pcOut->mNumLights];
-        ::memcpy(pcOut->mLights, &mScene->mLights[0], sizeof(void *) * pcOut->mNumLights);
+        memcpy(pcOut->mLights, &mScene->mLights[0], sizeof(void *) * pcOut->mNumLights);
     }
 
     // Now copy all cameras to the output scene
-    pcOut->mNumCameras = (unsigned int)mScene->mCameras.size();
+    pcOut->mNumCameras = static_cast<unsigned int>(mScene->mCameras.size());
     if (pcOut->mNumCameras) {
         pcOut->mCameras = new aiCamera *[pcOut->mNumCameras];
-        ::memcpy(pcOut->mCameras, &mScene->mCameras[0], sizeof(void *) * pcOut->mNumCameras);
+        memcpy(pcOut->mCameras, &mScene->mCameras[0], sizeof(void *) * pcOut->mNumCameras);
     }
 }
 
+} // namespace Assimp
+
 #endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER

code/AssetLib/3DS/3DSExporter.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -52,6 +51,7 @@ 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>
@@ -76,33 +76,33 @@ class ChunkWriter {
 
 public:
     ChunkWriter(StreamWriterLE &writer, uint16_t chunk_type) :
-            writer(writer) {
-        chunk_start_pos = writer.GetCurrentPos();
+            mWriter(writer) {
+        mChunkStartPos = writer.GetCurrentPos();
         writer.PutU2(chunk_type);
         writer.PutU4((uint32_t)CHUNK_SIZE_NOT_SET);
     }
 
     ~ChunkWriter() {
-        std::size_t head_pos = writer.GetCurrentPos();
+        std::size_t head_pos = mWriter.GetCurrentPos();
 
-        ai_assert(head_pos > chunk_start_pos);
-        const std::size_t chunk_size = head_pos - chunk_start_pos;
+        ai_assert(head_pos > mChunkStartPos);
+        const std::size_t chunk_size = head_pos - mChunkStartPos;
 
-        writer.SetCurrentPos(chunk_start_pos + SIZE_OFFSET);
-        writer.PutU4(static_cast<uint32_t>(chunk_size));
-        writer.SetCurrentPos(head_pos);
+        mWriter.SetCurrentPos(mChunkStartPos + SIZE_OFFSET);
+        mWriter.PutU4(static_cast<uint32_t>(chunk_size));
+        mWriter.SetCurrentPos(head_pos);
     }
 
 private:
-    StreamWriterLE &writer;
-    std::size_t chunk_start_pos;
+    StreamWriterLE &mWriter;
+    std::size_t mChunkStartPos;
 };
 
 // Return an unique name for a given |mesh| attached to |node| that
 // preserves the mesh's given name if it has one. |index| is the index
 // of the mesh in |aiScene::mMeshes|.
 std::string GetMeshName(const aiMesh &mesh, unsigned int index, const aiNode &node) {
-    static const char underscore = '_';
+    static constexpr char underscore = '_';
     char postfix[10] = { 0 };
     ASSIMP_itoa10(postfix, index);
 
@@ -122,8 +122,7 @@ std::string GetMaterialName(const aiMaterial &mat, unsigned int index) {
     char postfix[10] = { 0 };
     ASSIMP_itoa10(postfix, index);
 
-    aiString mat_name;
-    if (AI_SUCCESS == mat.Get(AI_MATKEY_NAME, mat_name)) {
+    if (aiString mat_name; AI_SUCCESS == mat.Get(AI_MATKEY_NAME, mat_name)) {
         return mat_name.C_Str() + underscore + postfix;
     }
 
@@ -208,9 +207,6 @@ Discreet3DSExporter::Discreet3DSExporter(std::shared_ptr<IOStream> &outfile, con
     }
 }
 
-// ------------------------------------------------------------------------------------------------
-Discreet3DSExporter::~Discreet3DSExporter() = default;
-
 // ------------------------------------------------------------------------------------------------
 int Discreet3DSExporter::WriteHierarchy(const aiNode &node, int seq, int sibling_level) {
     // 3DS scene hierarchy is serialized as in http://www.martinreddy.net/gfx/3d/3DS.spec
@@ -306,8 +302,7 @@ void Discreet3DSExporter::WriteMaterials() {
             WriteColor(color);
         }
 
-        aiShadingMode shading_mode = aiShadingMode_Flat;
-        if (mat.Get(AI_MATKEY_SHADING_MODEL, shading_mode) == AI_SUCCESS) {
+        if (aiShadingMode shading_mode = aiShadingMode_Flat; mat.Get(AI_MATKEY_SHADING_MODEL, shading_mode) == AI_SUCCESS) {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SHADING);
 
             Discreet3DS::shadetype3ds shading_mode_out;
@@ -335,7 +330,7 @@ void Discreet3DSExporter::WriteMaterials() {
             default:
                 shading_mode_out = Discreet3DS::Flat;
                 ai_assert(false);
-            };
+            }
             writer.PutU2(static_cast<uint16_t>(shading_mode_out));
         }
 
@@ -349,8 +344,7 @@ void Discreet3DSExporter::WriteMaterials() {
             WritePercentChunk(f);
         }
 
-        int twosided;
-        if (mat.Get(AI_MATKEY_TWOSIDED, twosided) == AI_SUCCESS && twosided != 0) {
+        if (int twosided; mat.Get(AI_MATKEY_TWOSIDED, twosided) == AI_SUCCESS && twosided != 0) {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_TWO_SIDE);
             writer.PutI2(1);
         }
@@ -544,7 +538,7 @@ void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh &mesh) {
 
 // ------------------------------------------------------------------------------------------------
 void Discreet3DSExporter::WriteString(const std::string &s) {
-    for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
+    for (auto it = s.begin(); it != s.end(); ++it) {
         writer.PutI1(*it);
     }
     writer.PutI1('\0');

code/AssetLib/3DS/3DSExporter.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -57,18 +56,17 @@ struct aiNode;
 struct aiMaterial;
 struct aiMesh;
 
-namespace Assimp
-{
+namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
 /**
  *  @brief  Helper class to export a given scene to a 3DS file.
  */
 // ------------------------------------------------------------------------------------------------
-class Discreet3DSExporter {
+class Discreet3DSExporter final {
 public:
     Discreet3DSExporter(std::shared_ptr<IOStream> &outfile, const aiScene* pScene);
-    ~Discreet3DSExporter();
+    ~Discreet3DSExporter() = default;
 
 private:
     void WriteMeshes();
@@ -88,9 +86,8 @@ private:
 
     std::map<const aiNode*, aiMatrix4x4> trafos;
 
-    typedef std::multimap<const aiNode*, unsigned int> MeshesByNodeMap;
+    using MeshesByNodeMap = std::multimap<const aiNode*, unsigned int>;
     MeshesByNodeMap meshes;
-
 };
 
 } // Namespace Assimp

code/AssetLib/3DS/3DSHelper.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -55,8 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/qnan.h>
 #include <cstdio> //sprintf
 
-namespace Assimp {
-namespace D3DS {
+namespace Assimp::D3DS {
 
 #include <assimp/Compiler/pushpack1.h>
 
@@ -322,7 +320,6 @@ struct Texture {
     //! Default constructor
     Texture() AI_NO_EXCEPT
             : mTextureBlend(0.0f),
-              mMapName(),
               mOffsetU(0.0),
               mOffsetV(0.0),
               mScaleU(1.0),
@@ -334,51 +331,11 @@ struct Texture {
         mTextureBlend = get_qnan();
     }
 
-    Texture(const Texture &other) :
-            mTextureBlend(other.mTextureBlend),
-            mMapName(other.mMapName),
-            mOffsetU(other.mOffsetU),
-            mOffsetV(other.mOffsetV),
-            mScaleU(other.mScaleU),
-            mScaleV(other.mScaleV),
-            mRotation(other.mRotation),
-            mMapMode(other.mMapMode),
-            bPrivate(other.bPrivate),
-            iUVSrc(other.iUVSrc) {
-        // empty
-    }
+    Texture(const Texture &other) = default;
 
-    Texture(Texture &&other) AI_NO_EXCEPT : mTextureBlend(other.mTextureBlend),
-                                            mMapName(std::move(other.mMapName)),
-                                            mOffsetU(other.mOffsetU),
-                                            mOffsetV(other.mOffsetV),
-                                            mScaleU(other.mScaleU),
-                                            mScaleV(other.mScaleV),
-                                            mRotation(other.mRotation),
-                                            mMapMode(other.mMapMode),
-                                            bPrivate(other.bPrivate),
-                                            iUVSrc(other.iUVSrc) {
-        // empty
-    }
+    Texture(Texture &&other) AI_NO_EXCEPT = default;
 
-    Texture &operator=(Texture &&other) AI_NO_EXCEPT {
-        if (this == &other) {
-            return *this;
-        }
-
-        mTextureBlend = other.mTextureBlend;
-        mMapName = std::move(other.mMapName);
-        mOffsetU = other.mOffsetU;
-        mOffsetV = other.mOffsetV;
-        mScaleU = other.mScaleU;
-        mScaleV = other.mScaleV;
-        mRotation = other.mRotation;
-        mMapMode = other.mMapMode;
-        bPrivate = other.bPrivate;
-        iUVSrc = other.iUVSrc;
-
-        return *this;
-    }
+    Texture &operator=(Texture &&other) AI_NO_EXCEPT = default;
 
     //! Specifies the blend factor for the texture
     ai_real mTextureBlend;
@@ -406,14 +363,13 @@ struct Texture {
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif // _MSC_VER
-
 // ---------------------------------------------------------------------------
 /** Helper structure representing a 3ds material */
 struct Material {
     //! Default constructor has been deleted
     Material() :
             mName(),
-            mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
+            mDiffuse(0.6f, 0.6f, 0.6f),
             mSpecularExponent(ai_real(0.0)),
             mShininessStrength(ai_real(1.0)),
             mShading(Discreet3DS::Gouraud),
@@ -426,7 +382,7 @@ struct Material {
     //! Constructor with explicit name
     explicit Material(const std::string &name) :
             mName(name),
-            mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
+            mDiffuse(0.6f, 0.6f, 0.6f),
             mSpecularExponent(ai_real(0.0)),
             mShininessStrength(ai_real(1.0)),
             mShading(Discreet3DS::Gouraud),
@@ -436,83 +392,9 @@ struct Material {
         // empty
     }
 
-    Material(const Material &other) :
-            mName(other.mName),
-            mDiffuse(other.mDiffuse),
-            mSpecularExponent(other.mSpecularExponent),
-            mShininessStrength(other.mShininessStrength),
-            mSpecular(other.mSpecular),
-            mAmbient(other.mAmbient),
-            mShading(other.mShading),
-            mTransparency(other.mTransparency),
-            sTexDiffuse(other.sTexDiffuse),
-            sTexOpacity(other.sTexOpacity),
-            sTexSpecular(other.sTexSpecular),
-            sTexReflective(other.sTexReflective),
-            sTexBump(other.sTexBump),
-            sTexEmissive(other.sTexEmissive),
-            sTexShininess(other.sTexShininess),
-            mBumpHeight(other.mBumpHeight),
-            mEmissive(other.mEmissive),
-            sTexAmbient(other.sTexAmbient),
-            mTwoSided(other.mTwoSided) {
-        // empty
-    }
+    Material(const Material &other) = default;
 
-    //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other) AI_NO_EXCEPT : mName(std::move(other.mName)),
-                                              mDiffuse(other.mDiffuse),
-                                              mSpecularExponent(other.mSpecularExponent),
-                                              mShininessStrength(other.mShininessStrength),
-                                              mSpecular(other.mSpecular),
-                                              mAmbient(other.mAmbient),
-                                              mShading(other.mShading),
-                                              mTransparency(other.mTransparency),
-                                              sTexDiffuse(std::move(other.sTexDiffuse)),
-                                              sTexOpacity(std::move(other.sTexOpacity)),
-                                              sTexSpecular(std::move(other.sTexSpecular)),
-                                              sTexReflective(std::move(other.sTexReflective)),
-                                              sTexBump(std::move(other.sTexBump)),
-                                              sTexEmissive(std::move(other.sTexEmissive)),
-                                              sTexShininess(std::move(other.sTexShininess)),
-                                              mBumpHeight(other.mBumpHeight),
-                                              mEmissive(other.mEmissive),
-                                              sTexAmbient(std::move(other.sTexAmbient)),
-                                              mTwoSided(other.mTwoSided) {
-        // empty
-    }
-
-    Material &operator=(Material &&other) AI_NO_EXCEPT {
-        if (this == &other) {
-            return *this;
-        }
-
-        mName = std::move(other.mName);
-        mDiffuse = other.mDiffuse;
-        mSpecularExponent = other.mSpecularExponent;
-        mShininessStrength = other.mShininessStrength,
-        mSpecular = other.mSpecular;
-        mAmbient = other.mAmbient;
-        mShading = other.mShading;
-        mTransparency = other.mTransparency;
-        sTexDiffuse = std::move(other.sTexDiffuse);
-        sTexOpacity = std::move(other.sTexOpacity);
-        sTexSpecular = std::move(other.sTexSpecular);
-        sTexReflective = std::move(other.sTexReflective);
-        sTexBump = std::move(other.sTexBump);
-        sTexEmissive = std::move(other.sTexEmissive);
-        sTexShininess = std::move(other.sTexShininess);
-        mBumpHeight = other.mBumpHeight;
-        mEmissive = other.mEmissive;
-        sTexAmbient = std::move(other.sTexAmbient);
-        mTwoSided = other.mTwoSided;
-
-        return *this;
-    }
-
-    virtual ~Material() {
-        // empty
-    }
+    virtual ~Material() = default;
 
     //! Name of the material
     std::string mName;
@@ -696,7 +578,6 @@ struct Scene {
     // Node* pcRootNode;
 };
 
-} // end of namespace D3DS
-} // end of namespace Assimp
+} // end of namespace Assimp::D3DS
 
 #endif // AI_XFILEHELPER_H_INC

code/AssetLib/3DS/3DSLoader.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -54,9 +54,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/IOSystem.hpp>
 
-using namespace Assimp;
+namespace Assimp {
 
-static const aiImporterDesc desc = {
+using namespace D3DS;
+
+static constexpr aiImporterDesc desc = {
     "Discreet 3DS Importer",
     "",
     "",
@@ -75,7 +77,7 @@ static const aiImporterDesc desc = {
 // - computes its length
 #define ASSIMP_3DS_BEGIN_CHUNK()                                              \
     while (true) {                                                            \
-        if (stream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \
+        if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \
             return;                                                           \
         }                                                                     \
         Discreet3DS::Chunk chunk;                                             \
@@ -83,34 +85,30 @@ static const aiImporterDesc desc = {
         int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk);              \
         if (chunkSize <= 0)                                                   \
             continue;                                                         \
-        const unsigned int oldReadLimit = stream->SetReadLimit(               \
-                stream->GetCurrentPos() + chunkSize);
+        const unsigned int oldReadLimit = mStream->SetReadLimit(               \
+                mStream->GetCurrentPos() + chunkSize);
 
 // ------------------------------------------------------------------------------------------------
 // End a parsing block
 // Must follow at the end of each parsing block, reset chunk end marker to previous value
 #define ASSIMP_3DS_END_CHUNK()                  \
-    stream->SkipToReadLimit();                  \
-    stream->SetReadLimit(oldReadLimit);         \
-    if (stream->GetRemainingSizeToLimit() == 0) \
+    mStream->SkipToReadLimit();                  \
+    mStream->SetReadLimit(oldReadLimit);         \
+    if (mStream->GetRemainingSizeToLimit() == 0) \
         return;                                 \
     }
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 Discreet3DSImporter::Discreet3DSImporter() :
-        stream(), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() {
+        mStream(nullptr), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() {
     // empty
 }
 
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-Discreet3DSImporter::~Discreet3DSImporter() = default;
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool Discreet3DSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    static const uint16_t token[] = { 0x4d4d, 0x3dc2 /*, 0x3daa */ };
+    static constexpr uint16_t token[] = { 0x4d4d, 0x3dc2 /*, 0x3daa */ };
     return CheckMagicToken(pIOHandler, pFile, token, AI_COUNT_OF(token), 0, sizeof token[0]);
 }
 
@@ -128,9 +126,7 @@ void Discreet3DSImporter::SetupProperties(const Importer * /*pImp*/) {
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void Discreet3DSImporter::InternReadFile(const std::string &pFile,
-        aiScene *pScene, IOSystem *pIOHandler) {
-
+void Discreet3DSImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     auto theFile = pIOHandler->Open(pFile, "rb");
     if (!theFile) {
         throw DeadlyImportError("3DS: Could not open ", pFile);
@@ -142,14 +138,14 @@ void Discreet3DSImporter::InternReadFile(const std::string &pFile,
     if (theStream.GetRemainingSize() < 16) {
         throw DeadlyImportError("3DS file is either empty or corrupt: ", pFile);
     }
-    this->stream = &theStream;
+    mStream = &theStream;
 
     // Allocate our temporary 3DS representation
-    D3DS::Scene _scene;
+    Scene _scene;
     mScene = &_scene;
 
     // Initialize members
-    D3DS::Node _rootNode("UNNAMED");
+    Node _rootNode("UNNAMED");
     mLastNodeIndex = -1;
     mCurrentNode = &_rootNode;
     mRootNode = mCurrentNode;
@@ -170,12 +166,12 @@ void Discreet3DSImporter::InternReadFile(const std::string &pFile,
     // vectors from the smoothing groups we read from the
     // file.
     for (auto &mesh : mScene->mMeshes) {
-        if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0) {
+        if (!mesh.mFaces.empty() && mesh.mPositions.empty()) {
             throw DeadlyImportError("3DS file contains faces but no vertices: ", pFile);
         }
         CheckIndices(mesh);
         MakeUnique(mesh);
-        ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
+        ComputeNormalsWithSmoothingsGroups<Face>(mesh);
     }
 
     // Replace all occurrences of the default material with a
@@ -200,12 +196,12 @@ void Discreet3DSImporter::InternReadFile(const std::string &pFile,
 
     AI_DEBUG_INVALIDATE_PTR(mRootNode);
     AI_DEBUG_INVALIDATE_PTR(mScene);
-    AI_DEBUG_INVALIDATE_PTR(this->stream);
+    AI_DEBUG_INVALIDATE_PTR(mStream);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Applies a master-scaling factor to the imported scene
-void Discreet3DSImporter::ApplyMasterScale(aiScene *pScene) {
+void Discreet3DSImporter::ApplyMasterScale(const aiScene *pScene) {
     // There are some 3DS files with a zero scaling factor
     if (!mMasterScale)
         mMasterScale = 1.0f;
@@ -227,14 +223,14 @@ void Discreet3DSImporter::ApplyMasterScale(aiScene *pScene) {
 void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk *pcOut) {
     ai_assert(pcOut != nullptr);
 
-    pcOut->Flag = stream->GetI2();
-    pcOut->Size = stream->GetI4();
+    pcOut->Flag = mStream->GetI2();
+    pcOut->Size = mStream->GetI4();
 
-    if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSize()) {
+    if (pcOut->Size - sizeof(Discreet3DS::Chunk) > mStream->GetRemainingSize()) {
         throw DeadlyImportError("Chunk is too large");
     }
 
-    if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSizeToLimit()) {
+    if (pcOut->Size - sizeof(Discreet3DS::Chunk) > mStream->GetRemainingSizeToLimit()) {
         ASSIMP_LOG_ERROR("3DS: Chunk overflow");
     }
 }
@@ -245,8 +241,7 @@ void Discreet3DSImporter::SkipChunk() {
     Discreet3DS::Chunk psChunk;
     ReadChunk(&psChunk);
 
-    stream->IncPtr(psChunk.Size - sizeof(Discreet3DS::Chunk));
-    return;
+    mStream->IncPtr(psChunk.Size - sizeof(Discreet3DS::Chunk));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -263,39 +258,45 @@ void Discreet3DSImporter::ParseMainChunk() {
     case Discreet3DS::CHUNK_MAIN:
         ParseEditorChunk();
         break;
-    };
+    }
 
     ASSIMP_3DS_END_CHUNK();
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code-return"
+#endif
     // recursively continue processing this hierarchy level
     return ParseMainChunk();
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 }
 
 // ------------------------------------------------------------------------------------------------
 void Discreet3DSImporter::ParseEditorChunk() {
-    ASSIMP_3DS_BEGIN_CHUNK();
+    ASSIMP_3DS_BEGIN_CHUNK()
 
     // get chunk type
     switch (chunk.Flag) {
-    case Discreet3DS::CHUNK_OBJMESH:
+        case Discreet3DS::CHUNK_OBJMESH:
+            ParseObjectChunk();
+            break;
 
-        ParseObjectChunk();
+        // NOTE: In several documentations in the internet this
+        // chunk appears at different locations
+        case Discreet3DS::CHUNK_KEYFRAMER:
+            ParseKeyframeChunk();
+            break;
+    
+        case Discreet3DS::CHUNK_VERSION: {
+            // print the version number
+            char buff[10];
+            ASSIMP_itoa10(buff, mStream->GetI2());
+            ASSIMP_LOG_INFO("3DS file format version: ", buff);
+        }
         break;
-
-    // NOTE: In several documentations in the internet this
-    // chunk appears at different locations
-    case Discreet3DS::CHUNK_KEYFRAMER:
-
-        ParseKeyframeChunk();
-        break;
-
-    case Discreet3DS::CHUNK_VERSION: {
-        // print the version number
-        char buff[10];
-        ASSIMP_itoa10(buff, stream->GetI2());
-        ASSIMP_LOG_INFO("3DS file format version: ", buff);
-    } break;
     };
-    ASSIMP_3DS_END_CHUNK();
+    ASSIMP_3DS_END_CHUNK()
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -306,10 +307,10 @@ void Discreet3DSImporter::ParseObjectChunk() {
     switch (chunk.Flag) {
     case Discreet3DS::CHUNK_OBJBLOCK: {
         unsigned int cnt = 0;
-        const char *sz = (const char *)stream->GetPtr();
+        const auto *sz = (const char *)mStream->GetPtr();
 
         // Get the name of the geometry object
-        while (stream->GetI1())
+        while (mStream->GetI1())
             ++cnt;
         ParseChunk(sz, cnt);
     } break;
@@ -337,8 +338,8 @@ void Discreet3DSImporter::ParseObjectChunk() {
         // Specifies the background image. The string should already be
         // properly 0 terminated but we need to be sure
         unsigned int cnt = 0;
-        const char *sz = (const char *)stream->GetPtr();
-        while (stream->GetI1())
+        auto *sz = (const char *)mStream->GetPtr();
+        while (mStream->GetI1())
             ++cnt;
         mBackgroundImage = std::string(sz, cnt);
     } break;
@@ -349,7 +350,7 @@ void Discreet3DSImporter::ParseObjectChunk() {
 
     case Discreet3DS::CHUNK_MASTER_SCALE:
         // Scene master scaling factor
-        mMasterScale = stream->GetF4();
+        mMasterScale = mStream->GetF4();
         break;
     };
     ASSIMP_3DS_END_CHUNK();
@@ -362,7 +363,7 @@ void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) {
     // IMPLEMENTATION NOTE;
     // Cameras or lights define their transformation in their parent node and in the
     // corresponding light or camera chunks. However, we read and process the latter
-    // to to be able to return valid cameras/lights even if no scenegraph is given.
+    // to be able to return valid cameras/lights even if no scenegraph is given.
 
     // get chunk type
     switch (chunk.Flag) {
@@ -376,15 +377,15 @@ void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) {
 
     case Discreet3DS::CHUNK_LIGHT: {
         // This starts a new light
-        aiLight *light = new aiLight();
+        auto *light = new aiLight();
         mScene->mLights.push_back(light);
 
         light->mName.Set(std::string(name, num));
 
         // First read the position of the light
-        light->mPosition.x = stream->GetF4();
-        light->mPosition.y = stream->GetF4();
-        light->mPosition.z = stream->GetF4();
+        light->mPosition.x = mStream->GetF4();
+        light->mPosition.y = mStream->GetF4();
+        light->mPosition.z = mStream->GetF4();
 
         light->mColorDiffuse = aiColor3D(1.f, 1.f, 1.f);
 
@@ -405,19 +406,19 @@ void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) {
 
     case Discreet3DS::CHUNK_CAMERA: {
         // This starts a new camera
-        aiCamera *camera = new aiCamera();
+        auto *camera = new aiCamera();
         mScene->mCameras.push_back(camera);
         camera->mName.Set(std::string(name, num));
 
         // First read the position of the camera
-        camera->mPosition.x = stream->GetF4();
-        camera->mPosition.y = stream->GetF4();
-        camera->mPosition.z = stream->GetF4();
+        camera->mPosition.x = mStream->GetF4();
+        camera->mPosition.y = mStream->GetF4();
+        camera->mPosition.z = mStream->GetF4();
 
         // Then the camera target
-        camera->mLookAt.x = stream->GetF4() - camera->mPosition.x;
-        camera->mLookAt.y = stream->GetF4() - camera->mPosition.y;
-        camera->mLookAt.z = stream->GetF4() - camera->mPosition.z;
+        camera->mLookAt.x = mStream->GetF4() - camera->mPosition.x;
+        camera->mLookAt.y = mStream->GetF4() - camera->mPosition.y;
+        camera->mLookAt.z = mStream->GetF4() - camera->mPosition.z;
         ai_real len = camera->mLookAt.Length();
         if (len < 1e-5) {
 
@@ -429,12 +430,12 @@ void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) {
             camera->mLookAt /= len;
 
         // And finally - the camera rotation angle, in counter clockwise direction
-        const ai_real angle = AI_DEG_TO_RAD(stream->GetF4());
+        const ai_real angle = AI_DEG_TO_RAD(mStream->GetF4());
         aiQuaternion quat(camera->mLookAt, angle);
         camera->mUp = quat.GetMatrix() * aiVector3D(0.0, 1.0, 0.0);
 
         // Read the lense angle
-        camera->mHorizontalFOV = AI_DEG_TO_RAD(stream->GetF4());
+        camera->mHorizontalFOV = AI_DEG_TO_RAD(mStream->GetF4());
         if (camera->mHorizontalFOV < 0.001f) {
             camera->mHorizontalFOV = float(AI_DEG_TO_RAD(45.f));
         }
@@ -460,34 +461,34 @@ void Discreet3DSImporter::ParseLightChunk() {
         light->mType = aiLightSource_SPOT;
 
         // We wouldn't need to normalize here, but we do it
-        light->mDirection.x = stream->GetF4() - light->mPosition.x;
-        light->mDirection.y = stream->GetF4() - light->mPosition.y;
-        light->mDirection.z = stream->GetF4() - light->mPosition.z;
+        light->mDirection.x = mStream->GetF4() - light->mPosition.x;
+        light->mDirection.y = mStream->GetF4() - light->mPosition.y;
+        light->mDirection.z = mStream->GetF4() - light->mPosition.z;
         light->mDirection.Normalize();
 
         // Now the hotspot and falloff angles - in degrees
-        light->mAngleInnerCone = AI_DEG_TO_RAD(stream->GetF4());
+        light->mAngleInnerCone = AI_DEG_TO_RAD(mStream->GetF4());
 
         // FIX: the falloff angle is just an offset
-        light->mAngleOuterCone = light->mAngleInnerCone + AI_DEG_TO_RAD(stream->GetF4());
+        light->mAngleOuterCone = light->mAngleInnerCone + AI_DEG_TO_RAD(mStream->GetF4());
         break;
 
         // intensity multiplier
     case Discreet3DS::CHUNK_DL_MULTIPLIER:
-        light->mColorDiffuse = light->mColorDiffuse * stream->GetF4();
+        light->mColorDiffuse = light->mColorDiffuse * mStream->GetF4();
         break;
 
         // light color
     case Discreet3DS::CHUNK_RGBF:
     case Discreet3DS::CHUNK_LINRGBF:
-        light->mColorDiffuse.r *= stream->GetF4();
-        light->mColorDiffuse.g *= stream->GetF4();
-        light->mColorDiffuse.b *= stream->GetF4();
+        light->mColorDiffuse.r *= mStream->GetF4();
+        light->mColorDiffuse.g *= mStream->GetF4();
+        light->mColorDiffuse.b *= mStream->GetF4();
         break;
 
         // light attenuation
     case Discreet3DS::CHUNK_DL_ATTENUATE:
-        light->mAttenuationLinear = stream->GetF4();
+        light->mAttenuationLinear = mStream->GetF4();
         break;
     };
 
@@ -502,10 +503,10 @@ void Discreet3DSImporter::ParseCameraChunk() {
     // get chunk type
     switch (chunk.Flag) {
         // near and far clip plane
-    case Discreet3DS::CHUNK_CAM_RANGES:
-        camera->mClipPlaneNear = stream->GetF4();
-        camera->mClipPlaneFar = stream->GetF4();
-        break;
+        case Discreet3DS::CHUNK_CAM_RANGES:
+            camera->mClipPlaneNear = mStream->GetF4();
+            camera->mClipPlaneFar = mStream->GetF4();
+            break;
     }
 
     ASSIMP_3DS_END_CHUNK();
@@ -552,14 +553,13 @@ void Discreet3DSImporter::InverseNodeSearch(D3DS::Node *pcNode, D3DS::Node *pcCu
 
 // ------------------------------------------------------------------------------------------------
 // Find a node with a specific name in the import hierarchy
-D3DS::Node *FindNode(D3DS::Node *root, const std::string &name) {
+Node *FindNode(Node *root, const std::string &name) {
     if (root->mName == name) {
         return root;
     }
 
-    for (std::vector<D3DS::Node *>::iterator it = root->mChildren.begin(); it != root->mChildren.end(); ++it) {
-        D3DS::Node *nd = FindNode(*it, name);
-        if (nullptr != nd) {
+    for (auto it = root->mChildren.begin(); it != root->mChildren.end(); ++it) {
+        if (auto *nd = FindNode(*it, name); nullptr != nd) {
             return nd;
         }
     }
@@ -577,7 +577,7 @@ bool KeyUniqueCompare(const T &first, const T &second) {
 // ------------------------------------------------------------------------------------------------
 // Skip some additional import data.
 void Discreet3DSImporter::SkipTCBInfo() {
-    unsigned int flags = stream->GetI2();
+    unsigned int flags = mStream->GetI2();
 
     if (!flags) {
         // Currently we can't do anything with these values. They occur
@@ -588,19 +588,19 @@ void Discreet3DSImporter::SkipTCBInfo() {
     }
 
     if (flags & Discreet3DS::KEY_USE_TENS) {
-        stream->IncPtr(4);
+        mStream->IncPtr(4);
     }
     if (flags & Discreet3DS::KEY_USE_BIAS) {
-        stream->IncPtr(4);
+        mStream->IncPtr(4);
     }
     if (flags & Discreet3DS::KEY_USE_CONT) {
-        stream->IncPtr(4);
+        mStream->IncPtr(4);
     }
     if (flags & Discreet3DS::KEY_USE_EASE_FROM) {
-        stream->IncPtr(4);
+        mStream->IncPtr(4);
     }
     if (flags & Discreet3DS::KEY_USE_EASE_TO) {
-        stream->IncPtr(4);
+        mStream->IncPtr(4);
     }
 }
 
@@ -619,15 +619,15 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
 
             // First of all: get the name of the object
             unsigned int cnt = 0;
-            const char *sz = (const char *)stream->GetPtr();
+            auto *sz = (const char *)mStream->GetPtr();
 
-            while (stream->GetI1())
+            while (mStream->GetI1())
                 ++cnt;
             std::string name = std::string(sz, cnt);
 
             // Now find out whether we have this node already (target animation channels
             // are stored with a separate object ID)
-            D3DS::Node *pcNode = FindNode(mRootNode, name);
+            Node *pcNode = FindNode(mRootNode, name);
             int instanceNumber = 1;
 
             if (pcNode) {
@@ -643,10 +643,10 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
             pcNode->mInstanceNumber = instanceNumber;
 
             // There are two unknown values which we can safely ignore
-            stream->IncPtr(4);
+            mStream->IncPtr(4);
 
             // Now read the hierarchy position of the object
-            uint16_t hierarchy = stream->GetI2() + 1;
+            uint16_t hierarchy = mStream->GetI2() + 1;
             pcNode->mHierarchyPos = hierarchy;
             pcNode->mHierarchyIndex = mLastNodeIndex;
 
@@ -675,8 +675,8 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
 
         // This is the "real" name of a $$$DUMMY object
         {
-            const char *sz = (const char *)stream->GetPtr();
-            while (stream->GetI1())
+            const char *sz = (const char *)mStream->GetPtr();
+            while (mStream->GetI1())
                 ;
 
             // If object name is DUMMY, take this one instead
@@ -695,16 +695,16 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
         }
 
         // Pivot = origin of rotation and scaling
-        mCurrentNode->vPivot.x = stream->GetF4();
-        mCurrentNode->vPivot.y = stream->GetF4();
-        mCurrentNode->vPivot.z = stream->GetF4();
+        mCurrentNode->vPivot.x = mStream->GetF4();
+        mCurrentNode->vPivot.y = mStream->GetF4();
+        mCurrentNode->vPivot.z = mStream->GetF4();
         break;
 
         // ////////////////////////////////////////////////////////////////////
         // POSITION KEYFRAME
     case Discreet3DS::CHUNK_TRACKPOS: {
-        stream->IncPtr(10);
-        const unsigned int numFrames = stream->GetI4();
+        mStream->IncPtr(10);
+        const unsigned int numFrames = mStream->GetI4();
         bool sortKeys = false;
 
         // This could also be meant as the target position for
@@ -717,16 +717,16 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
 
         l->reserve(numFrames);
         for (unsigned int i = 0; i < numFrames; ++i) {
-            const unsigned int fidx = stream->GetI4();
+            const unsigned int fidx = mStream->GetI4();
 
             // Setup a new position key
             aiVectorKey v;
             v.mTime = (double)fidx;
 
             SkipTCBInfo();
-            v.mValue.x = stream->GetF4();
-            v.mValue.y = stream->GetF4();
-            v.mValue.z = stream->GetF4();
+            v.mValue.x = mStream->GetF4();
+            v.mValue.y = mStream->GetF4();
+            v.mValue.z = mStream->GetF4();
 
             // check whether we'll need to sort the keys
             if (!l->empty() && v.mTime <= l->back().mTime)
@@ -756,11 +756,11 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
         bool sortKeys = false;
         std::vector<aiFloatKey> *l = &mCurrentNode->aCameraRollKeys;
 
-        stream->IncPtr(10);
-        const unsigned int numFrames = stream->GetI4();
+        mStream->IncPtr(10);
+        const unsigned int numFrames = mStream->GetI4();
         l->reserve(numFrames);
         for (unsigned int i = 0; i < numFrames; ++i) {
-            const unsigned int fidx = stream->GetI4();
+            const unsigned int fidx = mStream->GetI4();
 
             // Setup a new position key
             aiFloatKey v;
@@ -768,7 +768,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
 
             // This is just a single float
             SkipTCBInfo();
-            v.mValue = stream->GetF4();
+            v.mValue = mStream->GetF4();
 
             // Check whether we'll need to sort the keys
             if (!l->empty() && v.mTime <= l->back().mTime)
@@ -795,26 +795,26 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
         // ////////////////////////////////////////////////////////////////////
         // ROTATION KEYFRAME
     case Discreet3DS::CHUNK_TRACKROTATE: {
-        stream->IncPtr(10);
-        const unsigned int numFrames = stream->GetI4();
+        mStream->IncPtr(10);
+        const unsigned int numFrames = mStream->GetI4();
 
         bool sortKeys = false;
         std::vector<aiQuatKey> *l = &mCurrentNode->aRotationKeys;
         l->reserve(numFrames);
 
         for (unsigned int i = 0; i < numFrames; ++i) {
-            const unsigned int fidx = stream->GetI4();
+            const unsigned int fidx = mStream->GetI4();
             SkipTCBInfo();
 
             aiQuatKey v;
             v.mTime = (double)fidx;
 
             // The rotation keyframe is given as an axis-angle pair
-            const float rad = stream->GetF4();
+            const float rad = mStream->GetF4();
             aiVector3D axis;
-            axis.x = stream->GetF4();
-            axis.y = stream->GetF4();
-            axis.z = stream->GetF4();
+            axis.x = mStream->GetF4();
+            axis.y = mStream->GetF4();
+            axis.z = mStream->GetF4();
 
             if (!axis.x && !axis.y && !axis.z)
                 axis.y = 1.f;
@@ -839,16 +839,16 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
         // ////////////////////////////////////////////////////////////////////
         // SCALING KEYFRAME
     case Discreet3DS::CHUNK_TRACKSCALE: {
-        stream->IncPtr(10);
-        const unsigned int numFrames = stream->GetI2();
-        stream->IncPtr(2);
+        mStream->IncPtr(10);
+        const unsigned int numFrames = mStream->GetI2();
+        mStream->IncPtr(2);
 
         bool sortKeys = false;
         std::vector<aiVectorKey> *l = &mCurrentNode->aScalingKeys;
         l->reserve(numFrames);
 
         for (unsigned int i = 0; i < numFrames; ++i) {
-            const unsigned int fidx = stream->GetI4();
+            const unsigned int fidx = mStream->GetI4();
             SkipTCBInfo();
 
             // Setup a new key
@@ -856,9 +856,9 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
             v.mTime = (double)fidx;
 
             // ... and read its value
-            v.mValue.x = stream->GetF4();
-            v.mValue.y = stream->GetF4();
-            v.mValue.z = stream->GetF4();
+            v.mValue.x = mStream->GetF4();
+            v.mValue.y = mStream->GetF4();
+            v.mValue.z = mStream->GetF4();
 
             // check whether we'll need to sort the keys
             if (!l->empty() && v.mTime <= l->back().mTime)
@@ -899,23 +899,23 @@ void Discreet3DSImporter::ParseFaceChunk() {
         if (num > mMesh.mFaces.size()) {
             throw DeadlyImportError("3DS: More smoothing groups than faces");
         }
-        for (std::vector<D3DS::Face>::iterator i = mMesh.mFaces.begin(); m != num; ++i, ++m) {
+        for (auto i = mMesh.mFaces.begin(); m != num; ++i, ++m) {
             // nth bit is set for nth smoothing group
-            (*i).iSmoothGroup = stream->GetI4();
+            i->iSmoothGroup = mStream->GetI4();
         }
     } break;
 
     case Discreet3DS::CHUNK_FACEMAT: {
         // at fist an asciiz with the material name
-        const char *sz = (const char *)stream->GetPtr();
-        while (stream->GetI1())
+        const char *sz = (const char *)mStream->GetPtr();
+        while (mStream->GetI1())
             ;
 
         // find the index of the material
         unsigned int idx = 0xcdcdcdcd, cnt = 0;
-        for (std::vector<D3DS::Material>::const_iterator i = mScene->mMaterials.begin(); i != mScene->mMaterials.end(); ++i, ++cnt) {
+        for (auto i = mScene->mMaterials.begin(); i != mScene->mMaterials.end(); ++i, ++cnt) {
             // use case independent comparisons. hopefully it will work.
-            if ((*i).mName.length() && !ASSIMP_stricmp(sz, (*i).mName.c_str())) {
+            if (i->mName.length() && !ASSIMP_stricmp(sz, i->mName.c_str())) {
                 idx = cnt;
                 break;
             }
@@ -925,9 +925,9 @@ void Discreet3DSImporter::ParseFaceChunk() {
         }
 
         // Now continue and read all material indices
-        cnt = (uint16_t)stream->GetI2();
+        cnt = (uint16_t)mStream->GetI2();
         for (unsigned int i = 0; i < cnt; ++i) {
-            unsigned int fidx = (uint16_t)stream->GetI2();
+            unsigned int fidx = (uint16_t)mStream->GetI2();
 
             // check range
             if (fidx >= mMesh.mFaceMaterials.size()) {
@@ -952,59 +952,59 @@ void Discreet3DSImporter::ParseMeshChunk() {
     switch (chunk.Flag) {
     case Discreet3DS::CHUNK_VERTLIST: {
         // This is the list of all vertices in the current mesh
-        int num = (int)(uint16_t)stream->GetI2();
+        int num = (int)(uint16_t)mStream->GetI2();
         mMesh.mPositions.reserve(num);
         while (num-- > 0) {
             aiVector3D v;
-            v.x = stream->GetF4();
-            v.y = stream->GetF4();
-            v.z = stream->GetF4();
+            v.x = mStream->GetF4();
+            v.y = mStream->GetF4();
+            v.z = mStream->GetF4();
             mMesh.mPositions.push_back(v);
         }
     } break;
     case Discreet3DS::CHUNK_TRMATRIX: {
         // This is the RLEATIVE transformation matrix of the current mesh. Vertices are
         // pretransformed by this matrix wonder.
-        mMesh.mMat.a1 = stream->GetF4();
-        mMesh.mMat.b1 = stream->GetF4();
-        mMesh.mMat.c1 = stream->GetF4();
-        mMesh.mMat.a2 = stream->GetF4();
-        mMesh.mMat.b2 = stream->GetF4();
-        mMesh.mMat.c2 = stream->GetF4();
-        mMesh.mMat.a3 = stream->GetF4();
-        mMesh.mMat.b3 = stream->GetF4();
-        mMesh.mMat.c3 = stream->GetF4();
-        mMesh.mMat.a4 = stream->GetF4();
-        mMesh.mMat.b4 = stream->GetF4();
-        mMesh.mMat.c4 = stream->GetF4();
+        mMesh.mMat.a1 = mStream->GetF4();
+        mMesh.mMat.b1 = mStream->GetF4();
+        mMesh.mMat.c1 = mStream->GetF4();
+        mMesh.mMat.a2 = mStream->GetF4();
+        mMesh.mMat.b2 = mStream->GetF4();
+        mMesh.mMat.c2 = mStream->GetF4();
+        mMesh.mMat.a3 = mStream->GetF4();
+        mMesh.mMat.b3 = mStream->GetF4();
+        mMesh.mMat.c3 = mStream->GetF4();
+        mMesh.mMat.a4 = mStream->GetF4();
+        mMesh.mMat.b4 = mStream->GetF4();
+        mMesh.mMat.c4 = mStream->GetF4();
     } break;
 
     case Discreet3DS::CHUNK_MAPLIST: {
         // This is the list of all UV coords in the current mesh
-        int num = (int)(uint16_t)stream->GetI2();
+        int num = (int)(uint16_t)mStream->GetI2();
         mMesh.mTexCoords.reserve(num);
         while (num-- > 0) {
             aiVector3D v;
-            v.x = stream->GetF4();
-            v.y = stream->GetF4();
+            v.x = mStream->GetF4();
+            v.y = mStream->GetF4();
             mMesh.mTexCoords.push_back(v);
         }
     } break;
 
     case Discreet3DS::CHUNK_FACELIST: {
         // This is the list of all faces in the current mesh
-        int num = (int)(uint16_t)stream->GetI2();
+        int num = (int)(uint16_t)mStream->GetI2();
         mMesh.mFaces.reserve(num);
         while (num-- > 0) {
             // 3DS faces are ALWAYS triangles
             mMesh.mFaces.emplace_back();
-            D3DS::Face &sFace = mMesh.mFaces.back();
+            Face &sFace = mMesh.mFaces.back();
 
-            sFace.mIndices[0] = (uint16_t)stream->GetI2();
-            sFace.mIndices[1] = (uint16_t)stream->GetI2();
-            sFace.mIndices[2] = (uint16_t)stream->GetI2();
+            sFace.mIndices[0] = (uint16_t)mStream->GetI2();
+            sFace.mIndices[1] = (uint16_t)mStream->GetI2();
+            sFace.mIndices[2] = (uint16_t)mStream->GetI2();
 
-            stream->IncPtr(2); // skip edge visibility flag
+            mStream->IncPtr(2); // skip edge visibility flag
         }
 
         // Resize the material array (0xcdcdcdcd marks the default material; so if a face is
@@ -1012,7 +1012,7 @@ void Discreet3DSImporter::ParseMeshChunk() {
         mMesh.mFaceMaterials.resize(mMesh.mFaces.size(), 0xcdcdcdcd);
 
         // Larger 3DS files could have multiple FACE chunks here
-        chunkSize = (int)stream->GetRemainingSizeToLimit();
+        chunkSize = (int)mStream->GetRemainingSizeToLimit();
         if (chunkSize > (int)sizeof(Discreet3DS::Chunk))
             ParseFaceChunk();
     } break;
@@ -1029,9 +1029,9 @@ void Discreet3DSImporter::ParseMaterialChunk() {
 
     {
         // The material name string is already zero-terminated, but we need to be sure ...
-        const char *sz = (const char *)stream->GetPtr();
+        const char *sz = (const char *)mStream->GetPtr();
         unsigned int cnt = 0;
-        while (stream->GetI1())
+        while (mStream->GetI1())
             ++cnt;
 
         if (!cnt) {
@@ -1099,7 +1099,7 @@ void Discreet3DSImporter::ParseMaterialChunk() {
 
     case Discreet3DS::CHUNK_MAT_SHADING:
         // This is the material shading mode
-        mScene->mMaterials.back().mShading = (D3DS::Discreet3DS::shadetype3ds)stream->GetI2();
+        mScene->mMaterials.back().mShading = (Discreet3DS::shadetype3ds)mStream->GetI2();
         break;
 
     case Discreet3DS::CHUNK_MAT_TWO_SIDE:
@@ -1175,31 +1175,31 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture *pcOut) {
     switch (chunk.Flag) {
     case Discreet3DS::CHUNK_MAPFILE: {
         // The material name string is already zero-terminated, but we need to be sure ...
-        const char *sz = (const char *)stream->GetPtr();
+        const char *sz = (const char *)mStream->GetPtr();
         unsigned int cnt = 0;
-        while (stream->GetI1())
+        while (mStream->GetI1())
             ++cnt;
         pcOut->mMapName = std::string(sz, cnt);
     } break;
 
     case Discreet3DS::CHUNK_PERCENTD:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = ai_real(stream->GetF8());
+        pcOut->mTextureBlend = ai_real(mStream->GetF8());
         break;
 
     case Discreet3DS::CHUNK_PERCENTF:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = stream->GetF4();
+        pcOut->mTextureBlend = mStream->GetF4();
         break;
 
     case Discreet3DS::CHUNK_PERCENTW:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / ai_real(100.0);
+        pcOut->mTextureBlend = (ai_real)((uint16_t) mStream->GetI2()) / ai_real(100.0);
         break;
 
     case Discreet3DS::CHUNK_MAT_MAP_USCALE:
         // Texture coordinate scaling in the U direction
-        pcOut->mScaleU = stream->GetF4();
+        pcOut->mScaleU = mStream->GetF4();
         if (0.0f == pcOut->mScaleU) {
             ASSIMP_LOG_WARN("Texture coordinate scaling in the x direction is zero. Assuming 1.");
             pcOut->mScaleU = 1.0f;
@@ -1207,7 +1207,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture *pcOut) {
         break;
     case Discreet3DS::CHUNK_MAT_MAP_VSCALE:
         // Texture coordinate scaling in the V direction
-        pcOut->mScaleV = stream->GetF4();
+        pcOut->mScaleV = mStream->GetF4();
         if (0.0f == pcOut->mScaleV) {
             ASSIMP_LOG_WARN("Texture coordinate scaling in the y direction is zero. Assuming 1.");
             pcOut->mScaleV = 1.0f;
@@ -1216,21 +1216,21 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture *pcOut) {
 
     case Discreet3DS::CHUNK_MAT_MAP_UOFFSET:
         // Texture coordinate offset in the U direction
-        pcOut->mOffsetU = -stream->GetF4();
+        pcOut->mOffsetU = -mStream->GetF4();
         break;
 
     case Discreet3DS::CHUNK_MAT_MAP_VOFFSET:
         // Texture coordinate offset in the V direction
-        pcOut->mOffsetV = stream->GetF4();
+        pcOut->mOffsetV = mStream->GetF4();
         break;
 
     case Discreet3DS::CHUNK_MAT_MAP_ANG:
         // Texture coordinate rotation, CCW in DEGREES
-        pcOut->mRotation = -AI_DEG_TO_RAD(stream->GetF4());
+        pcOut->mRotation = -AI_DEG_TO_RAD(mStream->GetF4());
         break;
 
     case Discreet3DS::CHUNK_MAT_MAP_TILING: {
-        const uint16_t iFlags = stream->GetI2();
+        const uint16_t iFlags = mStream->GetI2();
 
         // Get the mapping mode (for both axes)
         if (iFlags & 0x2u)
@@ -1255,9 +1255,11 @@ ai_real Discreet3DSImporter::ParsePercentageChunk() {
     ReadChunk(&chunk);
 
     if (Discreet3DS::CHUNK_PERCENTF == chunk.Flag) {
-        return stream->GetF4() * ai_real(100) / ai_real(0xFFFF);
-    } else if (Discreet3DS::CHUNK_PERCENTW == chunk.Flag) {
-        return (ai_real)((uint16_t)stream->GetI2()) / (ai_real)0xFFFF;
+        return mStream->GetF4() * ai_real(100) / ai_real(0xFFFF);
+    }
+
+    if (Discreet3DS::CHUNK_PERCENTW == chunk.Flag) {
+        return (ai_real)((uint16_t)mStream->GetI2()) / (ai_real)0xFFFF;
     }
 
     return get_qnan();
@@ -1288,9 +1290,9 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) {
             *out = clrError;
             return;
         }
-        out->r = stream->GetF4();
-        out->g = stream->GetF4();
-        out->b = stream->GetF4();
+        out->r = mStream->GetF4();
+        out->g = mStream->GetF4();
+        out->b = mStream->GetF4();
         break;
 
     case Discreet3DS::CHUNK_LINRGBB:
@@ -1302,15 +1304,15 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) {
             return;
         }
         const ai_real invVal = ai_real(1.0) / ai_real(255.0);
-        out->r = (ai_real)(uint8_t)stream->GetI1() * invVal;
-        out->g = (ai_real)(uint8_t)stream->GetI1() * invVal;
-        out->b = (ai_real)(uint8_t)stream->GetI1() * invVal;
+        out->r = (ai_real)(uint8_t)mStream->GetI1() * invVal;
+        out->g = (ai_real)(uint8_t)mStream->GetI1() * invVal;
+        out->b = (ai_real)(uint8_t)mStream->GetI1() * invVal;
     } break;
 
     // Percentage chunks are accepted, too.
     case Discreet3DS::CHUNK_PERCENTF:
         if (acceptPercent && 4 <= diff) {
-            out->g = out->b = out->r = stream->GetF4();
+            out->g = out->b = out->r = mStream->GetF4();
             break;
         }
         *out = clrError;
@@ -1318,18 +1320,20 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) {
 
     case Discreet3DS::CHUNK_PERCENTW:
         if (acceptPercent && 1 <= diff) {
-            out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / ai_real(255.0);
+            out->g = out->b = out->r = (ai_real)(uint8_t)mStream->GetI1() / ai_real(255.0);
             break;
         }
         *out = clrError;
         return;
 
     default:
-        stream->IncPtr(diff);
+        mStream->IncPtr(diff);
         // Skip unknown chunks, hope this won't cause any problems.
         return ParseColorChunk(out, acceptPercent);
     };
     (void)bGamma;
 }
 
+} // namespace Assimp
+
 #endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER

code/AssetLib/3DS/3DSLoader.h

@@ -1,10 +1,8 @@
-
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -51,24 +49,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/BaseImporter.h>
 #include <assimp/types.h>
 
-
 #include "3DSHelper.h"
 #include <assimp/StreamReader.h>
 
 struct aiNode;
 
-namespace Assimp    {
-
-
-using namespace D3DS;
+namespace Assimp {
 
 // ---------------------------------------------------------------------------------
 /** Importer class for 3D Studio r3 and r4 3DS files
  */
-class Discreet3DSImporter : public BaseImporter {
+class Discreet3DSImporter final : public BaseImporter {
 public:
     Discreet3DSImporter();
-    ~Discreet3DSImporter();
+    ~Discreet3DSImporter() override = default;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
@@ -102,15 +96,14 @@ protected:
     // -------------------------------------------------------------------
     /** Converts a temporary material to the outer representation
      */
-    void ConvertMaterial(D3DS::Material& p_cMat,
-        aiMaterial& p_pcOut);
+    void ConvertMaterial(D3DS::Material& p_cMat, aiMaterial& p_pcOut);
 
     // -------------------------------------------------------------------
     /** Read a chunk
      *
      *  @param pcOut Receives the current chunk
      */
-    void ReadChunk(Discreet3DS::Chunk* pcOut);
+    void ReadChunk(D3DS::Discreet3DS::Chunk* pcOut);
 
     // -------------------------------------------------------------------
     /** Parse a percentage chunk. mCurrent will point to the next
@@ -120,13 +113,10 @@ protected:
     ai_real ParsePercentageChunk();
 
     // -------------------------------------------------------------------
-    /** Parse a color chunk. mCurrent will point to the next
-    * chunk behind afterwards. If no color chunk is found
-    * QNAN is returned in all members.
-    */
-    void ParseColorChunk(aiColor3D* p_pcOut,
-        bool p_bAcceptPercent = true);
-
+    /** Parse a color chunk. mCurrent will point to the next chunk behind
+     * afterward. If no color chunk is found QNAN is returned in all members.
+     */
+    void ParseColorChunk(aiColor3D* p_pcOut, bool p_bAcceptPercent = true);
 
     // -------------------------------------------------------------------
     /** Skip a chunk in the file
@@ -134,7 +124,7 @@ protected:
     void SkipChunk();
 
     // -------------------------------------------------------------------
-    /** Generate the nodegraph
+    /** Generate the node-graph
     */
     void GenerateNodeGraph(aiScene* pcOut);
 
@@ -230,19 +220,19 @@ protected:
     // -------------------------------------------------------------------
     /** Add a node to the node graph
     */
-    void AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,D3DS::Node* pcIn,
+    void AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut, D3DS::Node* pcIn,
         aiMatrix4x4& absTrafo);
 
     // -------------------------------------------------------------------
     /** Search for a node in the graph.
     * Called recursively
     */
-    void InverseNodeSearch(D3DS::Node* pcNode,D3DS::Node* pcCurrent);
+    void InverseNodeSearch(D3DS::Node* pcNode, D3DS::Node* pcCurrent);
 
     // -------------------------------------------------------------------
     /** Apply the master scaling factor to the mesh
     */
-    void ApplyMasterScale(aiScene* pScene);
+    void ApplyMasterScale(const aiScene* pScene);
 
     // -------------------------------------------------------------------
     /** Clamp all indices in the file to a valid range
@@ -254,31 +244,26 @@ protected:
     */
     void SkipTCBInfo();
 
-protected:
-
-    /** Stream to read from */
-    StreamReaderLE* stream;
-
-    /** Last touched node index */
+private:
+    /// Stream to read from
+    StreamReaderLE* mStream;
+    /// Last touched node index
     short mLastNodeIndex;
-
-    /** Current node, root node */
-    D3DS::Node* mCurrentNode, *mRootNode;
-
-    /** Scene under construction */
+    /// Current node
+    D3DS::Node* mCurrentNode;
+    /// Root node
+    D3DS::Node *mRootNode;
+    /// Scene under construction
     D3DS::Scene* mScene;
-
-    /** Ambient base color of the scene */
+    /// Ambient base color of the scene
     aiColor3D mClrAmbient;
-
-    /** Master scaling factor of the scene */
+    /// Master scaling factor of the scene
     ai_real mMasterScale;
-
-    /** Path to the background image of the scene */
+    /// Path to the background image of the scene
     std::string mBackgroundImage;
+    /// true for has a background
     bool bHasBG;
-
-    /** true if PRJ file */
+    /// true if PRJ file
     bool bIsPrj;
 };
 

code/AssetLib/3MF/3MFTypes.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -49,14 +49,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 struct aiMaterial;
 struct aiMesh;
 
-namespace Assimp {
-namespace D3MF {
+namespace Assimp:: D3MF {
 
 enum class ResourceType {
     RT_Object,
     RT_BaseMaterials,
     RT_EmbeddedTexture2D,
     RT_Texture2DGroup,
+    RT_ColorGroup,
     RT_Unknown
 }; // To be extended with other resource types (eg. material extension resources like Texture2d, Texture2dGroup...)
 
@@ -64,21 +64,18 @@ class Resource {
 public:
     int mId;
 
-    Resource(int id) :
-            mId(id) {
+    explicit Resource(int id) : mId(id) {
         // empty
     }
 
-    virtual ~Resource() {
-        // empty
-    }
+    virtual ~Resource() = default;
 
     virtual ResourceType getType() const {
         return ResourceType::RT_Unknown;
     }
 };
 
-class EmbeddedTexture : public Resource {
+class EmbeddedTexture final : public Resource {
 public:
     std::string mPath;
     std::string mContentType;
@@ -86,50 +83,57 @@ public:
     std::string mTilestyleV;
     std::vector<char> mBuffer;
 
-    EmbeddedTexture(int id) :
-            Resource(id),
-            mPath(),
-            mContentType(),
-            mTilestyleU(),
-            mTilestyleV() {
+    explicit EmbeddedTexture(int id) : Resource(id) {
         // empty
     }
 
-    ~EmbeddedTexture() = default;
+    ~EmbeddedTexture() override = default;
 
     ResourceType getType() const override {
         return ResourceType::RT_EmbeddedTexture2D;
     }
 };
 
-class Texture2DGroup : public Resource {
+class Texture2DGroup final : public Resource {
 public:
     std::vector<aiVector2D> mTex2dCoords;
     int mTexId;
-    Texture2DGroup(int id) :
-            Resource(id),
-            mTexId(-1) {
+
+    explicit Texture2DGroup(int id) : Resource(id), mTexId(-1) {
         // empty
     }
 
-    ~Texture2DGroup() = default;
+    ~Texture2DGroup() override = default;
 
     ResourceType getType() const override {
         return ResourceType::RT_Texture2DGroup;
     }
 };
 
-class BaseMaterials : public Resource {
+class ColorGroup final : public Resource {
 public:
-    std::vector<unsigned int> mMaterialIndex;
+    std::vector<aiColor4D> mColors;
 
-    BaseMaterials(int id) :
-            Resource(id),
-            mMaterialIndex() {
+    explicit ColorGroup(int id) : Resource(id) {
         // empty
     }
 
-    ~BaseMaterials() = default;
+    ~ColorGroup() override = default;
+
+    ResourceType getType() const override {
+        return ResourceType::RT_ColorGroup;
+    }
+};
+
+class BaseMaterials final : public Resource {
+public:
+    std::vector<unsigned int> mMaterialIndex;
+
+    explicit BaseMaterials(int id) : Resource(id) {
+        // empty
+    }
+
+    ~BaseMaterials() override = default;
 
     ResourceType getType() const override {
         return ResourceType::RT_BaseMaterials;
@@ -141,25 +145,24 @@ struct Component {
     aiMatrix4x4 mTransformation;
 };
 
-class Object : public Resource {
+class Object final : public Resource {
 public:
     std::vector<aiMesh *> mMeshes;
     std::vector<unsigned int> mMeshIndex;
     std::vector<Component> mComponents;
     std::string mName;
 
-    Object(int id) :
+    explicit Object(int id) :
             Resource(id),
             mName(std::string("Object_") + ai_to_string(id)) {
         // empty
     }
 
-    ~Object() = default;
+    ~Object() override = default;
 
     ResourceType getType() const override {
         return ResourceType::RT_Object;
     }
 };
 
-} // namespace D3MF
-} // namespace Assimp
+} // namespace Assimp::D3MF

code/AssetLib/3MF/3MFXmlTags.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -40,80 +40,80 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #pragma once
 
-namespace Assimp {
-namespace D3MF {
-
-namespace XmlTag {
+namespace Assimp::D3MF::XmlTag {
     // Root tag
-    const char* const RootTag = "3MF";
+    constexpr char RootTag[] = "3MF";
 
     // Meta-data
-    const char* const meta = "metadata";
-    const char* const meta_name = "name";
+    constexpr char meta[] = "metadata";
+    constexpr char meta_name[] = "name";
 
     // Model-data specific tags
-    const char* const model = "model";
-    const char* const model_unit = "unit";
-    const char* const metadata = "metadata";
-    const char* const resources = "resources";
-    const char* const object = "object";
-    const char* const mesh = "mesh";
-    const char* const components = "components";
-    const char* const component = "component";
-    const char* const vertices = "vertices";
-    const char* const vertex = "vertex";
-    const char* const triangles = "triangles";
-    const char* const triangle = "triangle";
-    const char* const x = "x";
-    const char* const y = "y";
-    const char* const z = "z";
-    const char* const v1 = "v1";
-    const char* const v2 = "v2";
-    const char* const v3 = "v3";
-    const char* const id = "id";
-    const char* const pid = "pid";
-    const char* const pindex = "pindex";
-    const char* const p1 = "p1";
-    const char *const p2 = "p2";
-    const char *const p3 = "p3";
-    const char* const name = "name";
-    const char* const type = "type";
-    const char* const build = "build";
-    const char* const item = "item";
-    const char* const objectid = "objectid";
-    const char* const transform = "transform";
-    const char *const path = "path";
+    constexpr char model[] = "model";
+    constexpr char model_unit[] = "unit";
+    constexpr char metadata[] = "metadata";
+    constexpr char resources[] = "resources";
+    constexpr char object[] = "object";
+    constexpr char mesh[] = "mesh";
+    constexpr char components[] = "components";
+    constexpr char component[] = "component";
+    constexpr char vertices[] = "vertices";
+    constexpr char vertex[] = "vertex";
+    constexpr char triangles[] = "triangles";
+    constexpr char triangle[] = "triangle";
+    constexpr char x[] = "x";
+    constexpr char y[] = "y";
+    constexpr char z[] = "z";
+    constexpr char v1[] = "v1";
+    constexpr char v2[] = "v2";
+    constexpr char v3[] = "v3";
+    constexpr char id[] = "id";
+    constexpr char pid[] = "pid";
+    constexpr char pindex[] = "pindex";
+    constexpr char p1[] = "p1";
+    constexpr char p2[] = "p2";
+    constexpr char p3[] = "p3";
+    constexpr char name[] = "name";
+    constexpr char type[] = "type";
+    constexpr char build[] = "build";
+    constexpr char item[] = "item";
+    constexpr char objectid[] = "objectid";
+    constexpr char transform[] = "transform";
+    constexpr char path[] = "path";
 
     // Material definitions
-    const char* const basematerials = "basematerials";
-    const char* const basematerials_base = "base";
-    const char* const basematerials_name = "name";
-    const char* const basematerials_displaycolor = "displaycolor";
-    const char* const texture_2d = "m:texture2d";
-    const char *const texture_group = "m:texture2dgroup";
-    const char *const texture_content_type = "contenttype";
-    const char *const texture_tilestyleu = "tilestyleu";
-    const char *const texture_tilestylev = "tilestylev";
-    const char *const texture_2d_coord = "m:tex2coord";
-    const char *const texture_cuurd_u = "u";
-    const char *const texture_cuurd_v = "v";
+    constexpr char basematerials[] = "basematerials";
+    constexpr char basematerials_base[] = "base";
+    constexpr char basematerials_name[] = "name";
+    constexpr char basematerials_displaycolor[] = "displaycolor";
+    constexpr char texture_2d[] = "m:texture2d";
+    constexpr char texture_group[] = "m:texture2dgroup";
+    constexpr char texture_content_type[] = "contenttype";
+    constexpr char texture_tilestyleu[] = "tilestyleu";
+    constexpr char texture_tilestylev[] = "tilestylev";
+    constexpr char texture_2d_coord[] = "m:tex2coord";
+    constexpr char texture_cuurd_u[] = "u";
+    constexpr char texture_cuurd_v[] = "v";
+
+    // vertex color definitions
+    constexpr char colorgroup[] = "m:colorgroup";
+    constexpr char color_item[] = "m:color";
+    constexpr char color_value[] = "color";
 
     // Meta info tags
-    const char* const CONTENT_TYPES_ARCHIVE = "[Content_Types].xml";
-    const char* const ROOT_RELATIONSHIPS_ARCHIVE = "_rels/.rels";
-    const char* const SCHEMA_CONTENTTYPES = "http://schemas.openxmlformats.org/package/2006/content-types";
-    const char* const SCHEMA_RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006/relationships";
-    const char* const RELS_RELATIONSHIP_CONTAINER = "Relationships";
-    const char* const RELS_RELATIONSHIP_NODE = "Relationship";
-    const char* const RELS_ATTRIB_TARGET = "Target";
-    const char* const RELS_ATTRIB_TYPE = "Type";
-    const char* const RELS_ATTRIB_ID = "Id";
-    const char* const PACKAGE_START_PART_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel";
-    const char* const PACKAGE_PRINT_TICKET_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/printticket";
-    const char* const PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
-    const char* const PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
-    const char* const PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
-}
+    constexpr char CONTENT_TYPES_ARCHIVE[] = "[Content_Types].xml";
+    constexpr char ROOT_RELATIONSHIPS_ARCHIVE[] = "_rels/.rels";
+    constexpr char SCHEMA_CONTENTTYPES[] = "http://schemas.openxmlformats.org/package/2006/content-types";
+    constexpr char SCHEMA_RELATIONSHIPS[] = "http://schemas.openxmlformats.org/package/2006/relationships";
+    constexpr char RELS_RELATIONSHIP_CONTAINER[] = "Relationships";
+    constexpr char RELS_RELATIONSHIP_NODE[] = "Relationship";
+    constexpr char RELS_ATTRIB_TARGET[] = "Target";
+    constexpr char RELS_ATTRIB_TYPE[] = "Type";
+    constexpr char RELS_ATTRIB_ID[] = "Id";
+    constexpr char PACKAGE_START_PART_RELATIONSHIP_TYPE[] = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel";
+    constexpr char PACKAGE_PRINT_TICKET_RELATIONSHIP_TYPE[] = "http://schemas.microsoft.com/3dmanufacturing/2013/01/printticket";
+    constexpr char PACKAGE_TEXTURE_RELATIONSHIP_TYPE[] = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
+    constexpr char PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE[] = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+    constexpr char PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE[] = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
 
-} // Namespace D3MF
-} // Namespace Assimp
+} // namespace Assimp::D3MF

code/AssetLib/3MF/D3MFExporter.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -48,7 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/Exporter.hpp>
-#include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 
 #include "3MFXmlTags.h"
@@ -83,7 +82,7 @@ void ExportScene3MF(const char *pFile, IOSystem *pIOSystem, const aiScene *pScen
 namespace D3MF {
 
 D3MFExporter::D3MFExporter(const char *pFile, const aiScene *pScene) :
-        mArchiveName(pFile), m_zipArchive(nullptr), mScene(pScene), mModelOutput(), mRelOutput(), mContentOutput(), mBuildItems(), mRelations() {
+        mArchiveName(pFile), m_zipArchive(nullptr), mScene(pScene) {
     // empty
 }
 
@@ -94,7 +93,7 @@ D3MFExporter::~D3MFExporter() {
     mRelations.clear();
 }
 
-bool D3MFExporter::validate() {
+bool D3MFExporter::validate() const {
     if (mArchiveName.empty()) {
         return false;
     }
@@ -249,10 +248,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 {

code/AssetLib/3MF/D3MFExporter.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -68,7 +68,7 @@ class D3MFExporter {
 public:
     D3MFExporter( const char* pFile, const aiScene* pScene );
     ~D3MFExporter();
-    bool validate();
+    bool validate() const;
     bool exportArchive( const char *file );
     bool exportContentTypes();
     bool exportRelations();

code/AssetLib/3MF/D3MFImporter.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -68,7 +68,7 @@ namespace Assimp {
 
 using namespace D3MF;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "3mf Importer",
     "",
     "",
@@ -81,16 +81,17 @@ static const aiImporterDesc desc = {
     "3mf"
 };
 
-D3MFImporter::D3MFImporter() = default;
-
-D3MFImporter::~D3MFImporter() = default;
-
-bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool /*checkSig*/) const {
+bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool ) const {
     if (!ZipArchiveIOSystem::isZipArchive(pIOHandler, filename)) {
         return false;
     }
-    D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
-    return opcPackage.validate();
+    static constexpr char ModelRef[] = "3D/3dmodel.model";
+    ZipArchiveIOSystem archive(pIOHandler, filename);
+    if (!archive.Exists(ModelRef)) {
+        return false;
+    }
+
+    return true;
 }
 
 void D3MFImporter::SetupProperties(const Importer*) {
@@ -106,7 +107,7 @@ void D3MFImporter::InternReadFile(const std::string &filename, aiScene *pScene,
 
     XmlParser xmlParser;
     if (xmlParser.parse(opcPackage.RootStream())) {
-        XmlSerializer xmlSerializer(&xmlParser);
+        XmlSerializer xmlSerializer(xmlParser);
         xmlSerializer.ImportXml(pScene);
 
         const std::vector<aiTexture*> &tex =  opcPackage.GetEmbeddedTextures();

code/AssetLib/3MF/D3MFImporter.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -53,13 +53,13 @@ namespace Assimp {
 ///
 /// Implements the basic topology import and embedded textures.
 // ---------------------------------------------------------------------------
-class D3MFImporter : public BaseImporter {
+class D3MFImporter final : public BaseImporter {
 public:
     /// @brief The default class constructor.
-    D3MFImporter();
+    D3MFImporter() = default;
 
     ///	@brief  The class destructor.
-    ~D3MFImporter() override;
+    ~D3MFImporter() override = default;
 
     /// @brief Performs the data format detection.
     /// @param pFile        The filename to check.

code/AssetLib/3MF/D3MFOpcPackage.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -65,10 +65,9 @@ namespace D3MF {
 
 using OpcPackageRelationshipPtr = std::shared_ptr<OpcPackageRelationship>;
 
-class OpcPackageRelationshipReader {
+class OpcPackageRelationshipReader final {
 public:
-    OpcPackageRelationshipReader(XmlParser &parser) :
-            m_relationShips() {
+    explicit OpcPackageRelationshipReader(XmlParser &parser) : mRelations() {
         XmlNode root = parser.getRootNode();
         ParseRootNode(root);
     }
@@ -108,20 +107,20 @@ public:
                 relPtr->type = currentNode.attribute(XmlTag::RELS_ATTRIB_TYPE).as_string();
                 relPtr->target = currentNode.attribute(XmlTag::RELS_ATTRIB_TARGET).as_string();
                 if (validateRels(relPtr)) {
-                    m_relationShips.push_back(relPtr);
+                    mRelations.push_back(relPtr);
                 }
             }
         }
     }
 
-    std::vector<OpcPackageRelationshipPtr> m_relationShips;
+    std::vector<OpcPackageRelationshipPtr> mRelations;
 };
 
 static bool IsEmbeddedTexture( const std::string &filename ) {
     const std::string extension = BaseImporter::GetExtension(filename);
-    if (extension == "jpg" || extension == "png") {
+    if (extension == "jpg" || extension == "png" || extension == "jpeg") {
         std::string::size_type pos = filename.find("thumbnail");
-        if (pos == std::string::npos) {
+        if (pos != std::string::npos) {
             return false;
         }
         return true;
@@ -160,7 +159,7 @@ D3MFOpcPackage::D3MFOpcPackage(IOSystem *pIOHandler, const std::string &rFile) :
                     // deal with zip-bug
                     rootFile = rootFile.substr(1);
                 }
-            } 
+            }
 
             ASSIMP_LOG_VERBOSE_DEBUG(rootFile);
 
@@ -186,9 +185,6 @@ D3MFOpcPackage::D3MFOpcPackage(IOSystem *pIOHandler, const std::string &rFile) :
 D3MFOpcPackage::~D3MFOpcPackage() {
     mZipArchive->Close(mRootStream);
     delete mZipArchive;
-    for (auto tex : mEmbeddedTextures) {
-        delete tex;
-    }
 }
 
 IOStream *D3MFOpcPackage::RootStream() const {
@@ -217,11 +213,11 @@ std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream *stream) {
 
     OpcPackageRelationshipReader reader(xmlParser);
 
-    auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr &rel) {
+    auto itr = std::find_if(reader.mRelations.begin(), reader.mRelations.end(), [](const OpcPackageRelationshipPtr &rel) {
         return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
     });
 
-    if (itr == reader.m_relationShips.end()) {
+    if (itr == reader.mRelations.end()) {
         throw DeadlyImportError("Cannot find ", XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE);
     }
 

code/AssetLib/3MF/D3MFOpcPackage.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 

code/AssetLib/3MF/XmlSerializer.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -44,19 +44,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "3MFTypes.h"
 #include <assimp/scene.h>
 
+#include <utility>
+
 namespace Assimp {
 namespace D3MF {
 
-static const int IdNotSet = -1;
+static constexpr int IdNotSet = -1;
 
 namespace {
 
-static const size_t ColRGBA_Len = 9;
-static const size_t ColRGB_Len = 7;
+static constexpr size_t ColRGBA_Len = 9;
+static constexpr size_t ColRGB_Len = 7;
 
 // format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
-bool validateColorString(const char *color) {
-    const size_t len = strlen(color);
+bool validateColorString(const std::string color) {
+    const size_t len = color.size();
     if (ColRGBA_Len != len && ColRGB_Len != len) {
         return false;
     }
@@ -73,7 +75,7 @@ aiFace ReadTriangle(XmlNode &node, int &texId0, int &texId1, int &texId2) {
     face.mIndices[1] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v2).as_string()));
     face.mIndices[2] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v3).as_string()));
 
-    texId0 = texId1 = texId2 = -1;
+    texId0 = texId1 = texId2 = IdNotSet;
     XmlParser::getIntAttribute(node, XmlTag::p1, texId0);
     XmlParser::getIntAttribute(node, XmlTag::p2, texId1);
     XmlParser::getIntAttribute(node, XmlTag::p3, texId2);
@@ -155,8 +157,8 @@ aiMatrix4x4 parseTransformMatrix(const std::string& matrixStr) {
     return transformMatrix;
 }
 
-bool parseColor(const char *color, aiColor4D &diffuse) {
-    if (nullptr == color) {
+bool parseColor(const std::string &color, aiColor4D &diffuse) {
+    if (color.empty()) {
         return false;
     }
 
@@ -176,7 +178,7 @@ bool parseColor(const char *color, aiColor4D &diffuse) {
 
     char b[3] = { color[5], color[6], '\0' };
     diffuse.b = static_cast<ai_real>(strtol(b, nullptr, 16)) / ai_real(255.0);
-    const size_t len = strlen(color);
+    const size_t len = color.size();
     if (ColRGB_Len == len) {
         return true;
     }
@@ -197,11 +199,11 @@ void assignDiffuseColor(XmlNode &node, aiMaterial *mat) {
 
 } // namespace
 
-XmlSerializer::XmlSerializer(XmlParser *xmlParser) :
+XmlSerializer::XmlSerializer(XmlParser &xmlParser) :
         mResourcesDictionnary(),
         mMeshCount(0),
         mXmlParser(xmlParser) {
-    ai_assert(nullptr != xmlParser);
+    // empty
 }
 
 XmlSerializer::~XmlSerializer() {
@@ -214,9 +216,9 @@ void XmlSerializer::ImportXml(aiScene *scene) {
     if (nullptr == scene) {
         return;
     }
-    
+
     scene->mRootNode = new aiNode(XmlTag::RootTag);
-    XmlNode node = mXmlParser->getRootNode().child(XmlTag::model);
+    XmlNode node = mXmlParser.getRootNode().child(XmlTag::model);
     if (node.empty()) {
         return;
     }
@@ -234,6 +236,8 @@ void XmlSerializer::ImportXml(aiScene *scene) {
             ReadBaseMaterials(currentNode);
         } else if (currentNodeName == XmlTag::meta) {
             ReadMetadata(currentNode);
+        } else if (currentNodeName == XmlTag::colorgroup) {
+            ReadColorGroup(currentNode);
         }
     }
     StoreMaterialsInScene(scene);
@@ -329,9 +333,49 @@ void XmlSerializer::ReadObject(XmlNode &node) {
 
             if (hasPid) {
                 auto it = mResourcesDictionnary.find(pid);
-                if (hasPindex && it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_BaseMaterials) {
-                    BaseMaterials *materials = static_cast<BaseMaterials *>(it->second);
-                    mesh->mMaterialIndex = materials->mMaterialIndex[pindex];
+                if (hasPindex && it != mResourcesDictionnary.end()) {
+                    if (it->second->getType() == ResourceType::RT_BaseMaterials) {
+                        BaseMaterials *materials = static_cast<BaseMaterials *>(it->second);
+                        mesh->mMaterialIndex = materials->mMaterialIndex[pindex];
+                    } else if (it->second->getType() == ResourceType::RT_Texture2DGroup) {
+                        Texture2DGroup *group = static_cast<Texture2DGroup *>(it->second);
+                        if (mesh->mTextureCoords[0] == nullptr) {
+                            mesh->mNumUVComponents[0] = 2;
+                            for (unsigned int i = 1; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                                mesh->mNumUVComponents[i] = 0;
+                            }
+
+                            const std::string name = ai_to_string(group->mTexId);
+                            for (size_t i = 0; i < mMaterials.size(); ++i) {
+                                if (name == mMaterials[i]->GetName().C_Str()) {
+                                    mesh->mMaterialIndex = static_cast<unsigned int>(i);
+                                }
+                            }
+
+                            mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
+                            for (unsigned int vertex_idx = 0; vertex_idx < mesh->mNumVertices; vertex_idx++) {
+                                mesh->mTextureCoords[0][vertex_idx] =
+                                        aiVector3D(group->mTex2dCoords[pindex].x, group->mTex2dCoords[pindex].y, 0.0f);
+                            }
+                        } else {
+                            for (unsigned int vertex_idx = 0; vertex_idx < mesh->mNumVertices; vertex_idx++) {
+                                if (mesh->mTextureCoords[0][vertex_idx].z < 0) {
+                                    // use default
+                                    mesh->mTextureCoords[0][vertex_idx] =
+                                            aiVector3D(group->mTex2dCoords[pindex].x, group->mTex2dCoords[pindex].y, 0.0f);
+                                }
+                            }
+                        }
+                    }else if (it->second->getType() == ResourceType::RT_ColorGroup) {
+                        if (mesh->mColors[0] == nullptr) {
+                            mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
+
+                            ColorGroup *group = static_cast<ColorGroup *>(it->second);
+                            for (unsigned int vertex_idx = 0; vertex_idx < mesh->mNumVertices; vertex_idx++) {
+                                mesh->mColors[0][vertex_idx] = group->mColors[pindex];
+                            }
+                        }
+                    }
                 }
             }
 
@@ -413,27 +457,36 @@ void XmlSerializer::ImportTriangles(XmlNode &node, aiMesh *mesh) {
     for (XmlNode &currentNode : node.children()) {
         const std::string currentName = currentNode.name();
         if (currentName == XmlTag::triangle) {
-            int pid = IdNotSet, p1 = IdNotSet;
+            int pid = IdNotSet;
             bool hasPid = getNodeAttribute(currentNode, D3MF::XmlTag::pid, pid);
-            bool hasP1 = getNodeAttribute(currentNode, D3MF::XmlTag::p1, p1);
 
-            int texId[3];
-            Texture2DGroup *group = nullptr;
-            aiFace face = ReadTriangle(currentNode, texId[0], texId[1], texId[2]);
-            if (hasPid && hasP1) {
+            int pindex[3];
+            aiFace face = ReadTriangle(currentNode, pindex[0], pindex[1], pindex[2]);
+            if (hasPid && (pindex[0] != IdNotSet || pindex[1] != IdNotSet || pindex[2] != IdNotSet)) {
                 auto it = mResourcesDictionnary.find(pid);
                 if (it != mResourcesDictionnary.end()) {
                     if (it->second->getType() == ResourceType::RT_BaseMaterials) {
                         BaseMaterials *baseMaterials = static_cast<BaseMaterials *>(it->second);
-                        mesh->mMaterialIndex = baseMaterials->mMaterialIndex[p1];
+
+                        auto update_material = [&](int idx) {
+                            if (pindex[idx] != IdNotSet) {
+                                mesh->mMaterialIndex = baseMaterials->mMaterialIndex[pindex[idx]];
+                            }
+                        };
+
+                        update_material(0);
+                        update_material(1);
+                        update_material(2);
+
                     } else if (it->second->getType() == ResourceType::RT_Texture2DGroup) {
+                        // Load texture coordinates into mesh, when any
+                        Texture2DGroup *group = static_cast<Texture2DGroup *>(it->second); // fix bug
                         if (mesh->mTextureCoords[0] == nullptr) {
                             mesh->mNumUVComponents[0] = 2;
                             for (unsigned int i = 1; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
                                 mesh->mNumUVComponents[i] = 0;
                             }
 
-                            group = static_cast<Texture2DGroup *>(it->second);
                             const std::string name = ai_to_string(group->mTexId);
                             for (size_t i = 0; i < mMaterials.size(); ++i) {
                                 if (name == mMaterials[i]->GetName().C_Str()) {
@@ -441,19 +494,42 @@ void XmlSerializer::ImportTriangles(XmlNode &node, aiMesh *mesh) {
                                 }
                             }
                             mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
+                            for (unsigned int vertex_index = 0; vertex_index < mesh->mNumVertices; vertex_index++) {
+                                mesh->mTextureCoords[0][vertex_index].z = IdNotSet;//mark not set
+                            }
                         }
-                    } 
-                }
-            }
 
-            // Load texture coordinates into mesh, when any
-            if (group != nullptr) {
-                size_t i0 = face.mIndices[0];
-                size_t i1 = face.mIndices[1];
-                size_t i2 = face.mIndices[2];
-                mesh->mTextureCoords[0][i0] = aiVector3D(group->mTex2dCoords[texId[0]].x, group->mTex2dCoords[texId[0]].y, 0.0f);
-                mesh->mTextureCoords[0][i1] = aiVector3D(group->mTex2dCoords[texId[1]].x, group->mTex2dCoords[texId[1]].y, 0.0f);
-                mesh->mTextureCoords[0][i2] = aiVector3D(group->mTex2dCoords[texId[2]].x, group->mTex2dCoords[texId[2]].y, 0.0f);
+                        auto update_texture = [&](int idx) {
+                            if (pindex[idx] != IdNotSet) {
+                                size_t vertex_index = face.mIndices[idx];
+                                mesh->mTextureCoords[0][vertex_index] =
+                                        aiVector3D(group->mTex2dCoords[pindex[idx]].x, group->mTex2dCoords[pindex[idx]].y, 0.0f);
+                            }
+                        };
+
+                        update_texture(0);
+                        update_texture(1);
+                        update_texture(2);
+
+                    } else if (it->second->getType() == ResourceType::RT_ColorGroup) {
+                        // Load vertex color into mesh, when any
+                        ColorGroup *group = static_cast<ColorGroup *>(it->second);
+                        if (mesh->mColors[0] == nullptr) {
+                            mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
+                        }
+
+                        auto update_color = [&](int idx) {
+                            if (pindex[idx] != IdNotSet) {
+                                size_t vertex_index = face.mIndices[idx];
+                                mesh->mColors[0][vertex_index] = group->mColors[pindex[idx]];
+                            }
+                        };
+
+                        update_color(0);
+                        update_color(1);
+                        update_color(2);
+                    }
+                }
             }
 
             faces.push_back(face);
@@ -582,7 +658,7 @@ aiMaterial *XmlSerializer::readMaterialDef(XmlNode &node, unsigned int basemater
     stdMaterialName += strId;
     stdMaterialName += "_";
     if (hasName) {
-        stdMaterialName += std::string(name);
+        stdMaterialName += name;
     } else {
         stdMaterialName += "basemat_";
         stdMaterialName += ai_to_string(mMaterials.size());
@@ -596,6 +672,38 @@ aiMaterial *XmlSerializer::readMaterialDef(XmlNode &node, unsigned int basemater
     return material;
 }
 
+void XmlSerializer::ReadColor(XmlNode &node, ColorGroup *colorGroup) {
+    if (node.empty() || nullptr == colorGroup) {
+        return;
+    }
+
+    for (XmlNode currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == XmlTag::color_item) {
+            const char *color = currentNode.attribute(XmlTag::color_value).as_string();
+            aiColor4D color_value;
+            if (parseColor(color, color_value)) {
+                colorGroup->mColors.push_back(color_value);
+            }
+        }
+    }
+}
+
+void XmlSerializer::ReadColorGroup(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    int id = IdNotSet;
+    if (!XmlParser::getIntAttribute(node, XmlTag::id, id)) {
+        return;
+    }
+
+    ColorGroup *group = new ColorGroup(id);
+    ReadColor(node, group);
+    mResourcesDictionnary.insert(std::make_pair(id, group));
+}
+
 void XmlSerializer::StoreMaterialsInScene(aiScene *scene) {
     if (nullptr == scene) {
         return;

code/AssetLib/3MF/XmlSerializer.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -57,10 +57,12 @@ class D3MFOpcPackage;
 class Object;
 class Texture2DGroup;
 class EmbeddedTexture;
+class ColorGroup;
 
-class XmlSerializer {
+/// @brief his class implements ther 3mf serialization.
+class XmlSerializer final {
 public:
-    XmlSerializer(XmlParser *xmlParser);
+    explicit XmlSerializer(XmlParser &xmlParser);
     ~XmlSerializer();
     void ImportXml(aiScene *scene);
 
@@ -78,6 +80,8 @@ private:
     void ReadTextureGroup(XmlNode &node);
     aiMaterial *readMaterialDef(XmlNode &node, unsigned int basematerialsId);
     void StoreMaterialsInScene(aiScene *scene);
+    void ReadColorGroup(XmlNode &node);
+    void ReadColor(XmlNode &node, ColorGroup *colorGroup);
 
 private:
     struct MetaEntry {
@@ -89,7 +93,7 @@ private:
     std::vector<aiMaterial *> mMaterials;
     std::map<unsigned int, Resource *> mResourcesDictionnary;
     unsigned int mMeshCount;
-    XmlParser *mXmlParser;
+    XmlParser &mXmlParser;
 };
 
 } // namespace D3MF

code/AssetLib/AC/ACLoader.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -60,9 +60,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/Importer.hpp>
 #include <memory>
 
-using namespace Assimp;
+namespace Assimp {
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "AC3D Importer",
     "",
     "",
@@ -75,10 +75,12 @@ static const aiImporterDesc desc = {
     "ac acc ac3d"
 };
 
+static constexpr auto ACDoubleSidedFlag = 0x20;
+
 // ------------------------------------------------------------------------------------------------
 // skip to the next token
-inline const char *AcSkipToNextToken(const char *buffer) {
-    if (!SkipSpaces(&buffer)) {
+inline const char *AcSkipToNextToken(const char *buffer, const char *end) {
+    if (!SkipSpaces(&buffer, end)) {
         ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL");
     }
     return buffer;
@@ -86,13 +88,13 @@ inline const char *AcSkipToNextToken(const char *buffer) {
 
 // ------------------------------------------------------------------------------------------------
 // read a string (may be enclosed in double quotation marks). buffer must point to "
-inline const char *AcGetString(const char *buffer, std::string &out) {
+inline const char *AcGetString(const char *buffer, const char *end, std::string &out) {
     if (*buffer == '\0') {
         throw DeadlyImportError("AC3D: Unexpected EOF in string");
     }
     ++buffer;
     const char *sz = buffer;
-    while ('\"' != *buffer) {
+    while ('\"' != *buffer && buffer != end) {
         if (IsLineEnd(*buffer)) {
             ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL in string");
             out = "ERROR";
@@ -112,8 +114,8 @@ inline const char *AcGetString(const char *buffer, std::string &out) {
 // ------------------------------------------------------------------------------------------------
 // read 1 to n floats prefixed with an optional predefined identifier
 template <class T>
-inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *name, size_t name_length, size_t num, T *out) {
-    buffer = AcSkipToNextToken(buffer);
+inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *end, const char *name, size_t name_length, size_t num, T *out) {
+    buffer = AcSkipToNextToken(buffer, end);
     if (0 != name_length) {
         if (0 != strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) {
             ASSIMP_LOG_ERROR("AC3D: Unexpected token. ", name, " was expected.");
@@ -122,17 +124,41 @@ inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *name
         buffer += name_length + 1;
     }
     for (unsigned int _i = 0; _i < num; ++_i) {
-        buffer = AcSkipToNextToken(buffer);
-        buffer = fast_atoreal_move<float>(buffer, ((float *)out)[_i]);
+        buffer = AcSkipToNextToken(buffer, end);
+        buffer = fast_atoreal_move(buffer, ((float *)out)[_i]);
     }
 
     return buffer;
 }
 
+// ------------------------------------------------------------------------------------------------
+// Reverses vertex indices in a face.
+static void flipWindingOrder(aiFace &f) {
+    std::reverse(f.mIndices, f.mIndices + f.mNumIndices);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Duplicates a face and inverts it. Also duplicates all vertices (so the new face gets its own
+// set of normals and isn’t smoothed against the original).
+static void buildBacksideOfFace(const aiFace &origFace, aiFace *&outFaces, aiVector3D *&outVertices, const aiVector3D *allVertices,
+    aiVector3D *&outUV, const aiVector3D *allUV, unsigned &curIdx) {
+    auto &newFace = *outFaces++;
+    newFace = origFace;
+    flipWindingOrder(newFace);
+    for (unsigned f = 0; f < newFace.mNumIndices; ++f) {
+        *outVertices++ = allVertices[newFace.mIndices[f]];
+        if (outUV) {
+            *outUV = allUV[newFace.mIndices[f]];
+            outUV++;
+        }
+        newFace.mIndices[f] = curIdx++;
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 AC3DImporter::AC3DImporter() :
-        buffer(),
+        mBuffer(),
         configSplitBFCull(),
         configEvalSubdivision(),
         mNumMeshes(),
@@ -144,14 +170,10 @@ AC3DImporter::AC3DImporter() :
     // nothing to be done here
 }
 
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-AC3DImporter::~AC3DImporter() = default;
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool AC3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    static const uint32_t tokens[] = { AI_MAKE_MAGIC("AC3D") };
+    static constexpr uint32_t tokens[] = { AI_MAKE_MAGIC("AC3D") };
     return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
@@ -164,17 +186,18 @@ const aiImporterDesc *AC3DImporter::GetInfo() const {
 // ------------------------------------------------------------------------------------------------
 // Get a pointer to the next line from the file
 bool AC3DImporter::GetNextLine() {
-    SkipLine(&buffer);
-    return SkipSpaces(&buffer);
+    SkipLine(&mBuffer.data, mBuffer.end);
+    return SkipSpaces(&mBuffer.data, mBuffer.end);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Parse an object section in an AC file
-void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
-    if (!TokenMatch(buffer, "OBJECT", 6))
-        return;
+bool AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
+    if (!TokenMatch(mBuffer.data, "OBJECT", 6)) {
+        return false;
+    }
 
-    SkipSpaces(&buffer);
+    SkipSpaces(&mBuffer.data, mBuffer.end);
 
     ++mNumMeshes;
 
@@ -182,7 +205,7 @@ void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
     Object &obj = objects.back();
 
     aiLight *light = nullptr;
-    if (!ASSIMP_strincmp(buffer, "light", 5)) {
+    if (!ASSIMP_strincmp(mBuffer.data, "light", 5)) {
         // This is a light source. Add it to the list
         mLights->push_back(light = new aiLight());
 
@@ -192,66 +215,73 @@ void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
         light->mAttenuationConstant = 1.f;
 
         // Generate a default name for both the light source and the node
-        // FIXME - what's the right way to print a size_t? Is 'zu' universally available? stick with the safe version.
-        light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i", static_cast<unsigned int>(mLights->size()) - 1);
+        light->mName.length = ::ai_snprintf(light->mName.data, AI_MAXLEN, "ACLight_%i", static_cast<unsigned int>(mLights->size()) - 1);
         obj.name = std::string(light->mName.data);
 
         ASSIMP_LOG_VERBOSE_DEBUG("AC3D: Light source encountered");
         obj.type = Object::Light;
-    } else if (!ASSIMP_strincmp(buffer, "group", 5)) {
+    } else if (!ASSIMP_strincmp(mBuffer.data, "group", 5)) {
         obj.type = Object::Group;
-    } else if (!ASSIMP_strincmp(buffer, "world", 5)) {
+    } else if (!ASSIMP_strincmp(mBuffer.data, "world", 5)) {
         obj.type = Object::World;
-    } else
+    } else {
         obj.type = Object::Poly;
+    }
+
     while (GetNextLine()) {
-        if (TokenMatch(buffer, "kids", 4)) {
-            SkipSpaces(&buffer);
-            unsigned int num = strtoul10(buffer, &buffer);
+        if (TokenMatch(mBuffer.data, "kids", 4)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            unsigned int num = strtoul10(mBuffer.data, &mBuffer.data);
             GetNextLine();
             if (num) {
                 // load the children of this object recursively
                 obj.children.reserve(num);
-                for (unsigned int i = 0; i < num; ++i)
-                    LoadObjectSection(obj.children);
+                for (unsigned int i = 0; i < num; ++i) {
+                    if (!LoadObjectSection(obj.children)) {
+                        ASSIMP_LOG_WARN("AC3D: wrong number of kids");
+                        break;
+                    }
+                }
             }
-            return;
-        } else if (TokenMatch(buffer, "name", 4)) {
-            SkipSpaces(&buffer);
-            buffer = AcGetString(buffer, obj.name);
+            return true;
+        } else if (TokenMatch(mBuffer.data, "name", 4)) {
+            SkipSpaces(&mBuffer.data, mBuffer.data);
+            mBuffer.data = AcGetString(mBuffer.data, mBuffer.end, obj.name);
 
             // If this is a light source, we'll also need to store
             // the name of the node in it.
             if (light) {
                 light->mName.Set(obj.name);
             }
-        } else if (TokenMatch(buffer, "texture", 7)) {
-            SkipSpaces(&buffer);
-            buffer = AcGetString(buffer, obj.texture);
-        } else if (TokenMatch(buffer, "texrep", 6)) {
-            SkipSpaces(&buffer);
-            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 2, &obj.texRepeat);
+        } else if (TokenMatch(mBuffer.data, "texture", 7)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            std::string texture;
+            mBuffer.data = AcGetString(mBuffer.data, mBuffer.end, texture);
+            obj.textures.push_back(texture);
+        } else if (TokenMatch(mBuffer.data, "texrep", 6)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 2, &obj.texRepeat);
             if (!obj.texRepeat.x || !obj.texRepeat.y)
                 obj.texRepeat = aiVector2D(1.f, 1.f);
-        } else if (TokenMatch(buffer, "texoff", 6)) {
-            SkipSpaces(&buffer);
-            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 2, &obj.texOffset);
-        } else if (TokenMatch(buffer, "rot", 3)) {
-            SkipSpaces(&buffer);
-            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 9, &obj.rotation);
-        } else if (TokenMatch(buffer, "loc", 3)) {
-            SkipSpaces(&buffer);
-            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 3, &obj.translation);
-        } else if (TokenMatch(buffer, "subdiv", 6)) {
-            SkipSpaces(&buffer);
-            obj.subDiv = strtoul10(buffer, &buffer);
-        } else if (TokenMatch(buffer, "crease", 6)) {
-            SkipSpaces(&buffer);
-            obj.crease = fast_atof(buffer);
-        } else if (TokenMatch(buffer, "numvert", 7)) {
-            SkipSpaces(&buffer);
+        } else if (TokenMatch(mBuffer.data, "texoff", 6)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 2, &obj.texOffset);
+        } else if (TokenMatch(mBuffer.data, "rot", 3)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 9, &obj.rotation);
+        } else if (TokenMatch(mBuffer.data, "loc", 3)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 3, &obj.translation);
+        } else if (TokenMatch(mBuffer.data, "subdiv", 6)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            obj.subDiv = strtoul10(mBuffer.data, &mBuffer.data);
+        } else if (TokenMatch(mBuffer.data, "crease", 6)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
+            obj.crease = fast_atof(mBuffer.data);
+        } else if (TokenMatch(mBuffer.data, "numvert", 7)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
 
-            unsigned int t = strtoul10(buffer, &buffer);
+            unsigned int t = strtoul10(mBuffer.data, &mBuffer.data);
             if (t >= AI_MAX_ALLOC(aiVector3D)) {
                 throw DeadlyImportError("AC3D: Too many vertices, would run out of memory");
             }
@@ -260,59 +290,59 @@ void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
                 if (!GetNextLine()) {
                     ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: not all vertices have been parsed yet");
                     break;
-                } else if (!IsNumeric(*buffer)) {
+                } else if (!IsNumeric(*mBuffer.data)) {
                     ASSIMP_LOG_ERROR("AC3D: Unexpected token: not all vertices have been parsed yet");
-                    --buffer; // make sure the line is processed a second time
+                    --mBuffer.data; // make sure the line is processed a second time
                     break;
                 }
                 obj.vertices.emplace_back();
                 aiVector3D &v = obj.vertices.back();
-                buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 3, &v.x);
+                mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 3, &v.x);
             }
-        } else if (TokenMatch(buffer, "numsurf", 7)) {
-            SkipSpaces(&buffer);
+        } else if (TokenMatch(mBuffer.data, "numsurf", 7)) {
+            SkipSpaces(&mBuffer.data, mBuffer.end);
 
             bool Q3DWorkAround = false;
 
-            const unsigned int t = strtoul10(buffer, &buffer);
+            const unsigned int t = strtoul10(mBuffer.data, &mBuffer.data);
             obj.surfaces.reserve(t);
             for (unsigned int i = 0; i < t; ++i) {
                 GetNextLine();
-                if (!TokenMatch(buffer, "SURF", 4)) {
+                if (!TokenMatch(mBuffer.data, "SURF", 4)) {
                     // FIX: this can occur for some files - Quick 3D for
                     // example writes no surf chunks
                     if (!Q3DWorkAround) {
                         ASSIMP_LOG_WARN("AC3D: SURF token was expected");
                         ASSIMP_LOG_VERBOSE_DEBUG("Continuing with Quick3D Workaround enabled");
                     }
-                    --buffer; // make sure the line is processed a second time
+                    --mBuffer.data; // make sure the line is processed a second time
                     // break; --- see fix notes above
 
                     Q3DWorkAround = true;
                 }
-                SkipSpaces(&buffer);
+                SkipSpaces(&mBuffer.data, mBuffer.end);
                 obj.surfaces.emplace_back();
                 Surface &surf = obj.surfaces.back();
-                surf.flags = strtoul_cppstyle(buffer);
+                surf.flags = strtoul_cppstyle(mBuffer.data);
 
-                while (1) {
+                while (true) {
                     if (!GetNextLine()) {
                         throw DeadlyImportError("AC3D: Unexpected EOF: surface is incomplete");
                     }
-                    if (TokenMatch(buffer, "mat", 3)) {
-                        SkipSpaces(&buffer);
-                        surf.mat = strtoul10(buffer);
-                    } else if (TokenMatch(buffer, "refs", 4)) {
+                    if (TokenMatch(mBuffer.data, "mat", 3)) {
+                        SkipSpaces(&mBuffer.data, mBuffer.end);
+                        surf.mat = strtoul10(mBuffer.data);
+                    } else if (TokenMatch(mBuffer.data, "refs", 4)) {
                         // --- see fix notes above
                         if (Q3DWorkAround) {
                             if (!surf.entries.empty()) {
-                                buffer -= 6;
+                                mBuffer.data -= 6;
                                 break;
                             }
                         }
 
-                        SkipSpaces(&buffer);
-                        const unsigned int m = strtoul10(buffer);
+                        SkipSpaces(&mBuffer.data, mBuffer.end);
+                        const unsigned int m = strtoul10(mBuffer.data);
                         surf.entries.reserve(m);
 
                         obj.numRefs += m;
@@ -325,12 +355,12 @@ void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
                             surf.entries.emplace_back();
                             Surface::SurfaceEntry &entry = surf.entries.back();
 
-                            entry.first = strtoul10(buffer, &buffer);
-                            SkipSpaces(&buffer);
-                            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 2, &entry.second);
+                            entry.first = strtoul10(mBuffer.data, &mBuffer.data);
+                            SkipSpaces(&mBuffer.data, mBuffer.end);
+                            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 2, &entry.second);
                         }
                     } else {
-                        --buffer; // make sure the line is processed a second time
+                        --mBuffer.data; // make sure the line is processed a second time
                         break;
                     }
                 }
@@ -338,6 +368,8 @@ void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
         }
     }
     ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: \'kids\' line was expected");
+
+    return false;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -351,8 +383,8 @@ void AC3DImporter::ConvertMaterial(const Object &object,
         s.Set(matSrc.name);
         matDest.AddProperty(&s, AI_MATKEY_NAME);
     }
-    if (object.texture.length()) {
-        s.Set(object.texture);
+    if (!object.textures.empty()) {
+        s.Set(object.textures[0]);
         matDest.AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
         // UV transformation
@@ -443,8 +475,10 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                     idx = 0;
                 }
                 if ((*it).entries.empty()) {
-                    ASSIMP_LOG_WARN("AC3D: surface her zero vertex references");
+                    ASSIMP_LOG_WARN("AC3D: surface has zero vertex references");
                 }
+                const bool isDoubleSided = ACDoubleSidedFlag == (it->flags & ACDoubleSidedFlag);
+                const int doubleSidedFactor = isDoubleSided ? 2 : 1;
 
                 // validate all vertex indices to make sure we won't crash here
                 for (it2 = (*it).entries.begin(),
@@ -461,22 +495,21 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                 }
 
                 switch ((*it).GetType()) {
-                    // closed line
-                case Surface::ClosedLine:
-                    needMat[idx].first += (unsigned int)(*it).entries.size();
-                    needMat[idx].second += (unsigned int)(*it).entries.size() << 1u;
+                case Surface::ClosedLine: // closed line
+                    needMat[idx].first += static_cast<unsigned int>((*it).entries.size());
+                    needMat[idx].second += static_cast<unsigned int>((*it).entries.size() << 1u);
                     break;
 
                     // unclosed line
                 case Surface::OpenLine:
-                    needMat[idx].first += (unsigned int)(*it).entries.size() - 1;
-                    needMat[idx].second += ((unsigned int)(*it).entries.size() - 1) << 1u;
+                    needMat[idx].first += static_cast<unsigned int>((*it).entries.size() - 1);
+                    needMat[idx].second += static_cast<unsigned int>(((*it).entries.size() - 1) << 1u);
                     break;
 
                     // triangle strip
                 case Surface::TriangleStrip:
-                    needMat[idx].first += (unsigned int)(*it).entries.size() - 2;
-                    needMat[idx].second += ((unsigned int)(*it).entries.size() - 2) * 3;
+                    needMat[idx].first += static_cast<unsigned int>(it->entries.size() - 2) * doubleSidedFactor;
+                    needMat[idx].second += static_cast<unsigned int>(it->entries.size() - 2) * 3 * doubleSidedFactor;
                     break;
 
                 default:
@@ -489,8 +522,8 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                 case Surface::Polygon:
                     // the number of faces increments by one, the number
                     // of vertices by surface.numref.
-                    needMat[idx].first++;
-                    needMat[idx].second += (unsigned int)(*it).entries.size();
+                    needMat[idx].first += doubleSidedFactor;
+                    needMat[idx].second += static_cast<unsigned int>(it->entries.size()) * doubleSidedFactor;
                 };
             }
             unsigned int *pip = node->mMeshes = new unsigned int[node->mNumMeshes];
@@ -532,7 +565,7 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                 // allocate UV coordinates, but only if the texture name for the
                 // surface is not empty
                 aiVector3D *uv = nullptr;
-                if (object.texture.length()) {
+                if (!object.textures.empty()) {
                     uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
                     mesh->mNumUVComponents[0] = 2;
                 }
@@ -540,6 +573,7 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                 for (it = object.surfaces.begin(); it != end; ++it) {
                     if (mat == (*it).mat) {
                         const Surface &src = *it;
+                        const bool isDoubleSided = ACDoubleSidedFlag == (src.flags & ACDoubleSidedFlag);
 
                         // closed polygon
                         uint8_t type = (*it).GetType();
@@ -565,6 +599,8 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                                         ++uv;
                                     }
                                 }
+                                if(isDoubleSided) // Need a backface?
+                                    buildBacksideOfFace(faces[-1], faces, vertices, mesh->mVertices, uv, mesh->mTextureCoords[0], cur);
                             }
                         } else if (type == Surface::TriangleStrip) {
                             for (unsigned int i = 0; i < (unsigned int)src.entries.size() - 2; ++i) {
@@ -572,15 +608,6 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                                 const Surface::SurfaceEntry &entry2 = src.entries[i + 1];
                                 const Surface::SurfaceEntry &entry3 = src.entries[i + 2];
 
-                                // skip degenerate triangles
-                                if (object.vertices[entry1.first] == object.vertices[entry2.first] ||
-                                        object.vertices[entry1.first] == object.vertices[entry3.first] ||
-                                        object.vertices[entry2.first] == object.vertices[entry3.first]) {
-                                    mesh->mNumFaces--;
-                                    mesh->mNumVertices -= 3;
-                                    continue;
-                                }
-
                                 aiFace &face = *faces++;
                                 face.mNumIndices = 3;
                                 face.mIndices = new unsigned int[face.mNumIndices];
@@ -623,6 +650,8 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                                     uv->y = entry3.second.y;
                                     ++uv;
                                 }
+                                if(isDoubleSided) // Need a backface?
+                                    buildBacksideOfFace(faces[-1], faces, vertices, mesh->mVertices, uv, mesh->mTextureCoords[0], cur);
                             }
                         } else {
 
@@ -699,18 +728,18 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
         // generate a name depending on the type of the node
         switch (object.type) {
         case Object::Group:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i", mGroupsCounter++);
+            node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACGroup_%i", mGroupsCounter++);
             break;
         case Object::Poly:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i", mPolysCounter++);
+            node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACPoly_%i", mPolysCounter++);
             break;
         case Object::Light:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i", mLightsCounter++);
+            node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACLight_%i", mLightsCounter++);
             break;
 
             // there shouldn't be more than one world, but we don't care
         case Object::World:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i", mWorldsCounter++);
+            node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACWorld_%i", mWorldsCounter++);
             break;
         }
     }
@@ -750,7 +779,7 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if (file.get() == nullptr) {
+    if (file == nullptr) {
         throw DeadlyImportError("Failed to open AC3D file ", pFile, ".");
     }
 
@@ -758,17 +787,18 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
     std::vector<char> mBuffer2;
     TextFileToBuffer(file.get(), mBuffer2);
 
-    buffer = &mBuffer2[0];
+    mBuffer.data = &mBuffer2[0];
+    mBuffer.end = &mBuffer2[0] + mBuffer2.size();
     mNumMeshes = 0;
 
     mLightsCounter = mPolysCounter = mWorldsCounter = mGroupsCounter = 0;
 
-    if (::strncmp(buffer, "AC3D", 4)) {
+    if (::strncmp(mBuffer.data, "AC3D", 4)) {
         throw DeadlyImportError("AC3D: No valid AC3D file, magic sequence not found");
     }
 
     // print the file format version to the console
-    unsigned int version = HexDigitToDecimal(buffer[4]);
+    unsigned int version = HexDigitToDecimal(mBuffer.data[4]);
     char msg[3];
     ASSIMP_itoa10(msg, 3, version);
     ASSIMP_LOG_INFO("AC3D file format version: ", msg);
@@ -783,30 +813,31 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
     mLights = &lights;
 
     while (GetNextLine()) {
-        if (TokenMatch(buffer, "MATERIAL", 8)) {
+        if (TokenMatch(mBuffer.data, "MATERIAL", 8)) {
             materials.emplace_back();
             Material &mat = materials.back();
 
             // manually parse the material ... sscanf would use the buldin atof ...
             // Format: (name) rgb %f %f %f  amb %f %f %f  emis %f %f %f  spec %f %f %f  shi %d  trans %f
 
-            buffer = AcSkipToNextToken(buffer);
-            if ('\"' == *buffer) {
-                buffer = AcGetString(buffer, mat.name);
-                buffer = AcSkipToNextToken(buffer);
+            mBuffer.data = AcSkipToNextToken(mBuffer.data, mBuffer.end);
+            if ('\"' == *mBuffer.data) {
+                mBuffer.data = AcGetString(mBuffer.data, mBuffer.end, mat.name);
+                mBuffer.data = AcSkipToNextToken(mBuffer.data, mBuffer.end);
             }
 
-            buffer = TAcCheckedLoadFloatArray(buffer, "rgb", 3, 3, &mat.rgb);
-            buffer = TAcCheckedLoadFloatArray(buffer, "amb", 3, 3, &mat.amb);
-            buffer = TAcCheckedLoadFloatArray(buffer, "emis", 4, 3, &mat.emis);
-            buffer = TAcCheckedLoadFloatArray(buffer, "spec", 4, 3, &mat.spec);
-            buffer = TAcCheckedLoadFloatArray(buffer, "shi", 3, 1, &mat.shin);
-            buffer = TAcCheckedLoadFloatArray(buffer, "trans", 5, 1, &mat.trans);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "rgb", 3, 3, &mat.rgb);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "amb", 3, 3, &mat.amb);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "emis", 4, 3, &mat.emis);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "spec", 4, 3, &mat.spec);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "shi", 3, 1, &mat.shin);
+            mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "trans", 5, 1, &mat.trans);
+        } else {
+            LoadObjectSection(rootObjects);
         }
-        LoadObjectSection(rootObjects);
     }
 
-    if (rootObjects.empty() || !mNumMeshes) {
+    if (rootObjects.empty() || mNumMeshes == 0u) {
         throw DeadlyImportError("AC3D: No meshes have been loaded");
     }
     if (materials.empty()) {
@@ -822,7 +853,7 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
     materials.reserve(mNumMeshes);
 
     // generate a dummy root if there are multiple objects on the top layer
-    Object *root;
+    Object *root = nullptr;
     if (1 == rootObjects.size())
         root = &rootObjects[0];
     else {
@@ -835,7 +866,7 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
         delete root;
     }
 
-    if (!::strncmp(pScene->mRootNode->mName.data, "Node", 4)) {
+    if (::strncmp(pScene->mRootNode->mName.data, "Node", 4) == 0) {
         pScene->mRootNode->mName.Set("<AC3DWorld>");
     }
 
@@ -854,10 +885,12 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
 
     // copy lights
     pScene->mNumLights = (unsigned int)lights.size();
-    if (lights.size()) {
+    if (!lights.empty()) {
         pScene->mLights = new aiLight *[lights.size()];
         ::memcpy(pScene->mLights, &lights[0], lights.size() * sizeof(void *));
     }
 }
 
+} // namespace Assimp
+
 #endif //!defined ASSIMP_BUILD_NO_AC_IMPORTER

code/AssetLib/AC/ACLoader.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -60,10 +60,10 @@ namespace Assimp {
 // ---------------------------------------------------------------------------
 /** AC3D (*.ac) importer class
 */
-class AC3DImporter : public BaseImporter {
+class AC3DImporter final : public BaseImporter {
 public:
     AC3DImporter();
-    ~AC3DImporter() override;
+    ~AC3DImporter() override = default;
 
     // Represents an AC3D material
     struct Material {
@@ -103,7 +103,7 @@ public:
 
         unsigned int mat, flags;
 
-        typedef std::pair<unsigned int, aiVector2D> SurfaceEntry;
+        using SurfaceEntry = std::pair<unsigned int, aiVector2D>;
         std::vector<SurfaceEntry> entries;
 
         // Type is low nibble of flags
@@ -125,7 +125,6 @@ public:
                 type(World),
                 name(),
                 children(),
-                texture(),
                 texRepeat(1.f, 1.f),
                 texOffset(0.0f, 0.0f),
                 rotation(),
@@ -151,7 +150,8 @@ public:
         std::vector<Object> children;
 
         // texture to be assigned to all surfaces of the object
-        std::string texture;
+        // the .acc format supports up to 4 textures
+        std::vector<std::string> textures;
 
         // texture repat factors (scaling for all coordinates)
         aiVector2D texRepeat, texOffset;
@@ -216,7 +216,7 @@ private:
      *  load subobjects, the method returns after a 'kids 0' was
      *  encountered.
      *  @objects List of output objects*/
-    void LoadObjectSection(std::vector<Object> &objects);
+    bool LoadObjectSection(std::vector<Object> &objects);
 
     // -------------------------------------------------------------------
     /** Convert all objects into meshes and nodes.
@@ -242,7 +242,7 @@ private:
 
 private:
     // points to the next data line
-    const char *buffer;
+    aiBuffer mBuffer;
 
     // Configuration option: if enabled, up to two meshes
     // are generated per material: those faces who have

code/AssetLib/AMF/AMFImporter.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp {
 
-const aiImporterDesc AMFImporter::Description = {
+static constexpr aiImporterDesc Description = {
     "Additive manufacturing file format(AMF) Importer",
     "smalcom",
     "",
@@ -83,11 +83,7 @@ void AMFImporter::Clear() {
 
 AMFImporter::AMFImporter() AI_NO_EXCEPT :
         mNodeElement_Cur(nullptr),
-        mXmlParser(nullptr),
-        mUnit(),
-        mVersion(),
-        mMaterial_Converted(),
-        mTexture_Converted() {
+        mXmlParser(nullptr) {
     // empty
 }
 
@@ -182,28 +178,6 @@ bool AMFImporter::XML_SearchNode(const std::string &nodeName) {
     return nullptr != mXmlParser->findNode(nodeName);
 }
 
-void AMFImporter::ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString) {
-    size_t instr_len;
-
-    pOutString.clear();
-    instr_len = strlen(pInStr);
-    if (!instr_len) return;
-
-    pOutString.reserve(instr_len * 3 / 2);
-    // check and correct floats in format ".x". Must be "x.y".
-    if (pInStr[0] == '.') pOutString.push_back('0');
-
-    pOutString.push_back(pInStr[0]);
-    for (size_t ci = 1; ci < instr_len; ci++) {
-        if ((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t'))) {
-            pOutString.push_back('0');
-            pOutString.push_back('.');
-        } else {
-            pOutString.push_back(pInStr[ci]);
-        }
-    }
-}
-
 static bool ParseHelper_Decode_Base64_IsBase64(const char pChar) {
     return (isalnum((unsigned char)pChar) || (pChar == '+') || (pChar == '/'));
 }
@@ -217,7 +191,10 @@ void AMFImporter::ParseHelper_Decode_Base64(const std::string &pInputBase64, std
     uint8_t arr4[4], arr3[3];
 
     // check input data
-    if (pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
+    if (pInputBase64.size() % 4) {
+        throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
+    }
+
     // prepare output place
     pOutputData.clear();
     pOutputData.reserve(pInputBase64.size() / 4 * 3);
@@ -261,7 +238,7 @@ void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) {
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if (file.get() == nullptr) {
+    if (file == nullptr) {
         throw DeadlyImportError("Failed to open AMF file ", pFile, ".");
     }
 
@@ -350,8 +327,7 @@ void AMFImporter::ParseNode_Root() {
 // Multi elements - Yes.
 // Parent element - <amf>.
 void AMFImporter::ParseNode_Constellation(XmlNode &node) {
-    std::string id;
-    id = node.attribute("id").as_string();
+    std::string id = node.attribute("id").as_string();
 
     // create and if needed - define new grouping object.
     AMFNodeElementBase *ne = new AMFConstellation(mNodeElement_Cur);
@@ -407,17 +383,17 @@ void AMFImporter::ParseNode_Instance(XmlNode &node) {
         for (auto &currentNode : node.children()) {
             const std::string &currentName = currentNode.name();
             if (currentName == "deltax") {
-                XmlParser::getValueAsFloat(currentNode, als.Delta.x);
+                XmlParser::getValueAsReal(currentNode, als.Delta.x);
             } else if (currentName == "deltay") {
-                XmlParser::getValueAsFloat(currentNode, als.Delta.y);
+                XmlParser::getValueAsReal(currentNode, als.Delta.y);
             } else if (currentName == "deltaz") {
-                XmlParser::getValueAsFloat(currentNode, als.Delta.z);
+                XmlParser::getValueAsReal(currentNode, als.Delta.z);
             } else if (currentName == "rx") {
-                XmlParser::getValueAsFloat(currentNode, als.Delta.x);
+                XmlParser::getValueAsReal(currentNode, als.Delta.x);
             } else if (currentName == "ry") {
-                XmlParser::getValueAsFloat(currentNode, als.Delta.y);
+                XmlParser::getValueAsReal(currentNode, als.Delta.y);
             } else if (currentName == "rz") {
-                XmlParser::getValueAsFloat(currentNode, als.Delta.z);
+                XmlParser::getValueAsReal(currentNode, als.Delta.z);
             }
         }
         ParseHelper_Node_Exit();
@@ -497,7 +473,7 @@ void AMFImporter::ParseNode_Metadata(XmlNode &node) {
 
     // read attribute
     ne = new AMFMetadata(mNodeElement_Cur);
-    ((AMFMetadata *)ne)->Type = type;
+    ((AMFMetadata *)ne)->MetaType = type;
     ((AMFMetadata *)ne)->Value = value;
     mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
     mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.

code/AssetLib/AMF/AMFImporter.hpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -97,9 +97,13 @@ namespace Assimp {
 ///            new - <texmap> and children <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>
 ///            old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
 ///
-class AMFImporter : public BaseImporter {
-private:
-    struct SPP_Material; // forward declaration
+class AMFImporter final : public BaseImporter {
+    using AMFMetaDataArray = std::vector<AMFMetadata *>;
+    using MeshArray = std::vector<aiMesh *>;
+    using NodeArray = std::vector<aiNode *>;
+
+public:
+    struct SPP_Material;
 
     /// Data type for post-processing step. More suitable container for part of material's composition.
     struct SPP_Composite {
@@ -107,22 +111,6 @@ private:
         std::string Formula; ///< Formula for calculating ratio of \ref Material.
     };
 
-    /// \struct SPP_Material
-    /// Data type for post-processing step. More suitable container for material.
-    struct SPP_Material {
-        std::string ID; ///< Material ID.
-        std::list<AMFMetadata *> Metadata; ///< Metadata of material.
-        AMFColor *Color; ///< Color of material.
-        std::list<SPP_Composite> Composition; ///< List of child materials if current material is composition of few another.
-
-        /// Return color calculated for specified coordinate.
-        /// \param [in] pX - "x" coordinate.
-        /// \param [in] pY - "y" coordinate.
-        /// \param [in] pZ - "z" coordinate.
-        /// \return calculated color.
-        aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
-    };
-
     /// Data type for post-processing step. More suitable container for texture.
     struct SPP_Texture {
         std::string ID;
@@ -139,10 +127,51 @@ private:
         const AMFTexMap *TexMap; ///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
     };
 
-    using AMFMetaDataArray = std::vector<AMFMetadata*>;
-    using MeshArray = std::vector<aiMesh*>;
-    using NodeArray = std::vector<aiNode*>;
+    /// Data type for post-processing step. More suitable container for material.
+    struct SPP_Material {
+        std::string ID; ///< Material ID.
+        std::list<AMFMetadata *> Metadata; ///< Metadata of material.
+        AMFColor *Color; ///< Color of material.
+        std::list<SPP_Composite> Composition; ///< List of child materials if current material is composition of few another.
 
+        /// Return color calculated for specified coordinate.
+        /// \param [in] pX - "x" coordinate.
+        /// \param [in] pY - "y" coordinate.
+        /// \param [in] pZ - "z" coordinate.
+        /// \return calculated color.
+        aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
+    };
+
+    /// Default constructor.
+    AMFImporter() AI_NO_EXCEPT;
+
+    /// Default destructor.
+    ~AMFImporter() override;
+
+    /// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
+    /// Also exception can be thrown if trouble will found.
+    /// \param [in] pFile - name of file to be parsed.
+    /// \param [in] pIOHandler - pointer to IO helper object.
+    void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
+    void ParseHelper_Node_Enter(AMFNodeElementBase *child);
+    void ParseHelper_Node_Exit();
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override;
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+    const aiImporterDesc *GetInfo() const override;
+    bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const;
+    bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const;
+    bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const;
+    AI_WONT_RETURN void Throw_CloseNotFound(const std::string &nodeName) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void Throw_ID_NotFound(const std::string &pID) const AI_WONT_RETURN_SUFFIX;
+    void XML_CheckNode_MustHaveChildren(pugi::xml_node &node);
+    bool XML_SearchNode(const std::string &nodeName);
+    AMFImporter(const AMFImporter &pScene) = delete;
+    AMFImporter &operator=(const AMFImporter &pScene) = delete;
+
+private:
     /// Clear all temporary data.
     void Clear();
 
@@ -262,40 +291,9 @@ private:
     /// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
     void ParseNode_TexMap(XmlNode &node, const bool pUseOldName = false);
 
-public:
-    /// Default constructor.
-    AMFImporter() AI_NO_EXCEPT;
 
-    /// Default destructor.
-    ~AMFImporter() override;
-
-    /// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
-    /// Also exception can be thrown if trouble will found.
-    /// \param [in] pFile - name of file to be parsed.
-    /// \param [in] pIOHandler - pointer to IO helper object.
-    void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
-    void ParseHelper_Node_Enter(AMFNodeElementBase *child);
-    void ParseHelper_Node_Exit();
-    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override;
-    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
-    const aiImporterDesc *GetInfo() const override;
-    bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const;
-    bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const;
-    bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const;
-    void Throw_CloseNotFound(const std::string &nodeName);
-    void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName);
-    void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName);
-    void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription);
-    void Throw_ID_NotFound(const std::string &pID) const;
-    void XML_CheckNode_MustHaveChildren(pugi::xml_node &node);
-    bool XML_SearchNode(const std::string &nodeName);
-    void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString);
-    AMFImporter(const AMFImporter &pScene) = delete;
-    AMFImporter &operator=(const AMFImporter &pScene) = delete;
 
 private:
-    static const aiImporterDesc Description;
-
     AMFNodeElementBase *mNodeElement_Cur; ///< Current element.
     std::list<AMFNodeElementBase *> mNodeElement_List; ///< All elements of scene graph.
     XmlParser *mXmlParser;

code/AssetLib/AMF/AMFImporter_Geometry.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -167,11 +167,11 @@ void AMFImporter::ParseNode_Coordinates(XmlNode &node) {
             AMFCoordinates &als = *((AMFCoordinates *)ne); // alias for convenience
             const std::string &currentName = ai_tolower(currentNode.name());
             if (currentName == "x") {
-                XmlParser::getValueAsFloat(currentNode, als.Coordinate.x);
+                XmlParser::getValueAsReal(currentNode, als.Coordinate.x);
             } else if (currentName == "y") {
-                XmlParser::getValueAsFloat(currentNode, als.Coordinate.y);
+                XmlParser::getValueAsReal(currentNode, als.Coordinate.y);
             } else if (currentName == "z") {
-                XmlParser::getValueAsFloat(currentNode, als.Coordinate.z);
+                XmlParser::getValueAsReal(currentNode, als.Coordinate.z);
             }
         }
         ParseHelper_Node_Exit();
@@ -202,7 +202,7 @@ void AMFImporter::ParseNode_Volume(XmlNode &node) {
 
     ((AMFVolume *)ne)->MaterialID = node.attribute("materialid").as_string();
 
-    ((AMFVolume *)ne)->Type = type;
+    ((AMFVolume *)ne)->VolumeType = type;
     // Check for child nodes
     bool col_read = false;
     if (!node.empty()) {

code/AssetLib/AMF/AMFImporter_Material.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -263,26 +263,25 @@ void AMFImporter::ParseNode_TexMap(XmlNode &node, const bool pUseOldName) {
             const std::string &name = currentNode.name();
             if (name == "utex1") {
 				read_flag[0] = true;
-                XmlParser::getValueAsFloat(node, als.TextureCoordinate[0].x);
+                XmlParser::getValueAsReal(currentNode, als.TextureCoordinate[0].x);
             } else if (name == "utex2") {
 				read_flag[1] = true;
-                XmlParser::getValueAsFloat(node, als.TextureCoordinate[1].x);
+                XmlParser::getValueAsReal(currentNode, als.TextureCoordinate[1].x);
             } else if (name == "utex3") {
 				read_flag[2] = true;
-                XmlParser::getValueAsFloat(node, als.TextureCoordinate[2].x);
+                XmlParser::getValueAsReal(currentNode, als.TextureCoordinate[2].x);
             } else if (name == "vtex1") {
 				read_flag[3] = true;
-                XmlParser::getValueAsFloat(node, als.TextureCoordinate[0].y);
+                XmlParser::getValueAsReal(currentNode, als.TextureCoordinate[0].y);
             } else if (name == "vtex2") {
 				read_flag[4] = true;
-                XmlParser::getValueAsFloat(node, als.TextureCoordinate[1].y);
+                XmlParser::getValueAsReal(currentNode, als.TextureCoordinate[1].y);
             } else if (name == "vtex3") {
 				read_flag[5] = true;
-                XmlParser::getValueAsFloat(node, als.TextureCoordinate[2].y);
+                XmlParser::getValueAsReal(currentNode, als.TextureCoordinate[2].y);
 			}
 		}
         ParseHelper_Node_Exit();
-
 	} else {
 		for (pugi::xml_attribute &attr : node.attributes()) {
             const std::string name = attr.name();

code/AssetLib/AMF/AMFImporter_Node.hpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -56,7 +56,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <vector>
 
-/// \class CAMFImporter_NodeElement
 /// Base class for elements of nodes.
 class AMFNodeElementBase {
 public:
@@ -87,10 +86,9 @@ public:
 	AMFNodeElementBase *Parent; ///< Parent element. If nullptr then this node is root.
 	std::list<AMFNodeElementBase *> Child; ///< Child elements.
 
-public: /// Destructor, virtual..
-	virtual ~AMFNodeElementBase() {
-		// empty
-	}
+public:
+	/// Destructor, virtual..
+	virtual ~AMFNodeElementBase() = default;
 
 	/// Disabled copy constructor and co.
 	AMFNodeElementBase(const AMFNodeElementBase &pNodeElement) = delete;
@@ -100,27 +98,25 @@ public: /// Destructor, virtual..
 
 protected:
 	/// In constructor inheritor must set element type.
-	/// \param [in] pType - element type.
+	/// \param [in] type - element type.
 	/// \param [in] pParent - parent element.
-	AMFNodeElementBase(const EType pType, AMFNodeElementBase *pParent) :
-			Type(pType), ID(), Parent(pParent), Child() {
+	AMFNodeElementBase(EType type, AMFNodeElementBase *pParent) :
+			Type(type), Parent(pParent) {
 		// empty
 	}
 }; // class IAMFImporter_NodeElement
 
-/// \struct CAMFImporter_NodeElement_Constellation
 /// A collection of objects or constellations with specific relative locations.
-struct AMFConstellation : public AMFNodeElementBase {
+struct AMFConstellation final : public AMFNodeElementBase {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFConstellation(AMFNodeElementBase *pParent) :
+	explicit AMFConstellation(AMFNodeElementBase *pParent) :
 			AMFNodeElementBase(ENET_Constellation, pParent) {}
 
 }; // struct CAMFImporter_NodeElement_Constellation
 
-/// \struct CAMFImporter_NodeElement_Instance
 /// Part of constellation.
-struct AMFInstance : public AMFNodeElementBase {
+struct AMFInstance final : public AMFNodeElementBase {
 
 	std::string ObjectID; ///< ID of object for instantiation.
 	/// \var Delta - The distance of translation in the x, y, or z direction, respectively, in the referenced object's coordinate system, to
@@ -133,24 +129,24 @@ struct AMFInstance : public AMFNodeElementBase {
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFInstance(AMFNodeElementBase *pParent) :
+	explicit AMFInstance(AMFNodeElementBase *pParent) :
 			AMFNodeElementBase(ENET_Instance, pParent) {}
 };
 
-/// \struct CAMFImporter_NodeElement_Metadata
 /// Structure that define metadata node.
 struct AMFMetadata : public AMFNodeElementBase {
 
-	std::string Type; ///< Type of "Value".
-	std::string Value; ///< Value.
+	std::string MetaType; ///< Type of "Value".
+	std::string Value;    ///< Value.
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFMetadata(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Metadata, pParent) {}
+	explicit AMFMetadata(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Metadata, pParent) {
+	    // empty	
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Root
 /// Structure that define root node.
 struct AMFRoot : public AMFNodeElementBase {
 
@@ -159,11 +155,12 @@ struct AMFRoot : public AMFNodeElementBase {
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFRoot(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Root, pParent) {}
+	explicit AMFRoot(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Root, pParent) {
+	    // empty	
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Color
 /// Structure that define object node.
 struct AMFColor : public AMFNodeElementBase {
 	bool Composed; ///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
@@ -173,92 +170,97 @@ struct AMFColor : public AMFNodeElementBase {
 
 	/// @brief  Constructor.
 	/// @param [in] pParent - pointer to parent node.
-	AMFColor(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Color, pParent), Composed(false), Color(), Profile() {
+	explicit AMFColor(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Color, pParent), Composed(false), Color() {
 		// empty
 	}
 };
 
-/// \struct CAMFImporter_NodeElement_Material
 /// Structure that define material node.
 struct AMFMaterial : public AMFNodeElementBase {
-
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFMaterial(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Material, pParent) {}
+	explicit AMFMaterial(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Material, pParent) {
+	    // empty	
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Object
 /// Structure that define object node.
 struct AMFObject : public AMFNodeElementBase {
-
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFObject(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Object, pParent) {}
+	explicit AMFObject(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Object, pParent) {
+	    // empty	
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Mesh
 /// Structure that define mesh node.
 struct AMFMesh : public AMFNodeElementBase {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFMesh(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Mesh, pParent) {}
+	explicit AMFMesh(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Mesh, pParent) {
+	    // empty	
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Vertex
 /// Structure that define vertex node.
 struct AMFVertex : public AMFNodeElementBase {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFVertex(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Vertex, pParent) {}
+	explicit AMFVertex(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Vertex, pParent) {
+		// empty
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Edge
 /// Structure that define edge node.
 struct AMFEdge : public AMFNodeElementBase {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFEdge(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Edge, pParent) {}
+	explicit AMFEdge(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Edge, pParent) {
+		// empty
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Vertices
 /// Structure that define vertices node.
 struct AMFVertices : public AMFNodeElementBase {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFVertices(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Vertices, pParent) {}
+	explicit AMFVertices(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Vertices, pParent) {
+		// empty
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Volume
 /// Structure that define volume node.
 struct AMFVolume : public AMFNodeElementBase {
 	std::string MaterialID; ///< Which material to use.
-	std::string Type; ///< What this volume describes can be "region" or "support". If none specified, "object" is assumed.
+	std::string VolumeType; ///< What this volume describes can be "region" or "support". If none specified, "object" is assumed.
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFVolume(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Volume, pParent) {}
+	explicit AMFVolume(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Volume, pParent) {
+		// empty
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_Coordinates
 /// Structure that define coordinates node.
 struct AMFCoordinates : public AMFNodeElementBase {
 	aiVector3D Coordinate; ///< Coordinate.
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFCoordinates(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_Coordinates, pParent) {}
+	explicit AMFCoordinates(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Coordinates, pParent) {
+		// empty
+	}
 };
 
-/// \struct CAMFImporter_NodeElement_TexMap
 /// Structure that define texture coordinates node.
 struct AMFTexMap : public AMFNodeElementBase {
 	aiVector3D TextureCoordinate[3]; ///< Texture coordinates.
@@ -269,20 +271,19 @@ struct AMFTexMap : public AMFNodeElementBase {
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFTexMap(AMFNodeElementBase *pParent) :
-			AMFNodeElementBase(ENET_TexMap, pParent), TextureCoordinate{}, TextureID_R(), TextureID_G(), TextureID_B(), TextureID_A() {
+	explicit AMFTexMap(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_TexMap, pParent), TextureCoordinate{} {
 		// empty
 	}
 };
 
-/// \struct CAMFImporter_NodeElement_Triangle
 /// Structure that define triangle node.
 struct AMFTriangle : public AMFNodeElementBase {
 	size_t V[3]; ///< Triangle vertices.
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFTriangle(AMFNodeElementBase *pParent) :
+	explicit AMFTriangle(AMFNodeElementBase *pParent) :
 			AMFNodeElementBase(ENET_Triangle, pParent) {
 		// empty
 	}
@@ -296,7 +297,7 @@ struct AMFTexture : public AMFNodeElementBase {
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
-	AMFTexture(AMFNodeElementBase *pParent) :
+	explicit AMFTexture(AMFNodeElementBase *pParent) :
 			AMFNodeElementBase(ENET_Texture, pParent), Width(0), Height(0), Depth(0), Data(), Tiled(false) {
 		// empty
 	}

code/AssetLib/AMF/AMFImporter_Postprocess.cpp

@@ -1,9 +1,9 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -57,8 +57,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*pY*/, const float /*pZ*/) const {
-    aiColor4D tcol;
-
     // Check if stored data are supported.
     if (!Composition.empty()) {
         throw DeadlyImportError("IME. GetColor for composition");
@@ -68,7 +66,7 @@ aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*
         throw DeadlyImportError("IME. GetColor, composed color");
     }
 
-    tcol = Color->Color;
+    aiColor4D tcol = Color->Color;
 
     // Check if default color must be used
     if ((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0)) {
@@ -224,7 +222,8 @@ size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string &
     }
 
     // Create format hint.
-    strcpy(converted_texture.FormatHint, "rgba0000"); // copy initial string.
+    constexpr char templateColor[] = "rgba0000";
+    memcpy(converted_texture.FormatHint, templateColor, 8);
     if (!r.empty()) converted_texture.FormatHint[4] = '8';
     if (!g.empty()) converted_texture.FormatHint[5] = '8';
     if (!b.empty()) converted_texture.FormatHint[6] = '8';
@@ -332,7 +331,7 @@ void AMFImporter::Postprocess_AddMetadata(const AMFMetaDataArray &metadataList,
     size_t meta_idx(0);
 
     for (const AMFMetadata *metadata : metadataList) {
-        sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata->Type, aiString(metadata->Value));
+        sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata->MetaType, aiString(metadata->Value));
     }
 }
 
@@ -531,11 +530,9 @@ void AMFImporter::Postprocess_BuildMeshSet(const AMFMesh &pNodeElement, const st
                 col_arr.reserve(VertexCount_Max * 2);
 
                 { // fill arrays
-                    size_t vert_idx_from, vert_idx_to;
-
                     // first iteration.
-                    vert_idx_to = 0;
-                    vert_idx_from = VertexIndex_GetMinimal(face_list_cur, nullptr);
+                    size_t vert_idx_to = 0;
+                    size_t vert_idx_from = VertexIndex_GetMinimal(face_list_cur, nullptr);
                     vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
                     col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
                     if (vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
@@ -815,6 +812,7 @@ nl_clean_loop:
             for (; next_it != nodeArray.end(); ++next_it) {
                 if ((*next_it)->FindNode((*nl_it)->mName) != nullptr) {
                     // if current top node(nl_it) found in another top node then erase it from node_list and restart search loop.
+                    // FIXME: this leaks memory on test models test8.amf and test9.amf
                     nodeArray.erase(nl_it);
 
                     goto nl_clean_loop;
@@ -866,7 +864,7 @@ nl_clean_loop:
             pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
             pScene->mTextures[idx]->pcData = (aiTexel *)tex_convd.Data;
             // texture format description.
-            strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
+            strncpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint, HINTMAXTEXTURELEN);
             idx++;
         } // for(const SPP_Texture& tex_convd: mTexture_Converted)
 

code/AssetLib/ASE/ASELoader.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -44,7 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ASSIMP_BUILD_NO_ASE_IMPORTER
-
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers
@@ -64,10 +63,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // utilities
 #include <assimp/fast_atof.h>
 
-using namespace Assimp;
+namespace Assimp {
 using namespace Assimp::ASE;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "ASE Importer",
     "",
     "",
@@ -87,10 +86,6 @@ ASEImporter::ASEImporter() :
     // empty
 }
 
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-ASEImporter::~ASEImporter() = default;
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool ASEImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
@@ -122,14 +117,14 @@ void ASEImporter::InternReadFile(const std::string &pFile,
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if (file.get() == nullptr) {
+    if (file == nullptr) {
         throw DeadlyImportError("Failed to open ASE file ", pFile, ".");
     }
 
     // Allocate storage and copy the contents of the file to a memory buffer
     std::vector<char> mBuffer2;
     TextFileToBuffer(file.get(), mBuffer2);
-
+    const size_t fileSize = mBuffer2.size();
     this->mBuffer = &mBuffer2[0];
     this->pcScene = pScene;
 
@@ -151,7 +146,7 @@ void ASEImporter::InternReadFile(const std::string &pFile,
     };
 
     // Construct an ASE parser and parse the file
-    ASE::Parser parser(mBuffer, defaultFormat);
+    ASE::Parser parser(mBuffer, fileSize, defaultFormat);
     mParser = &parser;
     mParser->Parse();
 
@@ -326,21 +321,6 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode *> &nodes) {
                 aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
                 nd->mNodeName.Set(me->mName + ".Target");
 
-                // If there is no input position channel we will need
-                // to supply the default position from the node's
-                // local transformation matrix.
-                /*TargetAnimationHelper helper;
-                if (me->mAnim.akeyPositions.empty())
-                {
-                    aiMatrix4x4& mat = (*i)->mTransform;
-                    helper.SetFixedMainAnimationChannel(aiVector3D(
-                        mat.a4, mat.b4, mat.c4));
-                }
-                else helper.SetMainAnimationChannel (&me->mAnim.akeyPositions);
-                helper.SetTargetAnimationChannel (&me->mTargetAnim.akeyPositions);
-
-                helper.Process(&me->mTargetAnim.akeyPositions);*/
-
                 // Allocate the key array and fill it
                 nd->mNumPositionKeys = (unsigned int)me->mTargetAnim.akeyPositions.size();
                 nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
@@ -466,10 +446,9 @@ void ASEImporter::BuildLights() {
 }
 
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
-        aiNode *pcParent, const char *szName) {
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes, aiNode *pcParent, const std::string &name) {
     aiMatrix4x4 m;
-    AddNodes(nodes, pcParent, szName, m);
+    AddNodes(nodes, pcParent, name, m);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -526,10 +505,9 @@ void ASEImporter::AddMeshes(const ASE::BaseNode *snode, aiNode *node) {
 
 // ------------------------------------------------------------------------------------------------
 // Add child nodes to a given parent node
-void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
-        aiNode *pcParent, const char *szName,
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes, aiNode *pcParent, const std::string &name,
         const aiMatrix4x4 &mat) {
-    const size_t len = szName ? ::strlen(szName) : 0;
+    const size_t len = name.size();
     ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS);
 
     // Receives child nodes for the pcParent node
@@ -539,16 +517,18 @@ void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
     // which has *us* as parent.
     for (std::vector<BaseNode *>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
         const BaseNode *snode = *it;
-        if (szName) {
-            if (len != snode->mParent.length() || ::strcmp(szName, snode->mParent.c_str()))
+        if (!name.empty()) {
+            if (len != snode->mParent.length() || name != snode->mParent.c_str()) {
                 continue;
-        } else if (snode->mParent.length())
+            }
+        } else if (snode->mParent.length()) {
             continue;
+        }
 
         (*it)->mProcessed = true;
 
         // Allocate a new node and add it to the output data structure
-        apcNodes.push_back(new aiNode());
+        apcNodes.push_back(new aiNode);
         aiNode *node = apcNodes.back();
 
         node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node"));
@@ -561,7 +541,7 @@ void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
 
         // Add sub nodes - prevent stack overflow due to recursive parenting
         if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) {
-            AddNodes(nodes, node, node->mName.data, snode->mTransform);
+            AddNodes(nodes, node, node->mName.C_Str(), snode->mTransform);
         }
 
         // Further processing depends on the type of the node
@@ -639,7 +619,8 @@ void ASEImporter::BuildNodes(std::vector<BaseNode *> &nodes) {
     }
 
     // add all nodes
-    AddNodes(nodes, ch, nullptr);
+    static const std::string none = "";
+    AddNodes(nodes, ch, none);
 
     // now iterate through al nodes and find those that have not yet
     // been added to the nodegraph (= their parent could not be recognized)
@@ -750,6 +731,10 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh &mesh) {
     unsigned int iCurrent = 0, fi = 0;
     for (std::vector<ASE::Face>::iterator i = mesh.mFaces.begin(); i != mesh.mFaces.end(); ++i, ++fi) {
         for (unsigned int n = 0; n < 3; ++n, ++iCurrent) {
+            const uint32_t curIndex = (*i).mIndices[n];
+            if (curIndex >= mesh.mPositions.size()) {
+                throw DeadlyImportError("ASE: Invalid vertex index in face ", fi, ".");
+            }
             mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]];
 
             // add texture coordinates
@@ -924,7 +909,7 @@ void ASEImporter::ConvertMeshes(ASE::Mesh &mesh, std::vector<aiMesh *> &avOutMes
         ASSIMP_LOG_WARN("Material index is out of range");
     }
 
-    // If the material the mesh is assigned to is consisting of submeshes, split it
+    // If the material the mesh is assigned to consists of submeshes, split it
     if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) {
         std::vector<ASE::Material> vSubMaterials = mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials;
 
@@ -1282,6 +1267,7 @@ bool ASEImporter::GenerateNormals(ASE::Mesh &mesh) {
     return false;
 }
 
-#endif // ASSIMP_BUILD_NO_3DS_IMPORTER
+}
 
-#endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER
+#endif // ASSIMP_BUILD_NO_3DS_IMPORTER
+#endif // ASSIMP_BUILD_NO_ASE_IMPORTER

code/AssetLib/ASE/ASELoader.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -59,10 +59,10 @@ namespace Assimp {
 /** Importer class for the 3DS ASE ASCII format.
  *
  */
-class ASEImporter : public BaseImporter {
+class ASEImporter final : public BaseImporter {
 public:
     ASEImporter();
-    ~ASEImporter() override;
+    ~ASEImporter() override = default;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
@@ -153,13 +153,13 @@ private:
      *  \param matrix Current transform
      */
     void AddNodes(const std::vector<ASE::BaseNode*>& nodes,
-        aiNode* pcParent,const char* szName);
+        aiNode* pcParent, const std::string &name);
 
     void AddNodes(const std::vector<ASE::BaseNode*>& nodes,
-        aiNode* pcParent,const char* szName,
+        aiNode* pcParent, const std::string &name,
         const aiMatrix4x4& matrix);
 
-    void AddMeshes(const ASE::BaseNode* snode,aiNode* node);
+    void AddMeshes(const ASE::BaseNode* snode, aiNode* node);
 
     // -------------------------------------------------------------------
     /** Generate a default material and add it to the parser's list
@@ -188,5 +188,4 @@ protected:
 
 } // end of namespace Assimp
 
-
 #endif // AI_3DSIMPORTER_H_INC

code/AssetLib/ASE/ASEParser.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -58,14 +57,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ASE is quite similar to 3ds. We can reuse some structures
 #include "AssetLib/3DS/3DSLoader.h"
 
-namespace Assimp {
-namespace ASE {
+namespace Assimp::ASE {
 
 using namespace D3DS;
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing an ASE material */
-struct Material : public D3DS::Material {
+struct Material final : D3DS::Material {
     //! Default constructor has been deleted
     Material() = delete;
 
@@ -116,7 +114,7 @@ struct Material : public D3DS::Material {
         return *this;
     }
 
-    ~Material() = default;
+    ~Material() override = default;
 
     //! Contains all sub materials of this material
     std::vector<Material> avSubMaterials;
@@ -374,8 +372,8 @@ struct Dummy : public BaseNode {
 };
 
 // Parameters to Parser::Parse()
-#define AI_ASE_NEW_FILE_FORMAT 200
-#define AI_ASE_OLD_FILE_FORMAT 110
+static constexpr unsigned int AI_ASE_NEW_FILE_FORMAT = 200;
+static constexpr unsigned int AI_ASE_OLD_FILE_FORMAT = 110;
 
 // Internally we're a little bit more tolerant
 #define AI_ASE_IS_NEW_FILE_FORMAT() (iFileFormat >= 200)
@@ -385,20 +383,18 @@ struct Dummy : public BaseNode {
 /** \brief Class to parse ASE files
  */
 class Parser {
-private:
-    Parser() AI_NO_EXCEPT {
-        // empty
-    }
-
 public:
+    /// @brief No default constructor.
+    Parser() = delete;
+
     // -------------------------------------------------------------------
     //! Construct a parser from a given input file which is
     //! guaranteed to be terminated with zero.
-    //! @param szFile Input file
+    //! @param file              The name of the input file.
     //! @param fileFormatDefault Assumed file format version. If the
     //!   file format is specified in the file the new value replaces
     //!   the default value.
-    Parser(const char *szFile, unsigned int fileFormatDefault);
+    Parser(const char *file, size_t fileLen, unsigned int fileFormatDefault);
 
     // -------------------------------------------------------------------
     //! Parses the file into the parsers internal representation
@@ -556,13 +552,15 @@ private:
     //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL  ...)
     //! \param apOut Output buffer (3 floats)
     //! \param rIndexOut Output index
-    void ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut);
+    void ParseLV4MeshRealTriple(ai_real *apOut, unsigned int &rIndexOut);
+    void ParseLV4MeshFloatTriple(float *apOut, unsigned int &rIndexOut);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_VERT block in a file
     //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL  ...)
     //! \param apOut Output buffer (3 floats)
-    void ParseLV4MeshFloatTriple(ai_real *apOut);
+    void ParseLV4MeshRealTriple(ai_real *apOut);
+    void ParseLV4MeshFloatTriple(float *apOut);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_TFACE block in a file
@@ -580,7 +578,8 @@ private:
     // -------------------------------------------------------------------
     //! Parse a single float element
     //! \param fOut Output float
-    void ParseLV4MeshFloat(ai_real &fOut);
+    void ParseLV4MeshReal(ai_real &fOut);
+    void ParseLV4MeshFloat(float &fOut);
 
     // -------------------------------------------------------------------
     //! Parse a single int element
@@ -620,8 +619,8 @@ private:
     bool ParseString(std::string &out, const char *szName);
 
 public:
-    //! Pointer to current data
-    const char *filePtr;
+    const char *mFilePtr; ////< Pointer to current data
+    const char *mEnd;     ///< The end pointer of the file data
 
     //! background color to be passed to the viewer
     //! QNAN if none was found
@@ -668,8 +667,7 @@ public:
     unsigned int iFileFormat;
 };
 
-} // Namespace ASE
-} // namespace Assimp
+} // Namespace Assimp::ASE
 
 #endif // ASSIMP_BUILD_NO_3DS_IMPORTER
 

code/AssetLib/Assbin/AssbinExporter.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 

code/AssetLib/Assbin/AssbinExporter.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -56,5 +56,5 @@ namespace Assimp {
 void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/);
 
 }
-#endif 
+#endif
 #endif // AI_ASSBINEXPORTER_H_INC

code/AssetLib/Assbin/AssbinFileWriter.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -50,11 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/version.h>
 #include <assimp/IOStream.hpp>
 
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#include <zlib.h>
-#else
-#include "../contrib/zlib/zlib.h"
-#endif
+#include "zlib.h"
 
 #include <ctime>
 
@@ -243,29 +239,7 @@ inline size_t WriteArray(IOStream *stream, const T *in, unsigned int size) {
  *  and the chunk contents to the container stream. This allows relatively easy chunk
  *  chunk construction, even recursively.
  */
-class AssbinChunkWriter : public IOStream {
-private:
-    uint8_t *buffer;
-    uint32_t magic;
-    IOStream *container;
-    size_t cur_size, cursor, initial;
-
-private:
-    // -------------------------------------------------------------------
-    void Grow(size_t need = 0) {
-        size_t new_size = std::max(initial, std::max(need, cur_size + (cur_size >> 1)));
-
-        const uint8_t *const old = buffer;
-        buffer = new uint8_t[new_size];
-
-        if (old) {
-            memcpy(buffer, old, cur_size);
-            delete[] old;
-        }
-
-        cur_size = new_size;
-    }
-
+class AssbinChunkWriter final : public IOStream {
 public:
     AssbinChunkWriter(IOStream *container, uint32_t magic, size_t initial = 4096) :
             buffer(nullptr),
@@ -291,15 +265,15 @@ public:
     size_t Read(void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override {
         return 0;
     }
-    
+
     aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) override {
         return aiReturn_FAILURE;
     }
-    
+
     size_t Tell() const override {
         return cursor;
     }
-    
+
     void Flush() override {
         // not implemented
     }
@@ -319,6 +293,28 @@ public:
 
         return pCount;
     }
+
+private:
+    // -------------------------------------------------------------------
+    void Grow(size_t need = 0) {
+        size_t new_size = std::max(initial, std::max(need, cur_size + (cur_size >> 1)));
+
+        const uint8_t *const old = buffer;
+        buffer = new uint8_t[new_size];
+
+        if (old) {
+            memcpy(buffer, old, cur_size);
+            delete[] old;
+        }
+
+        cur_size = new_size;
+    }
+
+private:
+    uint8_t *buffer;
+    uint32_t magic;
+    IOStream *container;
+    size_t cur_size, cursor, initial;
 };
 
 // ----------------------------------------------------------------------------------

code/AssetLib/Assbin/AssbinFileWriter.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 

code/AssetLib/Assbin/AssbinLoader.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
 
 // internal headers
-#include "AssetLib/Assbin/AssbinLoader.h"
+#include "AssbinLoader.h"
 #include "Common/assbin_chunks.h"
 #include <assimp/MemoryIOWrapper.h>
 #include <assimp/anim.h>
@@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "Assimp Binary Importer",
     "Gargaj / Conspiracy",
     "",
@@ -91,10 +91,14 @@ bool AssbinImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, boo
     }
 
     char s[32];
-    in->Read(s, sizeof(char), 32);
+    const size_t read = in->Read(s, sizeof(char), 32);
 
     pIOHandler->Close(in);
 
+    if (read < 19) {
+      return false;
+    }
+
     return strncmp(s, "ASSIMP.binary-dump.", 19) == 0;
 }
 
@@ -684,6 +688,7 @@ void AssbinImporter::InternReadFile(const std::string &pFile, aiScene *pScene, I
     unsigned int versionMajor = Read<unsigned int>(stream);
     unsigned int versionMinor = Read<unsigned int>(stream);
     if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) {
+        pIOHandler->Close(stream);
         throw DeadlyImportError("Invalid version, data format not compatible!");
     }
 
@@ -693,8 +698,10 @@ void AssbinImporter::InternReadFile(const std::string &pFile, aiScene *pScene, I
     shortened = Read<uint16_t>(stream) > 0;
     compressed = Read<uint16_t>(stream) > 0;
 
-    if (shortened)
+    if (shortened) {
+        pIOHandler->Close(stream);
         throw DeadlyImportError("Shortened binaries are not supported!");
+    }
 
     stream->Seek(256, aiOrigin_CUR); // original filename
     stream->Seek(128, aiOrigin_CUR); // options

code/AssetLib/Assbin/AssbinLoader.h

@@ -1,9 +1,8 @@
-
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -61,7 +60,7 @@ struct aiCamera;
 
 #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------------
 /** Importer class for 3D Studio r3 and r4 3DS files

code/AssetLib/Assjson/cencode.c

@@ -7,7 +7,7 @@ For details, see http://sourceforge.net/projects/libb64
 
 #include "cencode.h" // changed from <B64/cencode.h>
 
-const int CHARS_PER_LINE = 72;
+static const int CHARS_PER_LINE = 72;
 
 #ifdef _MSC_VER
 #pragma warning(push)

code/AssetLib/Assjson/json_exporter.cpp

@@ -10,6 +10,7 @@ Licensed under a 3-clause BSD license. See the LICENSE file for more information
 #ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
 
 #include <assimp/scene.h>
+#include <assimp/ai_assert.h>
 #include <assimp/Exporter.hpp>
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
@@ -23,16 +24,15 @@ Licensed under a 3-clause BSD license. See the LICENSE file for more information
 
 #define CURRENT_FORMAT_VERSION 100
 
-// grab scoped_ptr from assimp to avoid a dependency on boost.
-//#include <assimp/../../code/BoostWorkaround/boost/scoped_ptr.hpp>
-
 #include "mesh_splitter.h"
 
 extern "C" {
-#include "cencode.h"
+#   include "cencode.h"
 }
+
 namespace Assimp {
 
+// Forward declarations
 void ExportAssimp2Json(const char *, Assimp::IOSystem *, const aiScene *, const Assimp::ExportProperties *);
 
 // small utility class to simplify serializing the aiScene to Json
@@ -43,7 +43,7 @@ public:
         Flag_WriteSpecialFloats = 0x2,
         Flag_SkipWhitespaces = 0x4
     };
-    
+
     JSONWriter(Assimp::IOStream &out, unsigned int flags = 0u) :
             out(out), indent (""), newline("\n"), space(" "), buff (), first(false), flags(flags) {
         // make sure that all formatting happens using the standard, C locale and not the user's current locale
@@ -179,7 +179,6 @@ private:
         // escape backslashes and single quotes, both would render the JSON invalid if left as is
         t.reserve(s.length);
         for (size_t i = 0; i < s.length; ++i) {
-
             if (s.data[i] == '\\' || s.data[i] == '\'' || s.data[i] == '\"') {
                 t.push_back('\\');
             }
@@ -241,7 +240,7 @@ private:
     unsigned int flags;
 };
 
-void Write(JSONWriter &out, const aiVector3D &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiVector3D &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.x);
     out.Element(ai.y);
@@ -249,7 +248,7 @@ void Write(JSONWriter &out, const aiVector3D &ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter &out, const aiQuaternion &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiQuaternion &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.w);
     out.Element(ai.x);
@@ -258,7 +257,7 @@ void Write(JSONWriter &out, const aiQuaternion &ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter &out, const aiColor3D &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiColor3D &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.r);
     out.Element(ai.g);
@@ -266,7 +265,7 @@ void Write(JSONWriter &out, const aiColor3D &ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter &out, const aiMatrix4x4 &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiMatrix4x4 &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     for (unsigned int x = 0; x < 4; ++x) {
         for (unsigned int y = 0; y < 4; ++y) {
@@ -276,7 +275,7 @@ void Write(JSONWriter &out, const aiMatrix4x4 &ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter &out, const aiBone &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiBone &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -297,7 +296,7 @@ void Write(JSONWriter &out, const aiBone &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiFace &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiFace &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     for (unsigned int i = 0; i < ai.mNumIndices; ++i) {
         out.Element(ai.mIndices[i]);
@@ -305,7 +304,7 @@ void Write(JSONWriter &out, const aiFace &ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter &out, const aiMesh &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiMesh &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -416,7 +415,7 @@ void Write(JSONWriter &out, const aiMesh &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiNode &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiNode &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -446,7 +445,7 @@ void Write(JSONWriter &out, const aiNode &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiMaterial &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiMaterial &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("properties");
@@ -466,41 +465,55 @@ void Write(JSONWriter &out, const aiMaterial &ai, bool is_elem = true) {
 
         out.Key("value");
         switch (prop->mType) {
-        case aiPTI_Float:
-            if (prop->mDataLength / sizeof(float) > 1) {
-                out.StartArray();
-                for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(float); ++ii) {
-                    out.Element(reinterpret_cast<float *>(prop->mData)[ii]);
+            case aiPTI_Float:
+                if (prop->mDataLength / sizeof(float) > 1) {
+                    out.StartArray();
+                    for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(float); ++ii) {
+                        out.Element(reinterpret_cast<float *>(prop->mData)[ii]);
+                    }
+                    out.EndArray();
+                } else {
+                    out.SimpleValue(*reinterpret_cast<float *>(prop->mData));
                 }
-                out.EndArray();
-            } else {
-                out.SimpleValue(*reinterpret_cast<float *>(prop->mData));
-            }
-            break;
-
-        case aiPTI_Integer:
-            if (prop->mDataLength / sizeof(int) > 1) {
-                out.StartArray();
-                for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(int); ++ii) {
-                    out.Element(reinterpret_cast<int *>(prop->mData)[ii]);
+                break;
+            case aiPTI_Double:
+                if (prop->mDataLength / sizeof(double) > 1) {
+                    out.StartArray();
+                    for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(double); ++ii) {
+                        out.Element(reinterpret_cast<double*>(prop->mData)[ii]);
+                    }
+                    out.EndArray();
+                } else {
+                    out.SimpleValue(*reinterpret_cast<double*>(prop->mData));
                 }
-                out.EndArray();
-            } else {
-                out.SimpleValue(*reinterpret_cast<int *>(prop->mData));
-            }
-            break;
+                break;
+            case aiPTI_Integer:
+                if (prop->mDataLength / sizeof(int) > 1) {
+                    out.StartArray();
+                    for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(int); ++ii) {
+                        out.Element(reinterpret_cast<int *>(prop->mData)[ii]);
+                    }
+                    out.EndArray();
+                } else {
+                    out.SimpleValue(*reinterpret_cast<int *>(prop->mData));
+                }
+                break;
 
-        case aiPTI_String: {
-            aiString s;
-            aiGetMaterialString(&ai, prop->mKey.data, prop->mSemantic, prop->mIndex, &s);
-            out.SimpleValue(s);
-        } break;
-        case aiPTI_Buffer: {
-            // binary data is written as series of hex-encoded octets
-            out.SimpleValue(prop->mData, prop->mDataLength);
-        } break;
-        default:
-            assert(false);
+            case aiPTI_String:
+                {
+                    aiString s;
+                    aiGetMaterialString(&ai, prop->mKey.data, prop->mSemantic, prop->mIndex, &s);
+                    out.SimpleValue(s);
+                }
+                break;
+            case aiPTI_Buffer:
+                {
+                    // binary data is written as series of hex-encoded octets
+                    out.SimpleValue(prop->mData, prop->mDataLength);
+                }
+                break;
+            default:
+                ai_assert(false);
         }
 
         out.EndObj();
@@ -510,7 +523,7 @@ void Write(JSONWriter &out, const aiMaterial &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiTexture &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiTexture &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("width");
@@ -546,7 +559,7 @@ void Write(JSONWriter &out, const aiTexture &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiLight &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiLight &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -594,7 +607,7 @@ void Write(JSONWriter &out, const aiLight &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiNodeAnim &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiNodeAnim &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -647,7 +660,7 @@ void Write(JSONWriter &out, const aiNodeAnim &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiAnimation &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiAnimation &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -668,7 +681,7 @@ void Write(JSONWriter &out, const aiAnimation &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiCamera &ai, bool is_elem = true) {
+static void Write(JSONWriter &out, const aiCamera &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -695,7 +708,7 @@ void Write(JSONWriter &out, const aiCamera &ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void WriteFormatInfo(JSONWriter &out) {
+static void WriteFormatInfo(JSONWriter &out) {
     out.StartObj();
     out.Key("format");
     out.SimpleValue("\"assimp2json\"");
@@ -704,7 +717,7 @@ void WriteFormatInfo(JSONWriter &out) {
     out.EndObj();
 }
 
-void Write(JSONWriter &out, const aiScene &ai) {
+static void Write(JSONWriter &out, const aiScene &ai) {
     out.StartObj();
 
     out.Key("__metadata__");

code/AssetLib/Assxml/AssxmlExporter.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -50,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/Exporter.hpp>
 
-namespace Assimp   {
+namespace Assimp {
 
 void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
 {

code/AssetLib/Assxml/AssxmlExporter.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 

code/AssetLib/Assxml/AssxmlFileWriter.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -36,7 +35,6 @@ 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.
-
 ----------------------------------------------------------------------
 */
 
@@ -79,8 +77,7 @@ static int ioprintf(IOStream *io, const char *format, ...) {
     }
 
     static const int Size = 4096;
-    char sz[Size];
-    ::memset(sz, '\0', Size);
+    char sz[Size] = {};
     va_list va;
     va_start(va, format);
     const unsigned int nSize = vsnprintf(sz, Size - 1, format, va);
@@ -223,7 +220,7 @@ static void WriteDump(const char *pFile, const char *cmd, const aiScene *scene,
     const unsigned int majorVersion(aiGetVersionMajor());
     const unsigned int minorVersion(aiGetVersionMinor());
     const unsigned int rev(aiGetVersionRevision());
-    const char *curtime(asctime(p));
+    const char *curtime = asctime(p);
     ioprintf(io, header.c_str(), majorVersion, minorVersion, rev, pFile, c.c_str(), curtime, scene->mFlags, 0u);
 
     // write the node graph
@@ -304,7 +301,11 @@ static void WriteDump(const char *pFile, const char *cmd, const aiScene *scene,
             bool compressed = (tex->mHeight == 0);
 
             // mesh header
-            ioprintf(io, "\t<Texture width=\"%u\" height=\"%u\" compressed=\"%s\"> \n",
+            std::string texName = "unknown";
+            if (tex->mFilename.length != 0u) {
+                texName = tex->mFilename.data;
+            }
+            ioprintf(io, "\t<Texture name=\"%s\" width=\"%u\" height=\"%u\" compressed=\"%s\"> \n", texName.c_str(),
                     (compressed ? -1 : tex->mWidth), (compressed ? -1 : tex->mHeight),
                     (compressed ? "true" : "false"));
 
@@ -352,7 +353,7 @@ static void WriteDump(const char *pFile, const char *cmd, const aiScene *scene,
             for (unsigned int n = 0; n < mat->mNumProperties; ++n) {
 
                 const aiMaterialProperty *prop = mat->mProperties[n];
-                const char *sz = "";
+                auto sz = "";
                 if (prop->mType == aiPTI_Float) {
                     sz = "float";
                 } else if (prop->mType == aiPTI_Integer) {
@@ -652,7 +653,7 @@ void DumpSceneToAssxml(
         const char *pFile, const char *cmd, IOSystem *pIOSystem,
         const aiScene *pScene, bool shortened) {
     std::unique_ptr<IOStream> file(pIOSystem->Open(pFile, "wt"));
-    if (!file.get()) {
+    if (!file) {
         throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
     }
 

code/AssetLib/Assxml/AssxmlFileWriter.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 

code/AssetLib/B3D/B3DImporter.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
 
 // internal headers
-#include "AssetLib/B3D/B3DImporter.h"
+#include "B3DImporter.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 #include "PostProcessing/TextureTransform.h"
 
@@ -59,10 +59,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <memory>
 
-using namespace Assimp;
+namespace Assimp {
 using namespace std;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "BlitzBasic 3D Importer",
     "",
     "",
@@ -79,9 +79,9 @@ static const aiImporterDesc desc = {
 #pragma warning(disable : 4018)
 #endif
 
-//#define DEBUG_B3D
+// #define DEBUG_B3D
 
-template<typename T>
+template <typename T>
 void DeleteAllBarePointers(std::vector<T> &x) {
     for (auto p : x) {
         delete p;
@@ -116,7 +116,7 @@ void B3DImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
 
     // Check whether we can read from the file
-    if (file.get() == nullptr) {
+    if (file == nullptr) {
         throw DeadlyImportError("Failed to open B3D file ", pFile, ".");
     }
 
@@ -150,7 +150,7 @@ AI_WONT_RETURN void B3DImporter::Fail(const string &str) {
 
 // ------------------------------------------------------------------------------------------------
 int B3DImporter::ReadByte() {
-    if (_pos > _buf.size()) {
+    if (_pos >= _buf.size()) {
         Fail("EOF");
     }
 
@@ -253,7 +253,7 @@ size_t B3DImporter::ChunkSize() {
 template <class T>
 T *B3DImporter::to_array(const vector<T> &v) {
     if (v.empty()) {
-        return 0;
+        return nullptr;
     }
     T *p = new T[v.size()];
     for (size_t i = 0; i < v.size(); ++i) {
@@ -266,7 +266,7 @@ T *B3DImporter::to_array(const vector<T> &v) {
 template <class T>
 T **unique_to_array(vector<std::unique_ptr<T>> &v) {
     if (v.empty()) {
-        return 0;
+        return nullptr;
     }
     T **p = new T *[v.size()];
     for (size_t i = 0; i < v.size(); ++i) {
@@ -329,7 +329,7 @@ void B3DImporter::ReadBRUS() {
             mat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED);
         }
 
-        //Textures
+        // Textures
         for (int i = 0; i < n_texs; ++i) {
             int texid = ReadInt();
             if (texid < -1 || (texid >= 0 && texid >= static_cast<int>(_textures.size()))) {
@@ -372,7 +372,7 @@ void B3DImporter::ReadVRTS() {
         }
 
         if (_vflags & 2) {
-            ReadQuat(); //skip v 4bytes...
+            ReadQuat(); // skip v 4bytes...
         }
 
         for (int j = 0; j < _tcsets; ++j) {
@@ -418,7 +418,6 @@ void B3DImporter::ReadTRIS(int v0) {
             ASSIMP_LOG_ERROR("Bad triangle index: i0=", i0, ", i1=", i1, ", i2=", i2);
 #endif
             Fail("Bad triangle index");
-            continue;
         }
         face->mNumIndices = 3;
         face->mIndices = new unsigned[3];
@@ -617,7 +616,7 @@ void B3DImporter::ReadBB3D(aiScene *scene) {
             } else if (chunk == "BRUS") {
                 ReadBRUS();
             } else if (chunk == "NODE") {
-                ReadNODE(0);
+                ReadNODE(nullptr);
             }
             ExitChunk();
         }
@@ -642,7 +641,7 @@ void B3DImporter::ReadBB3D(aiScene *scene) {
             int n_tris = mesh->mNumFaces;
             int n_verts = mesh->mNumVertices = n_tris * 3;
 
-            aiVector3D *mv = mesh->mVertices = new aiVector3D[n_verts], *mn = 0, *mc = 0;
+            aiVector3D *mv = mesh->mVertices = new aiVector3D[n_verts], *mn = nullptr, *mc = nullptr;
             if (_vflags & 1) {
                 mn = mesh->mNormals = new aiVector3D[n_verts];
             }
@@ -705,22 +704,22 @@ void B3DImporter::ReadBB3D(aiScene *scene) {
         }
     }
 
-    //nodes
+    // nodes
     scene->mRootNode = _nodes[0];
     _nodes.clear(); // node ownership now belongs to scene
 
-    //material
+    // material
     if (!_materials.size()) {
         _materials.emplace_back(std::unique_ptr<aiMaterial>(new aiMaterial));
     }
     scene->mNumMaterials = static_cast<unsigned int>(_materials.size());
     scene->mMaterials = unique_to_array(_materials);
 
-    //meshes
+    // meshes
     scene->mNumMeshes = static_cast<unsigned int>(_meshes.size());
     scene->mMeshes = unique_to_array(_meshes);
 
-    //animations
+    // animations
     if (_animations.size() == 1 && _nodeAnims.size()) {
 
         aiAnimation *anim = _animations.back().get();
@@ -739,4 +738,6 @@ void B3DImporter::ReadBB3D(aiScene *scene) {
     flip.Execute(scene);
 }
 
+} // namespace Assimp
+
 #endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER

code/AssetLib/B3D/B3DImporter.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -60,7 +60,7 @@ struct aiAnimation;
 
 namespace Assimp{
 
-class B3DImporter : public BaseImporter{
+class B3DImporter final : public BaseImporter{
 public:
     B3DImporter() = default;
     ~B3DImporter() override;

code/AssetLib/BVH/BVHLoader.cpp

@@ -4,9 +4,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -55,10 +53,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <map>
 #include <memory>
 
-using namespace Assimp;
+namespace Assimp {
+
 using namespace Assimp::Formatter;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "BVH Importer (MoCap)",
     "",
     "",
@@ -73,8 +72,8 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Aborts the file reading with an exception
-template<typename... T>
-AI_WONT_RETURN void BVHLoader::ThrowException(T&&... args) {
+template <typename... T>
+AI_WONT_RETURN void BVHLoader::ThrowException(T &&...args) {
     throw DeadlyImportError(mFileName, ":", mLine, " - ", args...);
 }
 
@@ -84,11 +83,9 @@ BVHLoader::BVHLoader() :
         mLine(),
         mAnimTickDuration(),
         mAnimNumFrames(),
-        noSkeletonMesh() {}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-BVHLoader::~BVHLoader() = default;
+        noSkeletonMesh() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
@@ -115,7 +112,7 @@ void BVHLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSyst
 
     // read file into memory
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
-    if (file.get() == nullptr) {
+    if (file == nullptr) {
         throw DeadlyImportError("Failed to open file ", pFile, ".");
     }
 
@@ -191,7 +188,7 @@ aiNode *BVHLoader::ReadNode() {
 
     // now read the node's contents
     std::string siteToken;
-    while (1) {
+    while (true) {
         std::string token = GetNextToken();
 
         // node offset to parent node
@@ -247,7 +244,7 @@ aiNode *BVHLoader::ReadEndSite(const std::string &pParentName) {
 
     // now read the node's contents. Only possible entry is "OFFSET"
     std::string token;
-    while (1) {
+    while (true) {
         token.clear();
         token = GetNextToken();
 
@@ -388,7 +385,7 @@ float BVHLoader::GetNextTokenAsFloat() {
     // check if the float is valid by testing if the atof() function consumed every char of the token
     const char *ctoken = token.c_str();
     float result = 0.0f;
-    ctoken = fast_atoreal_move<float>(ctoken, result);
+    ctoken = fast_atoreal_move(ctoken, result);
 
     if (ctoken != token.c_str() + token.length())
         ThrowException("Expected a floating point number, but found \"", token, "\".");
@@ -426,7 +423,7 @@ void BVHLoader::CreateAnimation(aiScene *pScene) {
         nodeAnim->mNodeName.Set(nodeName);
         std::map<BVHLoader::ChannelType, int> channelMap;
 
-        //Build map of channels
+        // Build map of channels
         for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel) {
             channelMap[node.mChannels[channel]] = channel;
         }
@@ -441,7 +438,7 @@ void BVHLoader::CreateAnimation(aiScene *pScene) {
 
                 // Now compute all translations
                 for (BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel + 1)) {
-                    //Find channel in node
+                    // Find channel in node
                     std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
 
                     if (mapIter == channelMap.end())
@@ -485,30 +482,27 @@ void BVHLoader::CreateAnimation(aiScene *pScene) {
             for (unsigned int fr = 0; fr < mAnimNumFrames; ++fr) {
                 aiMatrix4x4 temp;
                 aiMatrix3x3 rotMatrix;
-				for (unsigned int channelIdx = 0; channelIdx < node.mChannels.size(); ++ channelIdx) {
-					switch (node.mChannels[channelIdx]) {
-                    case Channel_RotationX:
-                        {
+                for (unsigned int channelIdx = 0; channelIdx < node.mChannels.size(); ++channelIdx) {
+                    switch (node.mChannels[channelIdx]) {
+                    case Channel_RotationX: {
                         const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
-                        aiMatrix4x4::RotationX( angle, temp); rotMatrix *= aiMatrix3x3( temp);
-                        }
-                        break;
-                    case Channel_RotationY:
-                        {
+                        aiMatrix4x4::RotationX(angle, temp);
+                        rotMatrix *= aiMatrix3x3(temp);
+                    } break;
+                    case Channel_RotationY: {
                         const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
-                        aiMatrix4x4::RotationY( angle, temp); rotMatrix *= aiMatrix3x3( temp);
-                        }
-                        break;
-                    case Channel_RotationZ:
-                        {
+                        aiMatrix4x4::RotationY(angle, temp);
+                        rotMatrix *= aiMatrix3x3(temp);
+                    } break;
+                    case Channel_RotationZ: {
                         const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
-                        aiMatrix4x4::RotationZ( angle, temp); rotMatrix *= aiMatrix3x3( temp);
-                        }
-                        break;
+                        aiMatrix4x4::RotationZ(angle, temp);
+                        rotMatrix *= aiMatrix3x3(temp);
+                    } break;
                     default:
                         break;
-					}
-				}
+                    }
+                }
                 rotkey->mTime = double(fr);
                 rotkey->mValue = aiQuaternion(rotMatrix);
                 ++rotkey;
@@ -525,4 +519,6 @@ void BVHLoader::CreateAnimation(aiScene *pScene) {
     }
 }
 
+} // namespace Assimp
+
 #endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER

code/AssetLib/BVH/BVHLoader.h

@@ -4,8 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -62,7 +61,7 @@ namespace Assimp {
  * the hierarchy. It contains no actual mesh data, but we generate a dummy mesh
  * inside the loader just to be able to see something.
 */
-class BVHLoader : public BaseImporter {
+class BVHLoader final : public BaseImporter {
 
     /** Possible animation channels for which the motion data holds the values */
     enum ChannelType {
@@ -80,32 +79,27 @@ class BVHLoader : public BaseImporter {
         std::vector<ChannelType> mChannels;
         std::vector<float> mChannelValues; // motion data values for that node. Of size NumChannels * NumFrames
 
-        Node() :
-                mNode(nullptr) {}
-
-        explicit Node(const aiNode *pNode) :
-                mNode(pNode) {}
+        Node() : mNode(nullptr) {}
+        explicit Node(const aiNode *pNode) :mNode(pNode) {}
     };
 
 public:
     BVHLoader();
-    ~BVHLoader();
+    ~BVHLoader() override = default;
 
-public:
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details. */
-    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool cs) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool cs) const override;
 
-    void SetupProperties(const Importer *pImp);
-    const aiImporterDesc *GetInfo() const;
+    void SetupProperties(const Importer *pImp) override;
+    const aiImporterDesc *GetInfo() const override;
 
 protected:
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
 
-protected:
     /** Reads the file */
     void ReadStructure(aiScene *pScene);
 

code/AssetLib/Blender/BlenderBMesh.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -52,8 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 template <>
 const char *LogFunctions<BlenderBMeshConverter>::Prefix() {
-    static auto prefix = "BLEND_BMESH: ";
-    return prefix;
+    return "BLEND_BMESH: ";
 }
 } // namespace Assimp
 
@@ -75,7 +74,9 @@ BlenderBMeshConverter::~BlenderBMeshConverter() {
 
 // ------------------------------------------------------------------------------------------------
 bool BlenderBMeshConverter::ContainsBMesh() const {
-    // TODO - Should probably do some additional verification here
+    if (BMesh == nullptr) {
+        return false;
+    }
     return BMesh->totpoly && BMesh->totloop && BMesh->totvert;
 }
 
@@ -140,7 +141,7 @@ void BlenderBMeshConverter::ConvertPolyToFaces(const MPoly &poly) {
                 ThrowException("BMesh uv loop array has incorrect size");
             }
             const MLoopUV *loopUV = &BMesh->mloopuv[poly.loopstart];
-            AddTFace(loopUV[0].uv, loopUV[1].uv, loopUV[2].uv, poly.totloop == 4 ? loopUV[3].uv : 0);
+            AddTFace(loopUV[0].uv, loopUV[1].uv, loopUV[2].uv, poly.totloop == 4 ? loopUV[3].uv : nullptr);
         }
     } else if (poly.totloop > 4) {
 #if ASSIMP_BLEND_WITH_GLU_TESSELLATE

code/AssetLib/Blender/BlenderBMesh.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -63,14 +63,12 @@ namespace Assimp
         struct MLoop;
     }
 
-    class BlenderBMeshConverter: public LogFunctions< BlenderBMeshConverter >
+    class BlenderBMeshConverter final : public LogFunctions< BlenderBMeshConverter >
     {
     public:
-        BlenderBMeshConverter( const Blender::Mesh* mesh );
-        ~BlenderBMeshConverter( );
-
-        bool ContainsBMesh( ) const;
-
+        explicit BlenderBMeshConverter( const Blender::Mesh* mesh );
+        ~BlenderBMeshConverter();
+        bool ContainsBMesh() const;
         const Blender::Mesh* TriangulateBMesh( );
 
     private:
@@ -80,7 +78,7 @@ namespace Assimp
         void DestroyTriMesh( );
         void ConvertPolyToFaces( const Blender::MPoly& poly );
         void AddFace( int v1, int v2, int v3, int v4 = 0 );
-        void AddTFace( const float* uv1, const float* uv2, const float *uv3, const float* uv4 = 0 );
+        void AddTFace(const float *uv1, const float *uv2, const float *uv3, const float *uv4 = nullptr);
 
         const Blender::Mesh* BMesh;
         Blender::Mesh* triMesh;

code/AssetLib/Blender/BlenderCustomData.cpp

@@ -96,7 +96,8 @@ struct CustomDataTypeDescription {
         *           other (like CD_ORCO, ...) uses arrays of rawtypes or even arrays of Structures
         *           use a special readfunction for that cases
         */
-std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions = { { DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MVert),
+static const std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions = { {
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MVert),
         DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
         DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
         DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MEdge),
@@ -141,7 +142,8 @@ std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions =
         DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
 
         DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION } };
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION 
+} };
 
 bool isValidCustomDataType(const int cdtype) {
     return cdtype >= 0 && cdtype < CD_NUMTYPES;

code/AssetLib/Blender/BlenderDNA.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -72,7 +71,7 @@ struct Type {
 
 // ------------------------------------------------------------------------------------------------
 void DNAParser::Parse() {
-    StreamReaderAny &stream = *db.reader.get();
+    StreamReaderAny &stream = *db.reader;
     DNA &dna = db.dna;
 
     if (!match4(stream, "SDNA")) {

code/AssetLib/Blender/BlenderDNA.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -56,14 +55,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // enable verbose log output. really verbose, so be careful.
 #ifdef ASSIMP_BUILD_DEBUG
-#define ASSIMP_BUILD_BLENDER_DEBUG
+#   define ASSIMP_BUILD_BLENDER_DEBUG
 #endif
 
 // set this to non-zero to dump BlenderDNA stuff to dna.txt.
 // you could set it on the assimp build command line too without touching it here.
 // !!! please make sure this is set to 0 in the repo !!!
 #ifndef ASSIMP_BUILD_BLENDER_DEBUG_DNA
-#define ASSIMP_BUILD_BLENDER_DEBUG_DNA 0
+#   define ASSIMP_BUILD_BLENDER_DEBUG_DNA 0
 #endif
 
 // #define ASSIMP_BUILD_BLENDER_NO_STATS
@@ -106,9 +105,7 @@ struct ElemBase {
         // empty
     }
 
-    virtual ~ElemBase() {
-        // empty
-    }
+    virtual ~ElemBase() = default;
 
     /** Type name of the element. The type
      * string points is the `c_str` of the `name` attribute of the
@@ -127,22 +124,14 @@ struct ElemBase {
  *  they used to point to.*/
 // -------------------------------------------------------------------------------
 struct Pointer {
-    Pointer() :
-            val() {
-        // empty
-    }
-    uint64_t val;
+    uint64_t val{0};
 };
 
 // -------------------------------------------------------------------------------
 /** Represents a generic offset within a BLEND file */
 // -------------------------------------------------------------------------------
 struct FileOffset {
-    FileOffset() :
-            val() {
-        // empty
-    }
-    uint64_t val;
+    uint64_t val{0};
 };
 
 // -------------------------------------------------------------------------------
@@ -207,7 +196,7 @@ enum ErrorPolicy {
 };
 
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
-#define ErrorPolicy_Igno ErrorPolicy_Warn
+#   define ErrorPolicy_Igno ErrorPolicy_Warn
 #endif
 
 // -------------------------------------------------------------------------------
@@ -399,10 +388,9 @@ private:
     mutable size_t cache_idx;
 };
 
-// --------------------------------------------------------
-template <>
+// -------------------------------------------------------------------------------------------------------
+template<>
 struct Structure::_defaultInitializer<ErrorPolicy_Warn> {
-
     template <typename T>
     void operator()(T &out, const char *reason = "<add reason>") {
         ASSIMP_LOG_WARN(reason);
@@ -412,9 +400,9 @@ struct Structure::_defaultInitializer<ErrorPolicy_Warn> {
     }
 };
 
-template <>
+// -------------------------------------------------------------------------------------------------------
+template<>
 struct Structure::_defaultInitializer<ErrorPolicy_Fail> {
-
     template <typename T>
     void operator()(T & /*out*/, const char *message = "") {
         // obviously, it is crucial that _DefaultInitializer is used
@@ -431,6 +419,17 @@ inline bool Structure ::ResolvePointer<std::shared_ptr, ElemBase>(std::shared_pt
         const Field &f,
         bool) const;
 
+template <> bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(
+    std::shared_ptr<ElemBase>& out, const Pointer & ptrval,
+    const FileDatabase& db, const Field&, bool) const;
+template <> inline void Structure :: Convert<int>    (int& dest,const FileDatabase& db) const;
+template<> inline void Structure :: Convert<short>  (short& dest,const FileDatabase& db) const;
+template <> inline void Structure :: Convert<char>   (char& dest,const FileDatabase& db) const;
+template <> inline void Structure::Convert<unsigned char>(unsigned char& dest, const FileDatabase& db) const;
+template <> inline void Structure :: Convert<float>  (float& dest,const FileDatabase& db) const;
+template <> inline void Structure :: Convert<double> (double& dest,const FileDatabase& db) const;
+template <> inline void Structure :: Convert<Pointer> (Pointer& dest,const FileDatabase& db) const;
+
 // -------------------------------------------------------------------------------
 /** Represents the full data structure information for a single BLEND file.
  *  This data is extracted from the DNA1 chunk in the file.
@@ -611,31 +610,23 @@ public:
 /** Import statistics, i.e. number of file blocks read*/
 // -------------------------------------------------------------------------------
 class Statistics {
-
 public:
-    Statistics() :
-            fields_read(), pointers_resolved(), cache_hits()
-            //      , blocks_read       ()
-            ,
-            cached_objects() {}
+    Statistics() = default;
+    ~Statistics() = default;
 
-public:
-    /** total number of fields we read */
+    /// total number of fields we read
     unsigned int fields_read;
 
-    /** total number of resolved pointers */
+    /// total number of resolved pointers
     unsigned int pointers_resolved;
 
-    /** number of pointers resolved from the cache */
+    /// number of pointers resolved from the cache
     unsigned int cache_hits;
 
-    /** number of blocks (from  FileDatabase::entries)
-      we did actually read from. */
-    // unsigned int blocks_read;
-
-    /** objects in FileData::cache */
+    /// objects in FileData::cache
     unsigned int cached_objects;
 };
+
 #endif
 
 // -------------------------------------------------------------------------------
@@ -648,15 +639,13 @@ public:
     typedef std::map<Pointer, TOUT<ElemBase>> StructureCache;
 
 public:
-    ObjectCache(const FileDatabase &db) :
-            db(db) {
+    explicit ObjectCache(const FileDatabase &db) : db(db) {
         // currently there are only ~400 structure records per blend file.
         // we read only a small part of them and don't cache objects
         // which we don't need, so this should suffice.
         caches.reserve(64);
     }
 
-public:
     // --------------------------------------------------------
     /** Check whether a specific item is in the cache.
      *  @param s Data type of the item
@@ -664,10 +653,7 @@ public:
      *   cache doesn't know the item yet.
      *  @param ptr Item address to look for. */
     template <typename T>
-    void get(
-            const Structure &s,
-            TOUT<T> &out,
-            const Pointer &ptr) const;
+    void get( const Structure &s,TOUT<T> &out, const Pointer &ptr) const;
 
     // --------------------------------------------------------
     /** Add an item to the cache after the item has
@@ -692,7 +678,7 @@ private:
 template <>
 class ObjectCache<Blender::vector> {
 public:
-    ObjectCache(const FileDatabase &) {}
+    explicit ObjectCache(const FileDatabase &) {}
 
     template <typename T>
     void get(const Structure &, vector<T> &, const Pointer &) {}
@@ -701,7 +687,7 @@ public:
 };
 
 #ifdef _MSC_VER
-#pragma warning(disable : 4355)
+#   pragma warning(disable : 4355)
 #endif
 
 // -------------------------------------------------------------------------------
@@ -716,16 +702,6 @@ public:
     FileDatabase() :
             _cacheArrays(*this), _cache(*this), next_cache_idx() {}
 
-public:
-    // publicly accessible fields
-    bool i64bit;
-    bool little;
-
-    DNA dna;
-    std::shared_ptr<StreamReaderAny> reader;
-    vector<FileBlockHead> entries;
-
-public:
     Statistics &stats() const {
         return _stats;
     }
@@ -744,6 +720,15 @@ public:
         return _cacheArrays;
     }
 
+public:
+    // publicly accessible fields
+    bool i64bit;
+    bool little;
+
+    DNA dna;
+    std::shared_ptr<StreamReaderAny> reader;
+    vector<FileBlockHead> entries;
+
 private:
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
     mutable Statistics _stats;
@@ -756,20 +741,19 @@ private:
 };
 
 #ifdef _MSC_VER
-#pragma warning(default : 4355)
+#   pragma warning(default : 4355)
 #endif
 
 // -------------------------------------------------------------------------------
 /** Factory to extract a #DNA from the DNA1 file block in a BLEND file. */
 // -------------------------------------------------------------------------------
 class DNAParser {
-
 public:
     /** Bind the parser to a empty DNA and an input stream */
-    DNAParser(FileDatabase &db) :
-            db(db) {}
+    explicit DNAParser(FileDatabase &db) : db(db) {
+        // empty
+    }
 
-public:
     // --------------------------------------------------------
     /** Locate the DNA in the file and parse it. The input
      *  stream is expected to point to the beginning of the DN1
@@ -780,7 +764,6 @@ public:
      *    afterwards.*/
     void Parse();
 
-public:
     /** Obtain a reference to the extracted DNA information */
     const Blender::DNA &GetDNA() const {
         return db.dna;

code/AssetLib/Blender/BlenderDNA.inl

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -841,5 +841,7 @@ template <template <typename> class TOUT> template <typename T> void ObjectCache
 #endif
 }
 
-}}
+}
+}
+
 #endif

code/AssetLib/Blender/BlenderIntermediate.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -117,7 +116,7 @@ namespace Blender {
         mywrap arr;
     };
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && _MSC_VER < 1900
 #   pragma warning(disable:4351)
 #endif
 
@@ -172,7 +171,7 @@ namespace Blender {
         // original file data
         const FileDatabase& db;
     };
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && _MSC_VER < 1900
 #   pragma warning(default:4351)
 #endif
 

code/AssetLib/Blender/BlenderLoader.cpp

@@ -1,10 +1,8 @@
-
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -63,23 +61,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/StringComparison.h>
 
 #include <cctype>
+#include <memory>
+#include <utility>
 
 // zlib is needed for compressed blend files
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
 #include "Common/Compression.h"
-/* #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#    include <zlib.h>
-#  else
-#    include "../contrib/zlib/zlib.h"
-#  endif*/
 #endif
 
 namespace Assimp {
 
 template <>
 const char *LogFunctions<BlenderImporter>::Prefix() {
-    static auto prefix = "BLEND: ";
-    return prefix;
+    return "BLEND: ";
 }
 
 } // namespace Assimp
@@ -88,7 +82,7 @@ using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
-static const aiImporterDesc blenderDesc = {
+static constexpr aiImporterDesc blenderDesc = {
     "Blender 3D Importer (http://www.blender3d.org)",
     "",
     "",
@@ -114,15 +108,12 @@ BlenderImporter::~BlenderImporter() {
     delete modifier_cache;
 }
 
-static const char * const Tokens[] = { "BLENDER" };
+static constexpr char Token[] = "BLENDER";
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool BlenderImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    // note: this won't catch compressed files
-    static const char *tokens[] = { "<BLENDER", "blender" };
-
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+    return ParseMagicToken(pFile, pIOHandler).error.empty();
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -141,67 +132,25 @@ void BlenderImporter::SetupProperties(const Importer * /*pImp*/) {
 // Imports the given file into the given scene structure.
 void BlenderImporter::InternReadFile(const std::string &pFile,
         aiScene *pScene, IOSystem *pIOHandler) {
-#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-    std::vector<char> uncompressed;
-#endif
-
     FileDatabase file;
-    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
-    if (!stream) {
-        ThrowException("Could not open file for reading");
+    StreamOrError streamOrError = ParseMagicToken(pFile, pIOHandler);
+    if (!streamOrError.error.empty()) {
+        ThrowException(streamOrError.error);
     }
+    std::shared_ptr<IOStream> stream = std::move(streamOrError.stream);
 
-    char magic[8] = { 0 };
-    stream->Read(magic, 7, 1);
-    if (strcmp(magic, Tokens[0])) {
-        // Check for presence of the gzip header. If yes, assume it is a
-        // compressed blend file and try uncompressing it, else fail. This is to
-        // avoid uncompressing random files which our loader might end up with.
-#ifdef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-        ThrowException("BLENDER magic bytes are missing, is this file compressed (Assimp was built without decompression support)?");
-#else
-        if (magic[0] != 0x1f || static_cast<uint8_t>(magic[1]) != 0x8b) {
-            ThrowException("BLENDER magic bytes are missing, couldn't find GZIP header either");
-        }
+    char version[4] = { 0 };
+    file.i64bit = (stream->Read(version, 1, 1), version[0] == '-');
+    file.little = (stream->Read(version, 1, 1), version[0] == 'v');
 
-        LogDebug("Found no BLENDER magic word but a GZIP header, might be a compressed file");
-        if (magic[2] != 8) {
-            ThrowException("Unsupported GZIP compression method");
-        }
+    stream->Read(version, 3, 1);
+    version[3] = '\0';
 
-        // http://www.gzip.org/zlib/rfc-gzip.html#header-trailer
-        stream->Seek(0L, aiOrigin_SET);
-        std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
-
-        size_t total = 0;
-        Compression compression;
-        if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, 16 + Compression::MaxWBits)) {
-            total = compression.decompress((unsigned char *)reader->GetPtr(), reader->GetRemainingSize(), uncompressed);
-            compression.close();
-        }
-
-        // replace the input stream with a memory stream
-        stream.reset(new MemoryIOStream(reinterpret_cast<uint8_t *>(uncompressed.data()), total));
-
-        // .. and retry
-        stream->Read(magic, 7, 1);
-        if (strcmp(magic, "BLENDER")) {
-            ThrowException("Found no BLENDER magic word in decompressed GZIP file");
-        }
-#endif
-    }
-
-    file.i64bit = (stream->Read(magic, 1, 1), magic[0] == '-');
-    file.little = (stream->Read(magic, 1, 1), magic[0] == 'v');
-
-    stream->Read(magic, 3, 1);
-    magic[3] = '\0';
-
-    LogInfo("Blender version is ", magic[0], ".", magic + 1,
+    LogInfo("Blender version is ", version[0], ".", version + 1,
             " (64bit: ", file.i64bit ? "true" : "false",
             ", little endian: ", file.little ? "true" : "false", ")");
 
-    ParseBlendFile(file, stream);
+    ParseBlendFile(file, std::move(stream));
 
     Scene scene;
     ExtractScene(scene, file);
@@ -218,7 +167,7 @@ void BlenderImporter::ParseBlendFile(FileDatabase &out, std::shared_ptr<IOStream
 
     out.entries.reserve(128);
     { // even small BLEND files tend to consist of many file blocks
-        SectionParser parser(*out.reader.get(), out.i64bit);
+        SectionParser parser(*out.reader, out.i64bit);
 
         // first parse the file in search for the DNA and insert all other sections into the database
         while ((parser.Next(), 1)) {
@@ -408,7 +357,7 @@ void BlenderImporter::ResolveImage(aiMaterial *out, const Material *mat, const M
     // check if the file contents are bundled with the BLEND file
     if (img->packedfile) {
         name.data[0] = '*';
-        name.length = 1 + ASSIMP_itoa10(name.data + 1, static_cast<unsigned int>(MAXLEN - 1), static_cast<int32_t>(conv_data.textures->size()));
+        name.length = 1 + ASSIMP_itoa10(name.data + 1, static_cast<unsigned int>(AI_MAXLEN - 1), static_cast<int32_t>(conv_data.textures->size()));
 
         conv_data.textures->push_back(new aiTexture());
         aiTexture *curTex = conv_data.textures->back();
@@ -482,7 +431,7 @@ void BlenderImporter::AddSentinelTexture(aiMaterial *out, const Material *mat, c
     (void)conv_data;
 
     aiString name;
-    name.length = ai_snprintf(name.data, MAXLEN, "Procedural,num=%i,type=%s", conv_data.sentinel_cnt++,
+    name.length = ai_snprintf(name.data, AI_MAXLEN, "Procedural,num=%i,type=%s", conv_data.sentinel_cnt++,
             GetTextureTypeDisplayString(tex->tex->type));
     out->AddProperty(&name, AI_MATKEY_TEXTURE_DIFFUSE(
                                     conv_data.next_texture[aiTextureType_DIFFUSE]++));
@@ -544,8 +493,9 @@ void BlenderImporter::BuildDefaultMaterial(Blender::ConversionData &conv_data) {
             if (index == static_cast<unsigned int>(-1)) {
                 // Setup a default material.
                 std::shared_ptr<Material> p(new Material());
-                ai_assert(::strlen(AI_DEFAULT_MATERIAL_NAME) < sizeof(p->id.name) - 2);
-                strcpy(p->id.name + 2, AI_DEFAULT_MATERIAL_NAME);
+                const size_t len = ::strlen(AI_DEFAULT_MATERIAL_NAME);
+                ai_assert(len < sizeof(p->id.name) - 2);
+                memcpy(p->id.name + 2, AI_DEFAULT_MATERIAL_NAME, len);
 
                 // Note: MSVC11 does not zero-initialize Material here, although it should.
                 // Thus all relevant fields should be explicitly initialized. We cannot add
@@ -1337,4 +1287,55 @@ aiNode *BlenderImporter::ConvertNode(const Scene &in, const Object *obj, Convers
     return node.release();
 }
 
+BlenderImporter::StreamOrError BlenderImporter::ParseMagicToken(const std::string &pFile, IOSystem *pIOHandler) const {
+    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
+    if (stream == nullptr) {
+        return {{}, {}, "Could not open file for reading"};
+    }
+
+    char magic[8] = { 0 };
+    stream->Read(magic, 7, 1);
+    if (strcmp(magic, Token) == 0) {
+        return {stream, {}, {}};
+    }
+
+    // Check for presence of the gzip header. If yes, assume it is a
+    // compressed blend file and try uncompressing it, else fail. This is to
+    // avoid uncompressing random files which our loader might end up with.
+#ifdef ASSIMP_BUILD_NO_COMPRESSED_BLEND
+    return {{}, {}, "BLENDER magic bytes are missing, is this file compressed (Assimp was built without decompression support)?"};
+#else
+    if (magic[0] != 0x1f || static_cast<uint8_t>(magic[1]) != 0x8b) {
+        return {{}, {}, "BLENDER magic bytes are missing, couldn't find GZIP header either"};
+    }
+
+    LogDebug("Found no BLENDER magic word but a GZIP header, might be a compressed file");
+    if (magic[2] != 8) {
+        return {{}, {}, "Unsupported GZIP compression method"};
+    }
+
+    // http://www.gzip.org/zlib/rfc-gzip.html#header-trailer
+    stream->Seek(0L, aiOrigin_SET);
+    std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
+
+    size_t total = 0;
+    Compression compression;
+    auto uncompressed = std::make_shared<std::vector<char>>();
+    if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, 16 + Compression::MaxWBits)) {
+        total = compression.decompress((unsigned char *)reader->GetPtr(), reader->GetRemainingSize(), *uncompressed);
+        compression.close();
+    }
+
+    // replace the input stream with a memory stream
+    stream = std::make_shared<MemoryIOStream>(reinterpret_cast<uint8_t *>(uncompressed->data()), total);
+
+    // .. and retry
+    stream->Read(magic, 7, 1);
+    if (strcmp(magic, Token) == 0) {
+        return {stream, uncompressed, {}};
+    }
+    return {{}, {}, "Found no BLENDER magic word in decompressed GZIP file"};
+#endif
+}
+
 #endif // ASSIMP_BUILD_NO_BLEND_IMPORTER

code/AssetLib/Blender/BlenderLoader.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -105,7 +105,7 @@ class BlenderModifier;
  *  call it is outsourced to BlenderDNA.cpp/BlenderDNA.h. This class only performs the
  *  conversion from intermediate format to aiScene. */
 // -------------------------------------------------------------------------------------------
-class BlenderImporter : public BaseImporter, public LogFunctions<BlenderImporter> {
+class BlenderImporter final : public BaseImporter, public LogFunctions<BlenderImporter> {
 public:
     BlenderImporter();
     ~BlenderImporter() override;
@@ -180,6 +180,19 @@ private:
             const Blender::MTex *tex,
             Blender::ConversionData &conv_data);
 
+    // TODO: Move to a std::variant, once c++17 is supported.
+    struct StreamOrError {
+        std::shared_ptr<IOStream> stream;
+        std::shared_ptr<std::vector<char>> input;
+        std::string error;
+    };
+
+    // Returns either a stream (and optional input data for the stream) or
+    // an error if it can't parse the magic token.
+    StreamOrError ParseMagicToken(
+            const std::string &pFile,
+            IOSystem *pIOHandler) const;
+
 private: // static stuff, mostly logging and error reporting.
     // --------------------
     static void CheckActualType(const Blender::ElemBase *dt,

code/AssetLib/Blender/BlenderModifier.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -283,6 +282,11 @@ void BlenderModifier_Subdivision ::DoIt(aiNode &out, ConversionData &conv_data,
     if (conv_data.meshes->empty()) {
         return;
     }
+    const size_t meshIndex = conv_data.meshes->size() - out.mNumMeshes;
+    if (meshIndex >= conv_data.meshes->size()) {
+        ASSIMP_LOG_ERROR("Invalid index detected.");
+        return;
+    }
     aiMesh **const meshes = &conv_data.meshes[conv_data.meshes->size() - out.mNumMeshes];
     std::unique_ptr<aiMesh *[]> tempmeshes(new aiMesh *[out.mNumMeshes]());
 

code/AssetLib/Blender/BlenderModifier.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -62,9 +61,7 @@ public:
     /**
      *  The class destructor, virtual.
      */
-    virtual ~BlenderModifier() {
-        // empty
-    }
+    virtual ~BlenderModifier() = default;
 
     // --------------------
     /**
@@ -117,7 +114,7 @@ private:
  *  Mirror modifier. Status: implemented.
  */
 // -------------------------------------------------------------------------------------------
-class BlenderModifier_Mirror : public BlenderModifier {
+class BlenderModifier_Mirror final : public BlenderModifier {
 public:
     // --------------------
     virtual bool IsActive( const ModifierData& modin);
@@ -134,7 +131,7 @@ public:
 // -------------------------------------------------------------------------------------------
 /** Subdivision modifier. Status: dummy. */
 // -------------------------------------------------------------------------------------------
-class BlenderModifier_Subdivision : public BlenderModifier {
+class BlenderModifier_Subdivision final : public BlenderModifier {
 public:
 
     // --------------------

code/AssetLib/Blender/BlenderScene.cpp

@@ -102,10 +102,6 @@ void Structure::Convert<CollectionObject>(
 
     ReadFieldPtr<ErrorPolicy_Fail>(dest.next, "*next", db);
     {
-        //std::shared_ptr<CollectionObject> prev;
-        //ReadFieldPtr<ErrorPolicy_Fail>(prev, "*prev", db);
-        //dest.prev = prev.get();
-
         std::shared_ptr<Object> ob;
         ReadFieldPtr<ErrorPolicy_Igno>(ob, "*ob", db);
         dest.ob = ob.get();
@@ -301,7 +297,7 @@ void Structure ::Convert<Base>(
         const FileDatabase &db) const {
     // note: as per https://github.com/assimp/assimp/issues/128,
     // reading the Object linked list recursively is prone to stack overflow.
-    // This structure converter is therefore an hand-written exception that
+    // This structure converter is therefore a hand-written exception that
     // does it iteratively.
 
     const int initial_pos = db.reader->GetCurrentPos();
@@ -569,7 +565,7 @@ void Structure ::Convert<MVert>(
         const FileDatabase &db) const {
 
     ReadFieldArray<ErrorPolicy_Fail>(dest.co, "co", db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.no, "no", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.no, "no", db);
     ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
     //ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
     ReadField<ErrorPolicy_Igno>(dest.bweight, "bweight", db);

code/AssetLib/Blender/BlenderScene.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -48,8 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BlenderDNA.h"
 
-namespace Assimp {
-namespace Blender {
+namespace Assimp::Blender {
 
 // Minor parts of this file are extracts from blender data structures,
 // declared in the ./source/blender/makesdna directory.
@@ -116,32 +114,32 @@ struct Collection;
 static const size_t MaxNameLen = 1024;
 
 // -------------------------------------------------------------------------------
-struct ID : ElemBase {
+struct ID final : ElemBase {
     char name[MaxNameLen] WARN;
     short flag;
 };
 
 // -------------------------------------------------------------------------------
-struct ListBase : ElemBase {
+struct ListBase final : ElemBase {
     std::shared_ptr<ElemBase> first;
     std::weak_ptr<ElemBase> last;
 };
 
 // -------------------------------------------------------------------------------
-struct PackedFile : ElemBase {
+struct PackedFile final : ElemBase {
     int size WARN;
     int seek WARN;
     std::shared_ptr<FileOffset> data WARN;
 };
 
 // -------------------------------------------------------------------------------
-struct GroupObject : ElemBase {
+struct GroupObject final : ElemBase {
     std::shared_ptr<GroupObject> prev, next FAIL;
     std::shared_ptr<Object> ob;
 };
 
 // -------------------------------------------------------------------------------
-struct Group : ElemBase {
+struct Group final : ElemBase {
     ID id FAIL;
     int layer;
 
@@ -149,32 +147,32 @@ struct Group : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct CollectionObject : ElemBase {
+struct CollectionObject final : ElemBase {
     //CollectionObject* prev;
     std::shared_ptr<CollectionObject> next;
     Object *ob;
 };
 
 // -------------------------------------------------------------------------------
-struct CollectionChild : ElemBase {
+struct CollectionChild final : ElemBase {
     std::shared_ptr<CollectionChild> next, prev;
     std::shared_ptr<Collection> collection;
 };
 
 // -------------------------------------------------------------------------------
-struct Collection : ElemBase {
+struct Collection final : ElemBase {
     ID id FAIL;
     ListBase gobject; // CollectionObject
     ListBase children; // CollectionChild
 };
 
 // -------------------------------------------------------------------------------
-struct World : ElemBase {
+struct World final : ElemBase {
     ID id FAIL;
 };
 
 // -------------------------------------------------------------------------------
-struct MVert : ElemBase {
+struct MVert final : ElemBase {
     float co[3] FAIL;
     float no[3] FAIL; // read as short and divided through / 32767.f
     char flag;
@@ -182,35 +180,35 @@ struct MVert : ElemBase {
     int bweight;
 
     MVert() :
-            ElemBase(), flag(0), mat_nr(0), bweight(0) {}
+            flag(0), mat_nr(0), bweight(0) {}
 };
 
 // -------------------------------------------------------------------------------
-struct MEdge : ElemBase {
+struct MEdge final : ElemBase {
     int v1, v2 FAIL;
     char crease, bweight;
     short flag;
 };
 
 // -------------------------------------------------------------------------------
-struct MLoop : ElemBase {
+struct MLoop final : ElemBase {
     int v, e;
 };
 
 // -------------------------------------------------------------------------------
-struct MLoopUV : ElemBase {
+struct MLoopUV final : ElemBase {
     float uv[2];
     int flag;
 };
 
 // -------------------------------------------------------------------------------
 // Note that red and blue are not swapped, as with MCol
-struct MLoopCol : ElemBase {
+struct MLoopCol final : ElemBase {
     unsigned char r, g, b, a;
 };
 
 // -------------------------------------------------------------------------------
-struct MPoly : ElemBase {
+struct MPoly final : ElemBase {
     int loopstart;
     int totloop;
     short mat_nr;
@@ -218,26 +216,26 @@ struct MPoly : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct MTexPoly : ElemBase {
+struct MTexPoly final : ElemBase {
     Image *tpage;
     char flag, transp;
     short mode, tile, pad;
 };
 
 // -------------------------------------------------------------------------------
-struct MCol : ElemBase {
+struct MCol final : ElemBase {
     char r, g, b, a FAIL;
 };
 
 // -------------------------------------------------------------------------------
-struct MFace : ElemBase {
+struct MFace final : ElemBase {
     int v1, v2, v3, v4 FAIL;
     int mat_nr FAIL;
     char flag;
 };
 
 // -------------------------------------------------------------------------------
-struct TFace : ElemBase {
+struct TFace final : ElemBase {
     float uv[4][2] FAIL;
     int col[4] FAIL;
     char flag;
@@ -247,7 +245,7 @@ struct TFace : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct MTFace : ElemBase {
+struct MTFace final : ElemBase {
     MTFace() :
             flag(0),
             mode(0),
@@ -265,24 +263,24 @@ struct MTFace : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct MDeformWeight : ElemBase {
+struct MDeformWeight final : ElemBase {
     int def_nr FAIL;
     float weight FAIL;
 };
 
 // -------------------------------------------------------------------------------
-struct MDeformVert : ElemBase {
+struct MDeformVert final : ElemBase {
     vector<MDeformWeight> dw WARN;
     int totweight;
 };
 
 // -------------------------------------------------------------------------------
-#define MA_RAYMIRROR 0x40000
-#define MA_TRANSPARENCY 0x10000
-#define MA_RAYTRANSP 0x20000
-#define MA_ZTRANSP 0x00040
+constexpr uint32_t MA_RAYMIRROR    = 0x40000;
+constexpr uint32_t MA_TRANSPARENCY = 0x10000;
+constexpr uint32_t MA_RAYTRANSP    = 0x20000;
+constexpr uint32_t MA_ZTRANSP      = 0x00040;
 
-struct Material : ElemBase {
+struct Material final : ElemBase {
     ID id FAIL;
 
     float r, g, b WARN;
@@ -404,7 +402,7 @@ CustomDataLayer 104
     char name 32 64
     void *data 96 8
 */
-struct CustomDataLayer : ElemBase {
+struct CustomDataLayer final : ElemBase {
     int type;
     int offset;
     int flag;
@@ -417,7 +415,6 @@ struct CustomDataLayer : ElemBase {
     std::shared_ptr<ElemBase> data; // must be converted to real type according type member
 
     CustomDataLayer() :
-            ElemBase(),
             type(0),
             offset(0),
             flag(0),
@@ -443,7 +440,7 @@ CustomData 208
     BLI_mempool *pool 192 8
     CustomDataExternal *external 200 8
 */
-struct CustomData : ElemBase {
+struct CustomData final : ElemBase {
     vector<std::shared_ptr<struct CustomDataLayer>> layers;
     int typemap[42]; // CD_NUMTYPES
     int totlayer;
@@ -456,7 +453,7 @@ struct CustomData : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct Mesh : ElemBase {
+struct Mesh final : ElemBase {
     ID id FAIL;
 
     int totface FAIL;
@@ -493,7 +490,7 @@ struct Mesh : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct Library : ElemBase {
+struct Library final : ElemBase {
     ID id FAIL;
 
     char name[240] WARN;
@@ -517,7 +514,7 @@ struct Camera : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct Lamp : ElemBase {
+struct Lamp final : ElemBase {
 
     enum FalloffType {
         FalloffType_Constant = 0x0,
@@ -604,7 +601,7 @@ struct Lamp : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct ModifierData : ElemBase {
+struct ModifierData final : ElemBase {
     enum ModifierType {
         eModifierType_None = 0,
         eModifierType_Subsurf,
@@ -654,9 +651,8 @@ struct SharedModifierData : ElemBase {
     ModifierData modifier;
 };
 
-
 // -------------------------------------------------------------------------------
-struct SubsurfModifierData : SharedModifierData {
+struct SubsurfModifierData final : SharedModifierData {
 
     enum Type {
 
@@ -676,7 +672,7 @@ struct SubsurfModifierData : SharedModifierData {
 };
 
 // -------------------------------------------------------------------------------
-struct MirrorModifierData : SharedModifierData {
+struct MirrorModifierData final : SharedModifierData {
 
     enum Flags {
         Flags_CLIPPING = 1 << 0,
@@ -694,7 +690,7 @@ struct MirrorModifierData : SharedModifierData {
 };
 
 // -------------------------------------------------------------------------------
-struct Object : ElemBase {
+struct Object final : ElemBase {
     ID id FAIL;
 
     enum Type {
@@ -729,26 +725,25 @@ struct Object : ElemBase {
     ListBase modifiers;
 
     Object() :
-            ElemBase(), type(Type_EMPTY), parent(nullptr), track(), proxy(), proxy_from(), data() {
+            type(Type_EMPTY), parent(nullptr) {
         // empty
     }
 };
 
 // -------------------------------------------------------------------------------
-struct Base : ElemBase {
+struct Base final : ElemBase {
     Base *prev WARN;
     std::shared_ptr<Base> next WARN;
     std::shared_ptr<Object> object WARN;
 
     Base() :
-            ElemBase(), prev(nullptr), next(), object() {
-        // empty
+            prev(nullptr) {
         // empty
     }
 };
 
 // -------------------------------------------------------------------------------
-struct Scene : ElemBase {
+struct Scene final : ElemBase {
     ID id FAIL;
 
     std::shared_ptr<Object> camera WARN;
@@ -758,14 +753,11 @@ struct Scene : ElemBase {
 
     ListBase base;
 
-    Scene() :
-            ElemBase(), camera(), world(), basact(), master_collection() {
-        // empty
-    }
+    Scene() = default;
 };
 
 // -------------------------------------------------------------------------------
-struct Image : ElemBase {
+struct Image final : ElemBase {
     ID id FAIL;
 
     char name[240] WARN;
@@ -791,14 +783,11 @@ struct Image : ElemBase {
 
     short gen_x, gen_y, gen_type;
 
-    Image() :
-            ElemBase() {
-        // empty
-    }
+    Image() = default;
 };
 
 // -------------------------------------------------------------------------------
-struct Tex : ElemBase {
+struct Tex final : ElemBase {
 
     // actually, the only texture type we support is Type_IMAGE
     enum Type {
@@ -883,14 +872,13 @@ struct Tex : ElemBase {
 
     //char use_nodes;
 
-    Tex() :
-            ElemBase(), imaflag(ImageFlags_INTERPOL), type(Type_CLOUDS), ima() {
+    Tex() : imaflag(ImageFlags_INTERPOL), type(Type_CLOUDS) {
         // empty
     }
 };
 
 // -------------------------------------------------------------------------------
-struct MTex : ElemBase {
+struct MTex final : ElemBase {
 
     enum Projection {
         Proj_N = 0,
@@ -976,12 +964,9 @@ struct MTex : ElemBase {
     //float shadowfac;
     //float zenupfac, zendownfac, blendfac;
 
-    MTex() :
-            ElemBase() {
-        // empty
-    }
+    MTex() = default;
 };
 
-} // namespace Blender
-} // namespace Assimp
+} // namespace Assimp::Blender
+
 #endif

code/AssetLib/Blender/BlenderSceneGen.h

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderDNA.h"
 #include "BlenderScene.h"
 
-namespace Assimp    {
+namespace Assimp {
 namespace Blender {
 
 template <> void Structure :: Convert<Object> (

code/AssetLib/Blender/BlenderTessellator.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -40,10 +39,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file  BlenderTessellator.cpp
- *  @brief A simple tessellation wrapper
- */
-
+/// @file  BlenderTessellator.cpp
+/// @brief A simple tessellation wrapper
 
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 
@@ -62,8 +59,7 @@ namspace Assimp
 {
     template< > const char* LogFunctions< BlenderTessellatorGL >::Prefix()
     {
-        static auto prefix = "BLEND_TESS_GL: ";
-        return prefix;
+        return "BLEND_TESS_GL: ";
     }
 }
 
@@ -81,9 +77,7 @@ BlenderTessellatorGL::BlenderTessellatorGL( BlenderBMeshConverter& converter ):
 }
 
 // ------------------------------------------------------------------------------------------------
-BlenderTessellatorGL::~BlenderTessellatorGL( )
-{
-}
+BlenderTessellatorGL::~BlenderTessellatorGL() = default;
 
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorGL::Tessellate( const MLoop* polyLoop, int vertexCount, const std::vector< MVert >& vertices )
@@ -259,8 +253,7 @@ namespace Assimp
 {
     template< > const char* LogFunctions< BlenderTessellatorP2T >::Prefix()
     {
-        static auto prefix = "BLEND_TESS_P2T: ";
-        return prefix;
+        return "BLEND_TESS_P2T: ";
     }
 }
 
@@ -388,7 +381,14 @@ inline PointP2T& BlenderTessellatorP2T::GetActualPointStructure( p2t::Point& poi
 #    pragma clang diagnostic push
 #    pragma clang diagnostic ignored "-Winvalid-offsetof"
 #endif // __clang__
+#if defined __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Winvalid-offsetof"
+#endif // __GNUC__
     unsigned int pointOffset = offsetof( PointP2T, point2D );
+#if defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif // __GNUC__
 #if defined __clang__
 #    pragma clang diagnostic pop
 #endif

code/AssetLib/Blender/BlenderTessellator.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -144,11 +143,7 @@ namespace Assimp
 
 #if ASSIMP_BLEND_WITH_POLY_2_TRI
 
-#ifdef ASSIMP_USE_HUNTER
-#  include <poly2tri/poly2tri.h>
-#else
-#  include "../contrib/poly2tri/poly2tri/poly2tri.h"
-#endif
+#include "contrib/poly2tri/poly2tri/poly2tri.h"
 
 namespace Assimp
 {

code/AssetLib/C4D/C4DImporter.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2025, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -46,10 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // no #ifdefing here, Cinema4D support is carried out in a branch of assimp
 // where it is turned on in the CMake settings.
 
-#ifndef _MSC_VER
-#   error C4D support is currently MSVC only
-#endif
-
 #include "C4DImporter.h"
 #include <memory>
 #include <assimp/IOSystem.hpp>
@@ -68,7 +64,7 @@ namespace {
 
 aiString aiStringFrom(cineware::String const & cinestring) {
     aiString result;
-    cinestring.GetCString(result.data, MAXLEN-1);
+    cinestring.GetCString(result.data, AI_MAXLEN - 1);
     result.length = static_cast<ai_uint32>(cinestring.GetLength());
     return result;
 }
@@ -86,12 +82,11 @@ void GetWriterInfo(int &id, String &appname) {
 
 namespace Assimp {
     template<> const char* LogFunctions<C4DImporter>::Prefix() {
-        static auto prefix = "C4D: ";
-        return prefix;
+        return "C4D: ";
     }
 }
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "Cinema4D Importer",
     "",
     "",
@@ -104,27 +99,15 @@ static const aiImporterDesc desc = {
     "c4d"
 };
 
-
 // ------------------------------------------------------------------------------------------------
-C4DImporter::C4DImporter()
-: BaseImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-C4DImporter::~C4DImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-bool C4DImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const {
+bool C4DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
     const std::string& extension = GetExtension(pFile);
     if (extension == "c4d") {
         return true;
     } else if ((!extension.length() || checkSig) && pIOHandler)   {
         // TODO
     }
-    
+
     return false;
 }
 
@@ -206,7 +189,6 @@ void C4DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     std::copy(materials.begin(), materials.end(), pScene->mMaterials);
 }
 
-
 // ------------------------------------------------------------------------------------------------
 bool C4DImporter::ReadShader(aiMaterial* out, BaseShader* shader) {
     // based on Cineware sample code (C4DImportExport.cpp)
@@ -311,7 +293,7 @@ void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) {
 
     // based on Cineware sample code
     while (object) {
-        const LONG type = object->GetType();
+        const Int32 type = object->GetType();
         const Matrix& ml = object->GetMl();
 
         aiNode* const nd = new aiNode();
@@ -374,8 +356,8 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) {
     PolygonObject* const polyObject = dynamic_cast<PolygonObject*>(object);
     ai_assert(polyObject != nullptr);
 
-    const LONG pointCount = polyObject->GetPointCount();
-    const LONG polyCount = polyObject->GetPolygonCount();
+    const Int32 pointCount = polyObject->GetPointCount();
+    const Int32 polyCount = polyObject->GetPolygonCount();
     if(!polyObject || !pointCount) {
         LogWarn("ignoring mesh with zero vertices or faces");
         return nullptr;
@@ -397,7 +379,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) {
     unsigned int vcount = 0;
 
     // first count vertices
-    for (LONG i = 0; i < polyCount; i++)
+    for (Int32 i = 0; i < polyCount; i++)
     {
         vcount += 3;
 
@@ -440,7 +422,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) {
     }
 
     // copy vertices and extra channels over and populate faces
-    for (LONG i = 0; i < polyCount; ++i, ++face) {
+    for (Int32 i = 0; i < polyCount; ++i, ++face) {
         ai_assert(polys[i].a < pointCount && polys[i].a >= 0);
         const Vector& pointA = points[polys[i].a];
         verts->x = pointA.x;
@@ -517,7 +499,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) {
         if (tangents_src) {
 
             for(unsigned int k = 0; k < face->mNumIndices; ++k) {
-                LONG l;
+                Int32 l;
                 switch(k) {
                 case 0:
                     l = polys[i].a;

code/AssetLib/C4D/C4DImporter.h

@@ -63,7 +63,7 @@ namespace cineware {
     class BaseShader;
 }
 
-namespace Assimp  {
+namespace Assimp {
     // TinyFormatter.h
     namespace Formatter {
         template <typename T,typename TR, typename A> class basic_formatter;
@@ -78,6 +78,8 @@ namespace Assimp  {
 // -------------------------------------------------------------------------------------------
 class C4DImporter : public BaseImporter, public LogFunctions<C4DImporter> {
 public:
+    C4DImporter() = default;
+    ~C4DImporter() override = default;
     bool CanRead( const std::string& pFile, IOSystem*, bool checkSig) const override;
 
 protected:

code/AssetLib/COB/COBLoader.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -45,8 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_COB_IMPORTER
 
-#include "AssetLib/COB/COBLoader.h"
-#include "AssetLib/COB/COBScene.h"
+#include "COBLoader.h"
+#include "COBScene.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/LineSplitter.h>
@@ -61,11 +61,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <memory>
 
-using namespace Assimp;
+namespace Assimp {
+
 using namespace Assimp::COB;
 using namespace Assimp::Formatter;
 
-static const float units[] = {
+static constexpr float units[] = {
     1000.f,
     100.f,
     1.f,
@@ -76,7 +77,7 @@ static const float units[] = {
     1.f / 1609.344f
 };
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "TrueSpace Object Importer",
     "",
     "",
@@ -89,14 +90,6 @@ static const aiImporterDesc desc = {
     "cob scn"
 };
 
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-COBImporter::COBImporter() = default;
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-COBImporter::~COBImporter() = default;
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
@@ -117,10 +110,29 @@ void COBImporter::SetupProperties(const Importer * /*pImp*/) {
 }
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string &msg) {
+AI_WONT_RETURN void COBImporter::ThrowException(const std::string &msg) {
     throw DeadlyImportError("COB: ", msg);
 }
 
+// ------------------------------------------------------------------------------------------------
+static bool isValidASCIIHeader(const char *head) {
+    ai_assert(head != nullptr);
+
+    if (strncmp(head, "Caligari ", 9) != 0) {
+        COBImporter::ThrowException("Could not found magic id: `Caligari`");
+    }
+
+    if (strncmp(&head[9], "V00.", 4) != 0) {
+        COBImporter::ThrowException("Could not found Version tag: `V00.`");
+    }
+    ASSIMP_LOG_INFO("File format tag: ", std::string(head + 9, 6));
+    if (head[16] != 'L') {
+        COBImporter::ThrowException("File is big-endian, which is not supported");
+    }
+
+    return true;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
@@ -134,19 +146,15 @@ void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
     std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE(file));
 
     // check header
-    char head[32];
-    stream->CopyAndAdvance(head, 32);
-    if (strncmp(head, "Caligari ", 9) != 0) {
-        ThrowException("Could not found magic id: `Caligari`");
-    }
-
-    ASSIMP_LOG_INFO("File format tag: ", std::string(head + 9, 6));
-    if (head[16] != 'L') {
-        ThrowException("File is big-endian, which is not supported");
-    }
+    static constexpr size_t HeaderSize = 32u;
+    char head[HeaderSize] = {};
+    stream->CopyAndAdvance(head, HeaderSize);
 
     // load data into intermediate structures
     if (head[15] == 'A') {
+        if (!isValidASCIIHeader(head)) {
+            ThrowException("Invalid ASCII file header");
+        }
         ReadAsciiFile(scene, stream.get());
     } else {
         ReadBinaryFile(scene, stream.get());
@@ -158,7 +166,7 @@ void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
     // sort faces by material indices
     for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
-            Mesh &mesh = (Mesh &)(*n.get());
+            Mesh &mesh = (Mesh &)(*n);
             for (Face &f : mesh.faces) {
                 mesh.temp_map[f.material].push_back(&f);
             }
@@ -168,7 +176,7 @@ void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
     // count meshes
     for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
-            Mesh &mesh = (Mesh &)(*n.get());
+            Mesh &mesh = (Mesh &)(*n);
             if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
                 pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size());
             }
@@ -211,7 +219,7 @@ void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
         }
     }
 
-    pScene->mRootNode = BuildNodes(*root.get(), scene, pScene);
+    pScene->mRootNode = BuildNodes(*root, scene, pScene);
     //flip normals after import
     FlipWindingOrderProcess flip;
     flip.Execute(pScene);
@@ -236,7 +244,7 @@ aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fi
         const Mesh &ndmesh = (const Mesh &)(root);
         if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) {
 
-            typedef std::pair<const unsigned int, Mesh::FaceRefList> Entry;
+            using Entry = std::pair<const unsigned int, Mesh::FaceRefList>;
             for (const Entry &reflist : ndmesh.temp_map) {
                 { // create mesh
                     size_t n = 0;
@@ -380,9 +388,11 @@ aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fi
     }
 
     // add children recursively
-    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;
+    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;
@@ -481,8 +491,9 @@ void COBImporter::ReadBasicNodeInfo_Ascii(Node &msh, LineSplitter &splitter, con
         } else if (splitter.match_start("Transform")) {
             for (unsigned int y = 0; y < 4 && ++splitter; ++y) {
                 const char *s = splitter->c_str();
+                const char *end = s + splitter->size();
                 for (unsigned int x = 0; x < 4; ++x) {
-                    SkipSpaces(&s);
+                    SkipSpaces(&s, end);
                     msh.transform[y][x] = fast_atof(&s);
                 }
             }
@@ -494,12 +505,12 @@ void COBImporter::ReadBasicNodeInfo_Ascii(Node &msh, LineSplitter &splitter, con
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-void COBImporter::ReadFloat3Tuple_Ascii(T &fill, const char **in) {
+void COBImporter::ReadFloat3Tuple_Ascii(T &fill, const char **in, const char *end) {
     const char *rgb = *in;
     for (unsigned int i = 0; i < 3; ++i) {
-        SkipSpaces(&rgb);
+        SkipSpaces(&rgb, end);
         if (*rgb == ',') ++rgb;
-        SkipSpaces(&rgb);
+        SkipSpaces(&rgb, end);
 
         fill[i] = fast_atof(&rgb);
     }
@@ -546,7 +557,7 @@ void COBImporter::ReadMat1_Ascii(Scene &out, LineSplitter &splitter, const Chunk
     }
 
     const char *rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(mat.rgb, &rgb);
+    ReadFloat3Tuple_Ascii(mat.rgb, &rgb, splitter.getEnd());
 
     ++splitter;
     if (!splitter.match_start("alpha ")) {
@@ -625,20 +636,21 @@ void COBImporter::ReadLght_Ascii(Scene &out, LineSplitter &splitter, const Chunk
     }
 
     const char *rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(msh.color, &rgb);
+    const char *end = splitter.getEnd();
+    ReadFloat3Tuple_Ascii(msh.color, &rgb, end);
 
-    SkipSpaces(&rgb);
+    SkipSpaces(&rgb, end);
     if (strncmp(rgb, "cone angle", 10) != 0) {
         ASSIMP_LOG_WARN("Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id);
     }
-    SkipSpaces(rgb + 10, &rgb);
+    SkipSpaces(rgb + 10, &rgb, end);
     msh.angle = fast_atof(&rgb);
 
-    SkipSpaces(&rgb);
+    SkipSpaces(&rgb, end);
     if (strncmp(rgb, "inner angle", 11) != 0) {
         ASSIMP_LOG_WARN("Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
     }
-    SkipSpaces(rgb + 11, &rgb);
+    SkipSpaces(rgb + 11, &rgb, end);
     msh.inner_angle = fast_atof(&rgb);
 
     // skip the rest for we can't handle this kind of physically-based lighting information.
@@ -711,14 +723,14 @@ void COBImporter::ReadPolH_Ascii(Scene &out, LineSplitter &splitter, const Chunk
 
             for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
                 const char *s = splitter->c_str();
-
+                const char *end = splitter.getEnd();
                 aiVector3D &v = msh.vertex_positions[cur];
 
-                SkipSpaces(&s);
+                SkipSpaces(&s, end);
                 v.x = fast_atof(&s);
-                SkipSpaces(&s);
+                SkipSpaces(&s, end);
                 v.y = fast_atof(&s);
-                SkipSpaces(&s);
+                SkipSpaces(&s, end);
                 v.z = fast_atof(&s);
             }
         } else if (splitter.match_start("Texture Vertices")) {
@@ -727,12 +739,13 @@ void COBImporter::ReadPolH_Ascii(Scene &out, LineSplitter &splitter, const Chunk
 
             for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
                 const char *s = splitter->c_str();
+                const char *end = splitter.getEnd();
 
                 aiVector2D &v = msh.texture_coords[cur];
 
-                SkipSpaces(&s);
+                SkipSpaces(&s, end);
                 v.x = fast_atof(&s);
-                SkipSpaces(&s);
+                SkipSpaces(&s, end);
                 v.y = fast_atof(&s);
             }
         } else if (splitter.match_start("Faces")) {
@@ -757,8 +770,9 @@ void COBImporter::ReadPolH_Ascii(Scene &out, LineSplitter &splitter, const Chunk
                 face.material = strtoul10(splitter[6]);
 
                 const char *s = (++splitter)->c_str();
+                const char *end = splitter.getEnd();
                 for (size_t i = 0; i < face.indices.size(); ++i) {
-                    if (!SkipSpaces(&s)) {
+                    if (!SkipSpaces(&s, end)) {
                         ThrowException("Expected EOL token in Face entry");
                     }
                     if ('<' != *s++) {
@@ -868,7 +882,7 @@ void COBImporter::ReadBinaryFile(Scene &out, StreamReaderLE *reader) {
         return;
     }
 
-    while (1) {
+    while (true) {
         std::string type;
         type += reader->GetI1();
         type += reader->GetI1();
@@ -1054,7 +1068,7 @@ void COBImporter::ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const
     id[0] = reader.GetI1(), id[1] = reader.GetI1();
 
     if (id[0] == 'e' && id[1] == ':') {
-        mat.tex_env.reset(new Texture());
+        mat.tex_env = std::make_shared<Texture>();
 
         reader.GetI1();
         ReadString_Binary(mat.tex_env->path, reader);
@@ -1064,7 +1078,7 @@ void COBImporter::ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const
     }
 
     if (id[0] == 't' && id[1] == ':') {
-        mat.tex_color.reset(new Texture());
+        mat.tex_color = std::make_shared<Texture>();
 
         reader.GetI1();
         ReadString_Binary(mat.tex_color->path, reader);
@@ -1080,7 +1094,7 @@ void COBImporter::ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const
     }
 
     if (id[0] == 'b' && id[1] == ':') {
-        mat.tex_bump.reset(new Texture());
+        mat.tex_bump = std::make_shared<Texture>();
 
         reader.GetI1();
         ReadString_Binary(mat.tex_bump->path, reader);
@@ -1172,4 +1186,6 @@ void COBImporter::ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const
     ASSIMP_LOG_WARN("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
 }
 
+} // namespace Assimp
+
 #endif // ASSIMP_BUILD_NO_COB_IMPORTER

code/AssetLib/COB/COBLoader.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -56,16 +55,16 @@ class LineSplitter;
 
 // TinyFormatter.h
 namespace Formatter {
-template <typename T, typename TR, typename A>
-class basic_formatter;
-typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
+    template <typename T, typename TR, typename A>
+    class basic_formatter;
+    typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
 } // namespace Formatter
 
 // COBScene.h
 namespace COB {
-struct ChunkInfo;
-struct Node;
-struct Scene;
+    struct ChunkInfo;
+    struct Node;
+    struct Scene;
 } // namespace COB
 
 // -------------------------------------------------------------------------------------------
@@ -73,15 +72,19 @@ struct Scene;
  *
  *  Currently relatively limited, loads only ASCII files and needs more test coverage. */
 // -------------------------------------------------------------------------------------------
-class COBImporter : public BaseImporter {
+class COBImporter final : public BaseImporter {
 public:
-    COBImporter();
-    ~COBImporter() override;
+    COBImporter() = default;
+    ~COBImporter() override = default;
 
     // --------------------
     bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
             bool checkSig) const override;
 
+    // -------------------------------------------------------------------
+    /** Prepend 'COB: ' and throw msg.*/
+    AI_WONT_RETURN static void ThrowException(const std::string &msg) AI_WONT_RETURN_SUFFIX;
+
 protected:
     // --------------------
     const aiImporterDesc *GetInfo() const override;
@@ -94,10 +97,6 @@ protected:
             IOSystem *pIOHandler) override;
 
 private:
-    // -------------------------------------------------------------------
-    /** Prepend 'COB: ' and throw msg.*/
-    AI_WONT_RETURN static void ThrowException(const std::string &msg) AI_WONT_RETURN_SUFFIX;
-
     // -------------------------------------------------------------------
     /** @brief Read from an ascii scene/object file
      *  @param out Receives output data.
@@ -120,7 +119,7 @@ private:
     void ReadChunkInfo_Ascii(COB::ChunkInfo &out, const LineSplitter &splitter);
     void ReadBasicNodeInfo_Ascii(COB::Node &msh, LineSplitter &splitter, const COB::ChunkInfo &nfo);
     template <typename T>
-    void ReadFloat3Tuple_Ascii(T &fill, const char **in);
+    void ReadFloat3Tuple_Ascii(T &fill, const char **in, const char *end);
 
     void ReadPolH_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
     void ReadBitM_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
@@ -149,4 +148,5 @@ private:
 }; // !class COBImporter
 
 } // end of namespace Assimp
+
 #endif // AI_UNREALIMPORTER_H_INC

code/AssetLib/COB/COBScene.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -52,68 +52,66 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <deque>
 #include <map>
 
-namespace Assimp {
-namespace COB {
+namespace Assimp::COB {
 
 // ------------------
 /** Represents a single vertex index in a face */
-struct VertexIndex
-{
+struct VertexIndex {
     // intentionally uninitialized
     unsigned int pos_idx,uv_idx;
 };
 
 // ------------------
 /** COB Face data structure */
-struct Face
-{
+struct Face {
     // intentionally uninitialized
-    unsigned int material, flags;
+    unsigned int material;
+    unsigned int flags;
     std::vector<VertexIndex> indices;
 };
 
 // ------------------
 /** COB chunk header information */
-const unsigned int NO_SIZE = UINT_MAX;
+constexpr unsigned int NO_SIZE = UINT_MAX;
 
-struct ChunkInfo
-{
-    ChunkInfo ()
-        :   id        (0)
-        ,   parent_id (0)
-        ,   version   (0)
-        ,   size      (NO_SIZE)
-    {}
+struct ChunkInfo {
+    ChunkInfo() = default;
+    virtual ~ChunkInfo() = default;
 
     // Id of this chunk, unique within file
-    unsigned int id;
+    unsigned int id{ 0 };
 
     // and the corresponding parent
-    unsigned int parent_id;
+    unsigned int parent_id{ 0 };
 
     // version. v1.23 becomes 123
-    unsigned int version;
+    unsigned int version{ 0 };
 
     // chunk size in bytes, only relevant for binary files
     // NO_SIZE is also valid.
-    unsigned int size;
+    unsigned int size{NO_SIZE};
 };
 
 // ------------------
 /** A node in the scenegraph */
-struct Node : public ChunkInfo
-{
+struct Node : ChunkInfo {
     enum Type {
-        TYPE_MESH,TYPE_GROUP,TYPE_LIGHT,TYPE_CAMERA,TYPE_BONE
+        TYPE_INVALID = -1,
+        TYPE_MESH = 0,
+        TYPE_GROUP,
+        TYPE_LIGHT,
+        TYPE_CAMERA,
+        TYPE_BONE,
+        TYPE_COUNT
     };
 
-    virtual ~Node() = default;
-    Node(Type type) : type(type), unit_scale(1.f){}
+    ~Node() override = default;
+    explicit Node(Type type) : type(type), unit_scale(1.f){}
 
     Type type;
 
     // used during resolving
-    typedef std::deque<const Node*> ChildList;
+    using ChildList = std::deque<const Node*> ;
     mutable ChildList temp_children;
 
     // unique name
@@ -128,8 +126,7 @@ struct Node : public ChunkInfo
 
 // ------------------
 /** COB Mesh data structure */
-struct Mesh : public Node
-{
+struct Mesh final : Node {
     using ChunkInfo::operator=;
     enum DrawFlags {
         SOLID = 0x1,
@@ -162,107 +159,118 @@ struct Mesh : public Node
 
 // ------------------
 /** COB Group data structure */
-struct Group : public Node
-{
+struct Group final : Node {
     using ChunkInfo::operator=;
-    Group() : Node(TYPE_GROUP) {}
+    
+    Group() : Node(TYPE_GROUP) {
+        // empty
+    }
 };
 
 // ------------------
 /** COB Bone data structure */
-struct Bone : public Node
-{
+struct Bone final : Node {
     using ChunkInfo::operator=;
-    Bone() : Node(TYPE_BONE) {}
+    
+    Bone() : Node(TYPE_BONE) {
+        // empty
+    }
 };
 
 // ------------------
 /** COB Light data structure */
-struct Light : public Node
-{
+struct Light final : Node {
     enum LightType {
-        SPOT,LOCAL,INFINITE
+        SPOT,
+        LOCAL,
+        INFINITE
     };
 
     using ChunkInfo::operator=;
-    Light() : Node(TYPE_LIGHT),angle(),inner_angle(),ltype(SPOT) {}
+
+    Light() : Node(TYPE_LIGHT), ltype() {
+        // empty
+    }
 
     aiColor3D color;
-    float angle,inner_angle;
+    float angle{ 0.0f };
+    float inner_angle{ 0.0f };
 
-    LightType ltype;
+    LightType ltype{SPOT};
 };
 
 // ------------------
 /** COB Camera data structure */
-struct Camera : public Node
-{
+struct Camera final : Node {
     using ChunkInfo::operator=;
-    Camera() : Node(TYPE_CAMERA) {}
+
+    Camera() : Node(TYPE_CAMERA) {
+        // empty
+    }
 };
 
 // ------------------
 /** COB Texture data structure */
-struct Texture
-{
+struct Texture {
     std::string path;
     aiUVTransform transform;
 };
 
 // ------------------
 /** COB Material data structure */
-struct Material : ChunkInfo
-{
+struct Material : ChunkInfo {
     using ChunkInfo::operator=;
+
     enum Shader {
-        FLAT,PHONG,METAL
+        FLAT,
+        PHONG,
+        METAL
     };
 
     enum AutoFacet {
-        FACETED,AUTOFACETED,SMOOTH
+        FACETED,
+        AUTOFACETED,
+        SMOOTH
     };
 
-    Material() : alpha(),exp(),ior(),ka(),ks(1.f),
-        matnum(UINT_MAX),
-        shader(FLAT),autofacet(FACETED),
-        autofacet_angle()
-    {}
+    Material() : shader(FLAT) {
+        // empty
+    }
 
     std::string type;
-
     aiColor3D rgb;
-    float alpha, exp, ior,ka,ks;
-
-    unsigned int matnum;
+    float alpha{ 0.0f };
+    float exp{ 0.0f };
+    float ior{ 0.0f };
+    float ka{ 0.0f };
+    float ks{ 1.0f };
+    unsigned int matnum{ UINT_MAX };
     Shader shader;
-
-    AutoFacet autofacet;
-    float autofacet_angle;
-
+    AutoFacet autofacet{FACETED};
+    float autofacet_angle{ 0.0f };
     std::shared_ptr<Texture> tex_env,tex_bump,tex_color;
 };
 
 // ------------------
 /** Embedded bitmap, for instance for the thumbnail image */
-struct Bitmap : ChunkInfo
-{
-    Bitmap() : orig_size() {}
-    struct BitmapHeader
-    {
+struct Bitmap : ChunkInfo {
+    Bitmap() = default;
+
+    struct BitmapHeader {
+        // empty
     };
 
     BitmapHeader head;
-    size_t orig_size;
+    size_t orig_size{ 0u };
     std::vector<char> buff_zipped;
 };
 
-typedef std::deque< std::shared_ptr<Node> > NodeList;
-typedef std::vector< Material > MaterialList;
+using NodeList      = std::deque< std::shared_ptr<Node>>;
+using MaterialList = std::vector< Material >;
 
 // ------------------
 /** Represents a master COB scene, even if we loaded just a single COB file */
-struct Scene
-{
+struct Scene {
     NodeList nodes;
     MaterialList materials;
 
@@ -270,7 +278,6 @@ struct Scene
     Bitmap thumbnail;
 };
 
-    } // end COB
-} // end Assimp
+} // end Assimp::COB
 
-#endif
+#endif // INCLUDED_AI_COB_SCENE_H

code/AssetLib/CSM/CSMLoader.cpp

@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -44,9 +42,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  CSMLoader.cpp
  *  Implementation of the CSM importer class.
  */
-
-
-
 #ifndef ASSIMP_BUILD_NO_CSM_IMPORTER
 
 #include "CSMLoader.h"
@@ -63,7 +58,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "CharacterStudio Motion Importer (MoCap)",
     "",
     "",
@@ -76,48 +71,39 @@ static const aiImporterDesc desc = {
     "csm"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-CSMImporter::CSMImporter()
-: noSkeletonMesh()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-CSMImporter::~CSMImporter() = default;
+CSMImporter::CSMImporter() : noSkeletonMesh() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool CSMImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
-{
+bool CSMImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const {
     static const char* tokens[] = {"$Filename"};
     return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* CSMImporter::GetInfo () const
-{
+const aiImporterDesc* CSMImporter::GetInfo () const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void CSMImporter::SetupProperties(const Importer* pImp)
-{
+void CSMImporter::SetupProperties(const Importer* pImp) {
     noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void CSMImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
+        aiScene* pScene, IOSystem* pIOHandler) {
     std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == nullptr) {
+    if (file == nullptr) {
         throw DeadlyImportError( "Failed to open CSM file ", pFile, ".");
     }
 
@@ -125,80 +111,92 @@ void CSMImporter::InternReadFile( const std::string& pFile,
     std::vector<char> mBuffer2;
     TextFileToBuffer(file.get(),mBuffer2);
     const char* buffer = &mBuffer2[0];
-
+    const char *end = &mBuffer2[mBuffer2.size() - 1] + 1;
     std::unique_ptr<aiAnimation> anim(new aiAnimation());
     int first = 0, last = 0x00ffffff;
 
     // now process the file and look out for '$' sections
-    while (1)   {
-        SkipSpaces(&buffer);
-        if ('\0' == *buffer)
+    while (true) {
+        SkipSpaces(&buffer, end);
+        if ('\0' == *buffer) {
             break;
+        }
 
-        if ('$'  == *buffer)    {
+        if ('$'  == *buffer) {
             ++buffer;
-            if (TokenMatchI(buffer,"firstframe",10))    {
-                SkipSpaces(&buffer);
+            if (TokenMatchI(buffer,"firstframe",10)) {
+                SkipSpaces(&buffer, end);
                 first = strtol10(buffer,&buffer);
             }
-            else if (TokenMatchI(buffer,"lastframe",9))     {
-                SkipSpaces(&buffer);
+            else if (TokenMatchI(buffer,"lastframe",9)) {
+                SkipSpaces(&buffer, end);
                 last = strtol10(buffer,&buffer);
             }
             else if (TokenMatchI(buffer,"rate",4))  {
-                SkipSpaces(&buffer);
-                float d;
-                buffer = fast_atoreal_move<float>(buffer,d);
+                SkipSpaces(&buffer, end);
+                float d = { 0.0f };
+                buffer = fast_atoreal_move(buffer,d);
                 anim->mTicksPerSecond = d;
             }
             else if (TokenMatchI(buffer,"order",5)) {
                 std::vector< aiNodeAnim* > anims_temp;
                 anims_temp.reserve(30);
-                while (1)   {
-                    SkipSpaces(&buffer);
-                    if (IsLineEnd(*buffer) && SkipSpacesAndLineEnd(&buffer) && *buffer == '$')
+                while (true) {
+                    SkipSpaces(&buffer, end);
+                    if (IsLineEnd(*buffer) && SkipSpacesAndLineEnd(&buffer, end) && *buffer == '$')
                         break; // next section
 
                     // Construct a new node animation channel and setup its name
                     anims_temp.push_back(new aiNodeAnim());
                     aiNodeAnim* nda = anims_temp.back();
 
-                    char* ot = nda->mNodeName.data;
-                    while (!IsSpaceOrNewLine(*buffer))
+                    char *ot = nda->mNodeName.data;
+                    const char *ot_end = nda->mNodeName.data + AI_MAXLEN;
+                    while (!IsSpaceOrNewLine(*buffer) && buffer != end && ot != ot_end) {
                         *ot++ = *buffer++;
+                    }
 
                     *ot = '\0';
                     nda->mNodeName.length = static_cast<ai_uint32>(ot-nda->mNodeName.data);
                 }
 
                 anim->mNumChannels = static_cast<unsigned int>(anims_temp.size());
-                if (!anim->mNumChannels)
+                if (!anim->mNumChannels) {
                     throw DeadlyImportError("CSM: Empty $order section");
+                }
 
                 // copy over to the output animation
                 anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
                 ::memcpy(anim->mChannels,&anims_temp[0],sizeof(aiNodeAnim*)*anim->mNumChannels);
-            }
-            else if (TokenMatchI(buffer,"points",6))    {
-                if (!anim->mNumChannels)
+            } else if (TokenMatchI(buffer,"points",6)) {
+                if (!anim->mNumChannels) {
                     throw DeadlyImportError("CSM: \'$order\' section is required to appear prior to \'$points\'");
+                }
 
                 // If we know how many frames we'll read, we can preallocate some storage
                 unsigned int alloc = 100;
-                if (last != 0x00ffffff)
-                {
+                if (last != 0x00ffffff) {
+                    // re-init if the file has last frame data
                     alloc = last-first;
                     alloc += alloc>>2u; // + 25%
-                    for (unsigned int i = 0; i < anim->mNumChannels;++i)
+                    for (unsigned int i = 0; i < anim->mNumChannels; ++i) {
+                        if (anim->mChannels[i]->mPositionKeys != nullptr) delete[] anim->mChannels[i]->mPositionKeys;
                         anim->mChannels[i]->mPositionKeys = new aiVectorKey[alloc];
+                    }
+                } else {
+                    // default init
+                    for (unsigned int i = 0; i < anim->mNumChannels; ++i) {
+                        if (anim->mChannels[i]->mPositionKeys != nullptr) continue;
+                        anim->mChannels[i]->mPositionKeys = new aiVectorKey[alloc];
+                    }
                 }
 
                 unsigned int filled = 0;
 
                 // Now read all point data.
-                while (1)   {
-                    SkipSpaces(&buffer);
-                    if (IsLineEnd(*buffer) && (!SkipSpacesAndLineEnd(&buffer) || *buffer == '$'))   {
+                while (true) {
+                    SkipSpaces(&buffer, end);
+                    if (IsLineEnd(*buffer) && (!SkipSpacesAndLineEnd(&buffer, end) || *buffer == '$'))   {
                         break; // next section
                     }
 
@@ -209,56 +207,58 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                     for (unsigned int i = 0; i < anim->mNumChannels;++i)    {
 
                         aiNodeAnim* s = anim->mChannels[i];
-                        if (s->mNumPositionKeys == alloc)   { /* need to reallocate? */
-
+                        if (s->mNumPositionKeys == alloc)   {
+                            // need to reallocate?
                             aiVectorKey* old = s->mPositionKeys;
-                            s->mPositionKeys = new aiVectorKey[s->mNumPositionKeys = alloc*2];
+                            s->mPositionKeys = new aiVectorKey[alloc*2];
                             ::memcpy(s->mPositionKeys,old,sizeof(aiVectorKey)*alloc);
                             delete[] old;
                         }
 
                         // read x,y,z
-                        if(!SkipSpacesAndLineEnd(&buffer))
+                        if (!SkipSpacesAndLineEnd(&buffer, end)) {
                             throw DeadlyImportError("CSM: Unexpected EOF occurred reading sample x coord");
+                        }
 
                         if (TokenMatchI(buffer, "DROPOUT", 7))  {
                             // seems this is invalid marker data; at least the doc says it's possible
                             ASSIMP_LOG_WARN("CSM: Encountered invalid marker data (DROPOUT)");
-                        }
-                        else    {
+                        } else {
                             aiVectorKey* sub = s->mPositionKeys + s->mNumPositionKeys;
                             sub->mTime = (double)frame;
-                            buffer = fast_atoreal_move<float>(buffer, (float&)sub->mValue.x);
+                            buffer = fast_atoreal_move(buffer, sub->mValue.x);
 
-                            if(!SkipSpacesAndLineEnd(&buffer))
+                            if (!SkipSpacesAndLineEnd(&buffer, end)) {
                                 throw DeadlyImportError("CSM: Unexpected EOF occurred reading sample y coord");
-                            buffer = fast_atoreal_move<float>(buffer, (float&)sub->mValue.y);
+                            }
+                            buffer = fast_atoreal_move(buffer, sub->mValue.y);
 
-                            if(!SkipSpacesAndLineEnd(&buffer))
+                            if (!SkipSpacesAndLineEnd(&buffer, end)) {
                                 throw DeadlyImportError("CSM: Unexpected EOF occurred reading sample z coord");
-                            buffer = fast_atoreal_move<float>(buffer, (float&)sub->mValue.z);
+                            }
+                            buffer = fast_atoreal_move(buffer, sub->mValue.z);
 
                             ++s->mNumPositionKeys;
                         }
                     }
 
                     // update allocation granularity
-                    if (filled == alloc)
+                    if (filled == alloc) {
                         alloc *= 2;
+                    }
 
                     ++filled;
                 }
                 // all channels must be complete in order to continue safely.
                 for (unsigned int i = 0; i < anim->mNumChannels;++i)    {
-
-                    if (!anim->mChannels[i]->mNumPositionKeys)
+                    if (!anim->mChannels[i]->mNumPositionKeys) {
                         throw DeadlyImportError("CSM: Invalid marker track");
+                    }
                 }
             }
-        }
-        else    {
+        } else {
             // advance to the next line
-            SkipLine(&buffer);
+            SkipLine(&buffer, end);
         }
     }
 
@@ -272,14 +272,20 @@ void CSMImporter::InternReadFile( const std::string& pFile,
     pScene->mRootNode->mNumChildren = anim->mNumChannels;
     pScene->mRootNode->mChildren = new aiNode* [anim->mNumChannels];
 
-    for (unsigned int i = 0; i < anim->mNumChannels;++i)    {
+    for (unsigned int i = 0; i < anim->mNumChannels;++i) {
         aiNodeAnim* na = anim->mChannels[i];
 
         aiNode* nd  = pScene->mRootNode->mChildren[i] = new aiNode();
         nd->mName   = anim->mChannels[i]->mNodeName;
         nd->mParent = pScene->mRootNode;
 
-        aiMatrix4x4::Translation(na->mPositionKeys[0].mValue, nd->mTransformation);
+        if (na->mPositionKeys != nullptr && na->mNumPositionKeys > 0) {
+            aiMatrix4x4::Translation(na->mPositionKeys[0].mValue, nd->mTransformation);
+        } else {
+            // Use identity matrix if no valid position data is available
+            nd->mTransformation = aiMatrix4x4();
+            DefaultLogger::get()->warn("CSM: No position keys available for node - using identity transformation");
+        }
     }
 
     // Store the one and only animation in the scene

code/AssetLib/CSM/CSMLoader.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -58,10 +58,10 @@ namespace Assimp {
  *  Link to file format specification:
  *  <max_8_dvd>\samples\Motion\Docs\CSM.rtf
 */
-class CSMImporter : public BaseImporter {
+class CSMImporter final : public BaseImporter {
 public:
     CSMImporter();
-    ~CSMImporter() override;
+    ~CSMImporter() override = default;
 
     // -------------------------------------------------------------------
     bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
@@ -81,9 +81,8 @@ protected:
 private:
     bool noSkeletonMesh;
 
-}; // end of class CSMImporter
+};
 
-} // end of namespace Assimp
+} // namespace Assimp
 
 #endif // AI_AC3DIMPORTER_H_INC
-

code/AssetLib/Collada/ColladaExporter.cpp

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -36,7 +35,6 @@ 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.
-
 ----------------------------------------------------------------------
 */
 
@@ -64,6 +62,37 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp {
 
+static const aiNode *findSkeletonRootNode(const aiScene *scene, const aiMesh *mesh) {
+    std::set<const aiNode *> topParentBoneNodes;
+    if (mesh && mesh->mNumBones > 0) {
+        for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
+            aiBone *bone = mesh->mBones[i];
+
+            const aiNode *node = scene->mRootNode->findBoneNode(bone);
+            if (node) {
+                while (node->mParent && scene->findBone(node->mParent->mName) != nullptr) {
+                    node = node->mParent;
+                }
+                topParentBoneNodes.insert(node);
+            }
+        }
+    }
+
+    if (!topParentBoneNodes.empty()) {
+        const aiNode *parentBoneNode = *topParentBoneNodes.begin();
+        if (topParentBoneNodes.size() == 1) {
+            return parentBoneNode;
+        } else {
+            for (auto it : topParentBoneNodes) {
+                if (it->mParent) return it->mParent;
+            }
+            return parentBoneNode;
+        }
+    }
+
+    return nullptr;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
 void ExportSceneCollada(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
@@ -91,7 +120,7 @@ void ExportSceneCollada(const char *pFile, IOSystem *pIOSystem, const aiScene *p
 // Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
 static const std::string XMLIDEncode(const std::string &name) {
     const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
-    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
+    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char) - 1;
 
     if (name.length() == 0) {
         return name;
@@ -152,10 +181,6 @@ ColladaExporter::ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, con
     WriteFile();
 }
 
-// ------------------------------------------------------------------------------------------------
-// Destructor
-ColladaExporter::~ColladaExporter() = default;
-
 // ------------------------------------------------------------------------------------------------
 // Starts writing the contents
 void ColladaExporter::WriteFile() {
@@ -246,7 +271,7 @@ void ColladaExporter::WriteHeader() {
     }
 
     // Assimp root nodes can have meshes, Collada Scenes cannot
-    if (mScene->mRootNode->mNumChildren == 0 || mScene->mRootNode->mMeshes != 0) {
+    if (mScene->mRootNode->mNumChildren == 0 || mScene->mRootNode->mMeshes != nullptr) {
         mAdd_root_node = true;
     }
 
@@ -331,60 +356,68 @@ void ColladaExporter::WriteHeader() {
 // ------------------------------------------------------------------------------------------------
 // Write the embedded textures
 void ColladaExporter::WriteTextures() {
-    static const unsigned int buffer_size = 1024;
-    char str[buffer_size];
+    static constexpr unsigned int buffer_size = 1024;
+    char str[buffer_size] = {'\0'};
 
-    if (mScene->HasTextures()) {
-        for (unsigned int i = 0; i < mScene->mNumTextures; i++) {
-            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
-            // so we just write the textures in the current directory.
+    if (!mScene->HasTextures()) {
+        return;
+    }
 
-            aiTexture *texture = mScene->mTextures[i];
-            if (nullptr == texture) {
-                continue;
-            }
+    for (unsigned int i = 0; i < mScene->mNumTextures; i++) {
+        // It would be great to be able to create a directory in portable standard C++, but it's not the case,
+        // so we just write the textures in the current directory.
 
-            ASSIMP_itoa10(str, buffer_size, i + 1);
-
-            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char *)texture->achFormatHint);
-
-            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
-            if (outfile == nullptr) {
-                throw DeadlyExportError("could not open output texture file: " + mPath + name);
-            }
-
-            if (texture->mHeight == 0) {
-                outfile->Write((void *)texture->pcData, texture->mWidth, 1);
-            } else {
-                Bitmap::Save(texture, outfile.get());
-            }
-
-            outfile->Flush();
-
-            textures.insert(std::make_pair(i, name));
+        aiTexture *texture = mScene->mTextures[i];
+        if (nullptr == texture) {
+            continue;
         }
+
+        ASSIMP_itoa10(str, buffer_size, i + 1);
+
+        std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char *)texture->achFormatHint);
+
+        std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
+        if (outfile == nullptr) {
+            throw DeadlyExportError("could not open output texture file: " + mPath + name);
+        }
+
+        if (texture->mHeight == 0) {
+            outfile->Write((void *)texture->pcData, texture->mWidth, 1);
+        } else {
+            Bitmap::Save(texture, outfile.get());
+        }
+
+        outfile->Flush();
+
+        textures.insert(std::make_pair(i, name));
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Write the embedded textures
 void ColladaExporter::WriteCamerasLibrary() {
-    if (mScene->HasCameras()) {
-
-        mOutput << startstr << "<library_cameras>" << endstr;
-        PushTag();
-
-        for (size_t a = 0; a < mScene->mNumCameras; ++a)
-            WriteCamera(a);
-
-        PopTag();
-        mOutput << startstr << "</library_cameras>" << endstr;
+    if (!mScene->HasCameras()) {
+        return;
     }
+
+    mOutput << startstr << "<library_cameras>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumCameras; ++a) {
+        WriteCamera(a);
+    }
+
+    PopTag();
+    mOutput << startstr << "</library_cameras>" << endstr;
 }
 
 void ColladaExporter::WriteCamera(size_t pIndex) {
 
     const aiCamera *cam = mScene->mCameras[pIndex];
+    if (cam == nullptr) {
+        return;
+    }
+
     const std::string cameraId = GetObjectUniqueId(AiObjectType::Camera, pIndex);
     const std::string cameraName = GetObjectName(AiObjectType::Camera, pIndex);
 
@@ -422,22 +455,27 @@ void ColladaExporter::WriteCamera(size_t pIndex) {
 // ------------------------------------------------------------------------------------------------
 // Write the embedded textures
 void ColladaExporter::WriteLightsLibrary() {
-    if (mScene->HasLights()) {
-
-        mOutput << startstr << "<library_lights>" << endstr;
-        PushTag();
-
-        for (size_t a = 0; a < mScene->mNumLights; ++a)
-            WriteLight(a);
-
-        PopTag();
-        mOutput << startstr << "</library_lights>" << endstr;
+    if (!mScene->HasLights()) {
+        return;
     }
+
+    mOutput << startstr << "<library_lights>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumLights; ++a) {
+        WriteLight(a);
+    }
+
+    PopTag();
+    mOutput << startstr << "</library_lights>" << endstr;
 }
 
 void ColladaExporter::WriteLight(size_t pIndex) {
 
     const aiLight *light = mScene->mLights[pIndex];
+    if (light == nullptr) {
+        return;
+    }
     const std::string lightId = GetObjectUniqueId(AiObjectType::Light, pIndex);
     const std::string lightName = GetObjectName(AiObjectType::Light, pIndex);
 
@@ -448,7 +486,7 @@ void ColladaExporter::WriteLight(size_t pIndex) {
     PushTag();
     switch (light->mType) {
     case aiLightSource_AMBIENT:
-        WriteAmbienttLight(light);
+        WriteAmbientLight(light);
         break;
     case aiLightSource_DIRECTIONAL:
         WriteDirectionalLight(light);
@@ -462,6 +500,7 @@ void ColladaExporter::WriteLight(size_t pIndex) {
     case aiLightSource_AREA:
     case aiLightSource_UNDEFINED:
     case _aiLightSource_Force32Bit:
+    default:
         break;
     }
     PopTag();
@@ -521,10 +560,6 @@ void ColladaExporter::WriteSpotLight(const aiLight *const light) {
     mOutput << startstr << "<quadratic_attenuation>"
             << light->mAttenuationQuadratic
             << "</quadratic_attenuation>" << endstr;
-    /*
-    out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
-                            srcLight->mFalloffAngle);
-    */
 
     const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
     mOutput << startstr << "<falloff_angle sid=\"fall_off_angle\">"
@@ -543,7 +578,7 @@ void ColladaExporter::WriteSpotLight(const aiLight *const light) {
     mOutput << startstr << "</spot>" << endstr;
 }
 
-void ColladaExporter::WriteAmbienttLight(const aiLight *const light) {
+void ColladaExporter::WriteAmbientLight(const aiLight *const light) {
 
     const aiColor3D &color = light->mColorAmbient;
     mOutput << startstr << "<ambient>" << endstr;
@@ -559,41 +594,43 @@ void ColladaExporter::WriteAmbienttLight(const aiLight *const light) {
 // ------------------------------------------------------------------------------------------------
 // Reads a single surface entry from the given material keys
 bool ColladaExporter::ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex) {
-    if (pSrcMat.GetTextureCount(pTexture) > 0) {
-        aiString texfile;
-        unsigned int uvChannel = 0;
-        pSrcMat.GetTexture(pTexture, 0, &texfile, nullptr, &uvChannel);
-
-        std::string index_str(texfile.C_Str());
-
-        if (index_str.size() != 0 && index_str[0] == '*') {
-            unsigned int index;
-
-            index_str = index_str.substr(1, std::string::npos);
-
-            try {
-                index = (unsigned int)strtoul10_64<DeadlyExportError>(index_str.c_str());
-            } catch (std::exception &error) {
-                throw DeadlyExportError(error.what());
-            }
-
-            std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
-
-            if (name != textures.end()) {
-                poSurface.texture = name->second;
-            } else {
-                throw DeadlyExportError("could not find embedded texture at index " + index_str);
-            }
-        } else {
-            poSurface.texture = texfile.C_Str();
-        }
-
-        poSurface.channel = uvChannel;
-        poSurface.exist = true;
-    } else {
+    if (pSrcMat.GetTextureCount(pTexture) == 0) {
         if (pKey)
             poSurface.exist = pSrcMat.Get(pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
+        return poSurface.exist;
     }
+
+    aiString texfile;
+    unsigned int uvChannel = 0;
+    pSrcMat.GetTexture(pTexture, 0, &texfile, nullptr, &uvChannel);
+
+    std::string index_str(texfile.C_Str());
+
+    if (index_str.size() != 0 && index_str[0] == '*') {
+        unsigned int index;
+
+        index_str = index_str.substr(1, std::string::npos);
+
+        try {
+            index = (unsigned int)strtoul10_64<DeadlyExportError>(index_str.c_str());
+        } catch (std::exception &error) {
+            throw DeadlyExportError(error.what());
+        }
+
+        std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
+
+        if (name != textures.end()) {
+            poSurface.texture = name->second;
+        } else {
+            throw DeadlyExportError("could not find embedded texture at index " + index_str);
+        }
+    } else {
+        poSurface.texture = texfile.C_Str();
+    }
+
+    poSurface.channel = uvChannel;
+    poSurface.exist = true;
+
     return poSurface.exist;
 }
 
@@ -606,79 +643,87 @@ static bool isalnum_C(char c) {
 // ------------------------------------------------------------------------------------------------
 // Writes an image entry for the given surface
 void ColladaExporter::WriteImageEntry(const Surface &pSurface, const std::string &imageId) {
-    if (!pSurface.texture.empty()) {
-        mOutput << startstr << "<image id=\"" << imageId << "\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<init_from>";
-
-        // URL encode image file name first, then XML encode on top
-        std::stringstream imageUrlEncoded;
-        for (std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it) {
-            if (isalnum_C((unsigned char)*it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\')
-                imageUrlEncoded << *it;
-            else
-                imageUrlEncoded << '%' << std::hex << size_t((unsigned char)*it) << std::dec;
-        }
-        mOutput << XMLEscape(imageUrlEncoded.str());
-        mOutput << "</init_from>" << endstr;
-        PopTag();
-        mOutput << startstr << "</image>" << endstr;
+    if (pSurface.texture.empty()) {
+        return;
     }
+
+    mOutput << startstr << "<image id=\"" << imageId << "\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<init_from>";
+
+    // URL encode image file name first, then XML encode on top
+    std::stringstream imageUrlEncoded;
+    for (std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it) {
+        if (isalnum_C((unsigned char)*it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\')
+            imageUrlEncoded << *it;
+        else
+            imageUrlEncoded << '%' << std::hex << size_t((unsigned char)*it) << std::dec;
+    }
+    mOutput << XMLEscape(imageUrlEncoded.str());
+    mOutput << "</init_from>" << endstr;
+    PopTag();
+    mOutput << startstr << "</image>" << endstr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Writes a color-or-texture entry into an effect definition
 void ColladaExporter::WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId) {
-    if (pSurface.exist) {
-        mOutput << startstr << "<" << pTypeName << ">" << endstr;
-        PushTag();
-        if (pSurface.texture.empty()) {
-            mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
-        } else {
-            mOutput << startstr << "<texture texture=\"" << imageId << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
-        }
-        PopTag();
-        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    if (!pSurface.exist) {
+        return;
     }
+
+    mOutput << startstr << "<" << pTypeName << ">" << endstr;
+    PushTag();
+    if (pSurface.texture.empty()) {
+        mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
+    } else {
+        mOutput << startstr << "<texture texture=\"" << imageId << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+    }
+    PopTag();
+    mOutput << startstr << "</" << pTypeName << ">" << endstr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Writes the two parameters necessary for referencing a texture in an effect entry
 void ColladaExporter::WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId) {
     // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
-    if (!pSurface.texture.empty()) {
-        mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-surface\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<surface type=\"2D\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<init_from>" << materialId << "-" << pTypeName << "-image</init_from>" << endstr;
-        PopTag();
-        mOutput << startstr << "</surface>" << endstr;
-        PopTag();
-        mOutput << startstr << "</newparam>" << endstr;
-
-        mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-sampler\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<sampler2D>" << endstr;
-        PushTag();
-        mOutput << startstr << "<source>" << materialId << "-" << pTypeName << "-surface</source>" << endstr;
-        PopTag();
-        mOutput << startstr << "</sampler2D>" << endstr;
-        PopTag();
-        mOutput << startstr << "</newparam>" << endstr;
+    if (pSurface.texture.empty()) {
+        return;
     }
+
+    mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-surface\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<surface type=\"2D\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<init_from>" << materialId << "-" << pTypeName << "-image</init_from>" << endstr;
+    PopTag();
+    mOutput << startstr << "</surface>" << endstr;
+    PopTag();
+    mOutput << startstr << "</newparam>" << endstr;
+
+    mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-sampler\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<sampler2D>" << endstr;
+    PushTag();
+    mOutput << startstr << "<source>" << materialId << "-" << pTypeName << "-surface</source>" << endstr;
+    PopTag();
+    mOutput << startstr << "</sampler2D>" << endstr;
+    PopTag();
+    mOutput << startstr << "</newparam>" << endstr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Writes a scalar property
 void ColladaExporter::WriteFloatEntry(const Property &pProperty, const std::string &pTypeName) {
-    if (pProperty.exist) {
-        mOutput << startstr << "<" << pTypeName << ">" << endstr;
-        PushTag();
-        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
-        PopTag();
-        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    if (!pProperty.exist) {
+        return;
     }
+
+    mOutput << startstr << "<" << pTypeName << ">" << endstr;
+    PushTag();
+    mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
+    PopTag();
+    mOutput << startstr << "</" << pTypeName << ">" << endstr;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -832,8 +877,9 @@ void ColladaExporter::WriteControllerLibrary() {
 void ColladaExporter::WriteController(size_t pIndex) {
     const aiMesh *mesh = mScene->mMeshes[pIndex];
     // Is there a skin controller?
-    if (mesh->mNumBones == 0 || mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+    if (mesh->mNumBones == 0 || mesh->mNumFaces == 0 || mesh->mNumVertices == 0) {
         return;
+    }
 
     const std::string idstr = GetObjectUniqueId(AiObjectType::Mesh, pIndex);
     const std::string namestr = GetObjectName(AiObjectType::Mesh, pIndex);
@@ -864,8 +910,9 @@ void ColladaExporter::WriteController(size_t pIndex) {
 
     mOutput << startstr << "<Name_array id=\"" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
 
-    for (size_t i = 0; i < mesh->mNumBones; ++i)
+    for (size_t i = 0; i < mesh->mNumBones; ++i) {
         mOutput << GetBoneUniqueId(mesh->mBones[i]) << ' ';
+    }
 
     mOutput << "</Name_array>" << endstr;
 
@@ -888,9 +935,11 @@ void ColladaExporter::WriteController(size_t pIndex) {
 
     std::vector<ai_real> bind_poses;
     bind_poses.reserve(mesh->mNumBones * 16);
-    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
-        for (unsigned int j = 0; j < 4; ++j)
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
+        for (unsigned int j = 0; j < 4; ++j) {
             bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
+        }
+    }
 
     WriteFloatArray(idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real *)bind_poses.data(), bind_poses.size() / 16);
 
@@ -898,9 +947,11 @@ void ColladaExporter::WriteController(size_t pIndex) {
 
     std::vector<ai_real> skin_weights;
     skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
-    for (size_t i = 0; i < mesh->mNumBones; ++i)
-        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+    for (size_t i = 0; i < mesh->mNumBones; ++i) {
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j) {
             skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
+        }
+    }
 
     WriteFloatArray(idstr + "-skin-weights", FloatType_Weight, (const ai_real *)skin_weights.data(), skin_weights.size());
 
@@ -924,12 +975,15 @@ void ColladaExporter::WriteController(size_t pIndex) {
     mOutput << startstr << "<vcount>";
 
     std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
-    for (size_t i = 0; i < mesh->mNumBones; ++i)
-        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+    for (size_t i = 0; i < mesh->mNumBones; ++i) {
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j) {
             ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
+        }
+    }
 
-    for (size_t i = 0; i < mesh->mNumVertices; ++i)
+    for (size_t i = 0; i < mesh->mNumVertices; ++i) {
         mOutput << num_influences[i] << " ";
+    }
 
     mOutput << "</vcount>" << endstr;
 
@@ -945,7 +999,7 @@ void ColladaExporter::WriteController(size_t pIndex) {
 
     ai_uint weight_index = 0;
     std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
-    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
         for (unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j) {
             unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
             for (ai_uint k = 0; k < num_influences[vId]; ++k) {
@@ -957,9 +1011,11 @@ void ColladaExporter::WriteController(size_t pIndex) {
             }
             ++weight_index;
         }
+    }
 
-    for (size_t i = 0; i < joint_weight_indices.size(); ++i)
+    for (size_t i = 0; i < joint_weight_indices.size(); ++i) {
         mOutput << joint_weight_indices[i] << " ";
+    }
 
     num_influences.clear();
     accum_influences.clear();
@@ -983,8 +1039,9 @@ void ColladaExporter::WriteGeometryLibrary() {
     mOutput << startstr << "<library_geometries>" << endstr;
     PushTag();
 
-    for (size_t a = 0; a < mScene->mNumMeshes; ++a)
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a) {
         WriteGeometry(a);
+    }
 
     PopTag();
     mOutput << startstr << "</library_geometries>" << endstr;
@@ -997,8 +1054,9 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
     const std::string geometryId = GetObjectUniqueId(AiObjectType::Mesh, pIndex);
     const std::string geometryName = GetObjectName(AiObjectType::Mesh, pIndex);
 
-    if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+    if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0) {
         return;
+    }
 
     // opening tag
     mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
@@ -1010,8 +1068,9 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
     // Positions
     WriteFloatArray(geometryId + "-positions", FloatType_Vector, (ai_real *)mesh->mVertices, mesh->mNumVertices);
     // Normals, if any
-    if (mesh->HasNormals())
+    if (mesh->HasNormals()) {
         WriteFloatArray(geometryId + "-normals", FloatType_Vector, (ai_real *)mesh->mNormals, mesh->mNumVertices);
+    }
 
     // texture coords
     for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
@@ -1040,10 +1099,11 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
     int countLines = 0;
     int countPoly = 0;
     for (size_t a = 0; a < mesh->mNumFaces; ++a) {
-        if (mesh->mFaces[a].mNumIndices == 2)
+        if (mesh->mFaces[a].mNumIndices == 2) {
             countLines++;
-        else if (mesh->mFaces[a].mNumIndices >= 3)
+        } else if (mesh->mFaces[a].mNumIndices >= 3) {
             countPoly++;
+        }
     }
 
     // lines
@@ -1051,13 +1111,18 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
         mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
         PushTag();
         mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
-        if (mesh->HasNormals())
+        if (mesh->HasNormals()) {
             mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        }
         for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
-            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
-                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a))) {
+                mOutput << startstr
+                        << "<input semantic=\"TEXCOORD\" source=\"#"
+                        << geometryId
+                        << "-tex" << a << "\" "
                         << "set=\"" << a << "\""
                         << " />" << endstr;
+            }
         }
         for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
             if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
@@ -1070,8 +1135,9 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
         for (size_t a = 0; a < mesh->mNumFaces; ++a) {
             const aiFace &face = mesh->mFaces[a];
             if (face.mNumIndices != 2) continue;
-            for (size_t b = 0; b < face.mNumIndices; ++b)
+            for (size_t b = 0; b < face.mNumIndices; ++b) {
                 mOutput << face.mIndices[b] << " ";
+            }
         }
         mOutput << "</p>" << endstr;
         PopTag();
@@ -1085,8 +1151,9 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
         mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
         PushTag();
         mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
-        if (mesh->HasNormals())
+        if (mesh->HasNormals()) {
             mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        }
         for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
             if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
                 mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
@@ -1111,8 +1178,9 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
         for (size_t a = 0; a < mesh->mNumFaces; ++a) {
             const aiFace &face = mesh->mFaces[a];
             if (face.mNumIndices < 3) continue;
-            for (size_t b = 0; b < face.mNumIndices; ++b)
+            for (size_t b = 0; b < face.mNumIndices; ++b) {
                 mOutput << face.mIndices[b] << " ";
+            }
         }
         mOutput << "</p>" << endstr;
         PopTag();
@@ -1131,13 +1199,27 @@ void ColladaExporter::WriteGeometry(size_t pIndex) {
 void ColladaExporter::WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount) {
     size_t floatsPerElement = 0;
     switch (pType) {
-    case FloatType_Vector: floatsPerElement = 3; break;
-    case FloatType_TexCoord2: floatsPerElement = 2; break;
-    case FloatType_TexCoord3: floatsPerElement = 3; break;
-    case FloatType_Color: floatsPerElement = 3; break;
-    case FloatType_Mat4x4: floatsPerElement = 16; break;
-    case FloatType_Weight: floatsPerElement = 1; break;
-    case FloatType_Time: floatsPerElement = 1; break;
+    case FloatType_Vector:
+        floatsPerElement = 3;
+        break;
+    case FloatType_TexCoord2:
+        floatsPerElement = 2;
+        break;
+    case FloatType_TexCoord3:
+        floatsPerElement = 3;
+        break;
+    case FloatType_Color:
+        floatsPerElement = 3;
+        break;
+    case FloatType_Mat4x4:
+        floatsPerElement = 16;
+        break;
+    case FloatType_Weight:
+        floatsPerElement = 1;
+        break;
+    case FloatType_Time:
+        floatsPerElement = 1;
+        break;
     default:
         return;
     }
@@ -1163,8 +1245,9 @@ void ColladaExporter::WriteFloatArray(const std::string &pIdString, FloatDataTyp
             mOutput << pData[a * 4 + 2] << " ";
         }
     } else {
-        for (size_t a = 0; a < pElementCount * floatsPerElement; ++a)
+        for (size_t a = 0; a < pElementCount * floatsPerElement; ++a) {
             mOutput << pData[a] << " ";
+        }
     }
     mOutput << "</float_array>" << endstr;
     PopTag();
@@ -1256,9 +1339,13 @@ void ColladaExporter::WriteSceneLibrary() {
 // ------------------------------------------------------------------------------------------------
 void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
     const aiAnimation *anim = mScene->mAnimations[pIndex];
-
-    if (anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels == 0)
+    if (anim == nullptr) {
         return;
+    }
+
+    if (anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels == 0) {
+        return;
+    }
 
     const std::string animationNameEscaped = GetObjectName(AiObjectType::Animation, pIndex);
     const std::string idstrEscaped = GetObjectUniqueId(AiObjectType::Animation, pIndex);
@@ -1269,8 +1356,11 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
     std::string cur_node_idstr;
     for (size_t a = 0; a < anim->mNumChannels; ++a) {
         const aiNodeAnim *nodeAnim = anim->mChannels[a];
+        if (nodeAnim == nullptr) {
+            continue;
+        }
 
-        // sanity check
+        // sanity checks
         if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) {
             continue;
         }
@@ -1369,6 +1459,9 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
 
     for (size_t a = 0; a < anim->mNumChannels; ++a) {
         const aiNodeAnim *nodeAnim = anim->mChannels[a];
+        if (nodeAnim == nullptr) {
+            continue;
+        }
 
         {
             // samplers
@@ -1387,97 +1480,42 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
 
     for (size_t a = 0; a < anim->mNumChannels; ++a) {
         const aiNodeAnim *nodeAnim = anim->mChannels[a];
+        if (nodeAnim == nullptr) {
+            continue;
+        }
 
         {
             // channels
-            mOutput << startstr << "<channel source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-sampler")) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+            mOutput << startstr
+                    << "<channel source=\"#"
+                    << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-sampler"))
+                    << "\" target=\""
+                    << XMLIDEncode(nodeAnim->mNodeName.data)
+                    << "/matrix\"/>"
+                    << endstr;
         }
     }
 
     PopTag();
     mOutput << startstr << "</animation>" << endstr;
 }
+
 // ------------------------------------------------------------------------------------------------
 void ColladaExporter::WriteAnimationsLibrary() {
-    if (mScene->mNumAnimations > 0) {
-        mOutput << startstr << "<library_animations>" << endstr;
-        PushTag();
-
-        // start recursive write at the root node
-        for (size_t a = 0; a < mScene->mNumAnimations; ++a)
-            WriteAnimationLibrary(a);
-
-        PopTag();
-        mOutput << startstr << "</library_animations>" << endstr;
-    }
-}
-// ------------------------------------------------------------------------------------------------
-// Helper to find a bone by name in the scene
-aiBone *findBone(const aiScene *scene, const aiString &name) {
-    for (size_t m = 0; m < scene->mNumMeshes; m++) {
-        aiMesh *mesh = scene->mMeshes[m];
-        for (size_t b = 0; b < mesh->mNumBones; b++) {
-            aiBone *bone = mesh->mBones[b];
-            if (name == bone->mName) {
-                return bone;
-            }
-        }
-    }
-    return nullptr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Helper to find the node associated with a bone in the scene
-const aiNode *findBoneNode(const aiNode *aNode, const aiBone *bone) {
-    if (aNode && bone && aNode->mName == bone->mName) {
-        return aNode;
+    if (mScene->mNumAnimations == 0) {
+        return;
     }
 
-    if (aNode && bone) {
-        for (unsigned int i = 0; i < aNode->mNumChildren; ++i) {
-            aiNode *aChild = aNode->mChildren[i];
-            const aiNode *foundFromChild = nullptr;
-            if (aChild) {
-                foundFromChild = findBoneNode(aChild, bone);
-                if (foundFromChild) {
-                    return foundFromChild;
-                }
-            }
-        }
+    mOutput << startstr << "<library_animations>" << endstr;
+    PushTag();
+
+    // start recursive write at the root node
+    for (size_t a = 0; a < mScene->mNumAnimations; ++a) {
+        WriteAnimationLibrary(a);
     }
 
-    return nullptr;
-}
-
-const aiNode *findSkeletonRootNode(const aiScene *scene, const aiMesh *mesh) {
-    std::set<const aiNode *> topParentBoneNodes;
-    if (mesh && mesh->mNumBones > 0) {
-        for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
-            aiBone *bone = mesh->mBones[i];
-
-            const aiNode *node = findBoneNode(scene->mRootNode, bone);
-            if (node) {
-                while (node->mParent && findBone(scene, node->mParent->mName) != nullptr) {
-                    node = node->mParent;
-                }
-                topParentBoneNodes.insert(node);
-            }
-        }
-    }
-
-    if (!topParentBoneNodes.empty()) {
-        const aiNode *parentBoneNode = *topParentBoneNodes.begin();
-        if (topParentBoneNodes.size() == 1) {
-            return parentBoneNode;
-        } else {
-            for (auto it : topParentBoneNodes) {
-                if (it->mParent) return it->mParent;
-            }
-            return parentBoneNode;
-        }
-    }
-
-    return nullptr;
+    PopTag();
+    mOutput << startstr << "</library_animations>" << endstr;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1488,13 +1526,13 @@ void ColladaExporter::WriteNode(const aiNode *pNode) {
     // Assimp-specific: nodes with no name cannot be associated with bones
     const char *node_type;
     bool is_joint, is_skeleton_root = false;
-    if (pNode->mName.length == 0 || nullptr == findBone(mScene, pNode->mName)) {
+    if (pNode->mName.length == 0 || nullptr == mScene->findBone(pNode->mName)) {
         node_type = "NODE";
         is_joint = false;
     } else {
         node_type = "JOINT";
         is_joint = true;
-        if (!pNode->mParent || nullptr == findBone(mScene, pNode->mParent->mName)) {
+        if (!pNode->mParent || nullptr == mScene->findBone(pNode->mParent->mName)) {
             is_skeleton_root = true;
         }
     }
@@ -1532,7 +1570,6 @@ void ColladaExporter::WriteNode(const aiNode *pNode) {
     }
 
     // customized, sid should be 'matrix' to match with loader code.
-    //mOutput << startstr << "<matrix sid=\"transform\">";
     mOutput << startstr << "<matrix sid=\"matrix\">";
 
     mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
@@ -1556,7 +1593,6 @@ void ColladaExporter::WriteNode(const aiNode *pNode) {
                 break;
             }
         }
-
     } else
         // instance every geometry
         for (size_t a = 0; a < pNode->mNumMeshes; ++a) {
@@ -1612,8 +1648,9 @@ void ColladaExporter::WriteNode(const aiNode *pNode) {
         }
 
     // recurse into subnodes
-    for (size_t a = 0; a < pNode->mNumChildren; ++a)
+    for (size_t a = 0; a < pNode->mNumChildren; ++a) {
         WriteNode(pNode->mChildren[a]);
+    }
 
     PopTag();
     mOutput << startstr << "</node>" << endstr;
@@ -1628,8 +1665,9 @@ void ColladaExporter::CreateNodeIds(const aiNode *node) {
 std::string ColladaExporter::GetNodeUniqueId(const aiNode *node) {
     // Use the pointer as the key. This is safe because the scene is immutable.
     auto idIt = mNodeIdMap.find(node);
-    if (idIt != mNodeIdMap.cend())
+    if (idIt != mNodeIdMap.cend()) {
         return idIt->second;
+    }
 
     // Prefer the requested Collada Id if extant
     std::string idStr;
@@ -1640,36 +1678,42 @@ std::string ColladaExporter::GetNodeUniqueId(const aiNode *node) {
         idStr = node->mName.C_Str();
     }
     // Make sure the requested id is valid
-    if (idStr.empty())
+    if (idStr.empty()) {
         idStr = "node";
-    else
+    } else {
         idStr = XMLIDEncode(idStr);
+    }
 
     // Ensure it's unique
     idStr = MakeUniqueId(mUniqueIds, idStr, std::string());
     mUniqueIds.insert(idStr);
     mNodeIdMap.insert(std::make_pair(node, idStr));
+
     return idStr;
 }
 
 std::string ColladaExporter::GetNodeName(const aiNode *node) {
-
+    if (node == nullptr) {
+        return std::string();
+    }
     return XMLEscape(node->mName.C_Str());
 }
 
 std::string ColladaExporter::GetBoneUniqueId(const aiBone *bone) {
     // Find the Node that is this Bone
-    const aiNode *boneNode = findBoneNode(mScene->mRootNode, bone);
-    if (boneNode == nullptr)
+    const aiNode *boneNode = mScene->mRootNode->findBoneNode(bone);
+    if (boneNode == nullptr) {
         return std::string();
+    }
 
     return GetNodeUniqueId(boneNode);
 }
 
 std::string ColladaExporter::GetObjectUniqueId(AiObjectType type, size_t pIndex) {
     auto idIt = GetObjectIdMap(type).find(pIndex);
-    if (idIt != GetObjectIdMap(type).cend())
+    if (idIt != GetObjectIdMap(type).cend()) {
         return idIt->second;
+    }
 
     // Not seen this object before, create and add
     NameIdPair result = AddObjectIndexToMaps(type, pIndex);
@@ -1678,8 +1722,9 @@ std::string ColladaExporter::GetObjectUniqueId(AiObjectType type, size_t pIndex)
 
 std::string ColladaExporter::GetObjectName(AiObjectType type, size_t pIndex) {
     auto objectName = GetObjectNameMap(type).find(pIndex);
-    if (objectName != GetObjectNameMap(type).cend())
+    if (objectName != GetObjectNameMap(type).cend()) {
         return objectName->second;
+    }
 
     // Not seen this object before, create and add
     NameIdPair result = AddObjectIndexToMaps(type, pIndex);
@@ -1699,9 +1744,15 @@ ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType t
 
     // Get the name and id postfix
     switch (type) {
-    case AiObjectType::Mesh: name = mScene->mMeshes[index]->mName.C_Str(); break;
-    case AiObjectType::Material: name = mScene->mMaterials[index]->GetName().C_Str(); break;
-    case AiObjectType::Animation: name = mScene->mAnimations[index]->mName.C_Str(); break;
+    case AiObjectType::Mesh:
+        name = mScene->mMeshes[index]->mName.C_Str();
+        break;
+    case AiObjectType::Material:
+        name = mScene->mMaterials[index]->GetName().C_Str();
+        break;
+    case AiObjectType::Animation:
+        name = mScene->mAnimations[index]->mName.C_Str();
+        break;
     case AiObjectType::Light:
         name = mScene->mLights[index]->mName.C_Str();
         idPostfix = "-light";
@@ -1710,7 +1761,8 @@ ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType t
         name = mScene->mCameras[index]->mName.C_Str();
         idPostfix = "-camera";
         break;
-    case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type");
+    case AiObjectType::Count:
+        throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type");
     }
 
     if (name.empty()) {
@@ -1728,8 +1780,9 @@ ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType t
         idStr = XMLIDEncode(name);
     }
 
-    if (!name.empty())
+    if (!name.empty()) {
         name = XMLEscape(name);
+    }
 
     idStr = MakeUniqueId(mUniqueIds, idStr, idPostfix);
 
@@ -1743,5 +1796,5 @@ ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType t
 
 } // end of namespace Assimp
 
-#endif
-#endif
+#endif // ASSIMP_BUILD_NO_COLLADA_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT

code/AssetLib/Collada/ColladaExporter.h

@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -66,13 +65,13 @@ class IOSystem;
 
 /// Helper class to export a given scene to a Collada file. Just for my personal
 /// comfort when implementing it.
-class ColladaExporter {
+class ColladaExporter final {
 public:
     /// Constructor for a specific scene to export
     ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file);
 
     /// Destructor
-    virtual ~ColladaExporter();
+    virtual ~ColladaExporter() = default;
 
 protected:
     /// Starts writing the contents
@@ -101,7 +100,7 @@ protected:
     void WritePointLight(const aiLight *const light);
     void WriteDirectionalLight(const aiLight *const light);
     void WriteSpotLight(const aiLight *const light);
-    void WriteAmbienttLight(const aiLight *const light);
+    void WriteAmbientLight(const aiLight *const light);
 
     /// Writes the controller library
     void WriteControllerLibrary();

code/AssetLib/Collada/ColladaHelper.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 

code/AssetLib/Collada/ColladaHelper.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -341,7 +341,7 @@ struct SubMesh {
 
 /// Contains data for a single mesh
 struct Mesh {
-    Mesh(const std::string &id) :
+    explicit Mesh(const std::string &id) :
             mId(id) {
         for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
             mNumUVComponents[i] = 2;
@@ -666,7 +666,7 @@ struct ChannelEntry {
     const Collada::Accessor *mTimeAccessor; ///> Collada accessor to the time values
     const Collada::Data *mTimeData; ///> Source data array for the time values
     const Collada::Accessor *mValueAccessor; ///> Collada accessor to the key value values
-    const Collada::Data *mValueData; ///> Source datat array for the key value values
+    const Collada::Data *mValueData; ///> Source data array for the key value values
 
     ChannelEntry() :
             mChannel(),

code/AssetLib/Collada/ColladaLoader.cpp

@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -64,7 +64,7 @@ namespace Assimp {
 using namespace Assimp::Formatter;
 using namespace Assimp::Collada;
 
-static const aiImporterDesc desc = {
+static constexpr aiImporterDesc desc = {
     "Collada Importer",
     "",
     "",
@@ -77,42 +77,38 @@ static const aiImporterDesc desc = {
     "dae xml zae"
 };
 
-static const float kMillisecondsFromSeconds = 1000.f;
+static constexpr float kMillisecondsFromSeconds = 1000.f;
 
 // Add an item of metadata to a node
 // Assumes the key is not already in the list
 template <typename T>
-inline void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) {
+void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) {
     if (nullptr == node->mMetaData) {
         node->mMetaData = new aiMetadata();
     }
     node->mMetaData->Add(key, value);
 }
 
+// ------------------------------------------------------------------------------------------------
+// Reads a float value from an accessor and its data array.
+static ai_real ReadFloat(const Accessor &pAccessor, const Data &pData, size_t pIndex, size_t pOffset) {
+    const size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset;
+    ai_assert(pos < pData.mValues.size());
+    return pData.mValues[pos];
+}
+
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 ColladaLoader::ColladaLoader() :
-        mFileName(),
-        mMeshIndexByID(),
-        mMaterialIndexByName(),
-        mMeshes(),
-        newMats(),
-        mCameras(),
-        mLights(),
-        mTextures(),
-        mAnims(),
         noSkeletonMesh(false),
         removeEmptyBones(false),
         ignoreUpDirection(false),
+        ignoreUnitSize(false),
         useColladaName(false),
         mNodeNameCounter(0) {
     // empty
 }
 
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-ColladaLoader::~ColladaLoader() = default;
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
 bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
@@ -131,6 +127,7 @@ void ColladaLoader::SetupProperties(const Importer *pImp) {
     noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
     removeEmptyBones = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true) != 0;
     ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION, 0) != 0;
+    ignoreUnitSize = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UNIT_SIZE, 0) != 0;
     useColladaName = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES, 0) != 0;
 }
 
@@ -163,7 +160,7 @@ void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IO
         throw DeadlyImportError("Collada: File came out empty. Something is wrong here.");
     }
 
-    // reserve some storage to avoid unnecessary reallocs
+    // reserve some storage to avoid unnecessary reallocates
     newMats.reserve(parser.mMaterialLibrary.size() * 2u);
     mMeshes.reserve(parser.mMeshLibrary.size() * 2u);
 
@@ -179,12 +176,15 @@ void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IO
     // ... then fill the materials with the now adjusted settings
     FillMaterials(parser, pScene);
 
-    // Apply unit-size scale calculation
+    if (!ignoreUnitSize) {
+        // Apply unit-size scale calculation
+        pScene->mRootNode->mTransformation *= aiMatrix4x4(
+                parser.mUnitSize, 0, 0, 0,
+                0, parser.mUnitSize, 0, 0,
+                0, 0, parser.mUnitSize, 0,
+                0, 0, 0, 1);
+    }
 
-    pScene->mRootNode->mTransformation *= aiMatrix4x4(parser.mUnitSize, 0, 0, 0,
-            0, parser.mUnitSize, 0, 0,
-            0, 0, parser.mUnitSize, 0,
-            0, 0, 0, 1);
     if (!ignoreUpDirection) {
         // Convert to Y_UP, if different orientation
         if (parser.mUpDirection == ColladaParser::UP_X) {
@@ -232,7 +232,7 @@ void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IO
 // Recursively constructs a scene node for the given parser node and returns it.
 aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode) {
     // create a node for it
-    aiNode *node = new aiNode();
+    auto *node = new aiNode();
 
     // find a name for the new node. It's more complicated than you might think
     node->mName.Set(FindNameForNode(pNode));
@@ -255,7 +255,9 @@ aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collad
 
     // add children. first the *real* ones
     node->mNumChildren = static_cast<unsigned int>(pNode->mChildren.size() + instances.size());
-    node->mChildren = new aiNode *[node->mNumChildren];
+    if (node->mNumChildren != 0) {
+        node->mChildren = new aiNode * [node->mNumChildren];
+    }
 
     for (size_t a = 0; a < pNode->mChildren.size(); ++a) {
         node->mChildren[a] = BuildHierarchy(pParser, pNode->mChildren[a]);
@@ -278,24 +280,24 @@ aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collad
 // ------------------------------------------------------------------------------------------------
 // Resolve node instances
 void ColladaLoader::ResolveNodeInstances(const ColladaParser &pParser, const Node *pNode,
-        std::vector<const Node*> &resolved) {
+        std::vector<const Node*> &resolved) const {
     // reserve enough storage
     resolved.reserve(pNode->mNodeInstances.size());
 
     // ... and iterate through all nodes to be instanced as children of pNode
-    for (const auto &nodeInst : pNode->mNodeInstances) {
+    for (const auto &[mNode] : pNode->mNodeInstances) {
         // find the corresponding node in the library
-        const ColladaParser::NodeLibrary::const_iterator itt = pParser.mNodeLibrary.find(nodeInst.mNode);
+        const auto itt = pParser.mNodeLibrary.find(mNode);
         const Node *nd = itt == pParser.mNodeLibrary.end() ? nullptr : (*itt).second;
 
         // FIX for http://sourceforge.net/tracker/?func=detail&aid=3054873&group_id=226462&atid=1067632
         // need to check for both name and ID to catch all. To avoid breaking valid files,
         // the workaround is only enabled when the first attempt to resolve the node has failed.
         if (nullptr == nd) {
-            nd = FindNode(pParser.mRootNode, nodeInst.mNode);
+            nd = FindNode(pParser.mRootNode, mNode);
         }
         if (nullptr == nd) {
-            ASSIMP_LOG_ERROR("Collada: Unable to resolve reference to instanced node ", nodeInst.mNode);
+            ASSIMP_LOG_ERROR("Collada: Unable to resolve reference to instanced node ", mNode);
         } else {
             //  attach this node to the list of children
             resolved.push_back(nd);
@@ -305,8 +307,8 @@ void ColladaLoader::ResolveNodeInstances(const ColladaParser &pParser, const Nod
 
 // ------------------------------------------------------------------------------------------------
 // Resolve UV channels
-void ColladaLoader::ApplyVertexToEffectSemanticMapping(Sampler &sampler, const SemanticMappingTable &table) {
-    SemanticMappingTable::InputSemanticMap::const_iterator it = table.mMap.find(sampler.mUVChannel);
+static void ApplyVertexToEffectSemanticMapping(Sampler &sampler, const SemanticMappingTable &table) {
+    const auto it = table.mMap.find(sampler.mUVChannel);
     if (it == table.mMap.end()) {
         return;
     }
@@ -323,7 +325,7 @@ void ColladaLoader::ApplyVertexToEffectSemanticMapping(Sampler &sampler, const S
 void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
     for (const LightInstance &lid : pNode->mLights) {
         // find the referred light
-        ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find(lid.mLight);
+        auto srcLightIt = pParser.mLightLibrary.find(lid.mLight);
         if (srcLightIt == pParser.mLightLibrary.end()) {
             ASSIMP_LOG_WARN("Collada: Unable to find light for ID \"", lid.mLight, "\". Skipping.");
             continue;
@@ -331,7 +333,7 @@ void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node
         const Collada::Light *srcLight = &srcLightIt->second;
 
         // now fill our ai data structure
-        aiLight *out = new aiLight();
+        auto out = new aiLight();
         out->mName = pTarget->mName;
         out->mType = (aiLightSourceType)srcLight->mType;
 
@@ -388,7 +390,7 @@ void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node
 void ColladaLoader::BuildCamerasForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
     for (const CameraInstance &cid : pNode->mCameras) {
         // find the referred light
-        ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find(cid.mCamera);
+        auto srcCameraIt = pParser.mCameraLibrary.find(cid.mCamera);
         if (srcCameraIt == pParser.mCameraLibrary.end()) {
             ASSIMP_LOG_WARN("Collada: Unable to find camera for ID \"", cid.mCamera, "\". Skipping.");
             continue;
@@ -401,7 +403,7 @@ void ColladaLoader::BuildCamerasForNode(const ColladaParser &pParser, const Node
         }
 
         // now fill our ai data structure
-        aiCamera *out = new aiCamera();
+        auto *out = new aiCamera();
         out->mName = pTarget->mName;
 
         // collada cameras point in -Z by default, rest is specified in node transform
@@ -451,10 +453,10 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node
         const Controller *srcController = nullptr;
 
         // find the referred mesh
-        ColladaParser::MeshLibrary::const_iterator srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController);
+        auto srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController);
         if (srcMeshIt == pParser.mMeshLibrary.end()) {
             // if not found in the mesh-library, it might also be a controller referring to a mesh
-            ColladaParser::ControllerLibrary::const_iterator srcContrIt = pParser.mControllerLibrary.find(mid.mMeshOrController);
+            auto srcContrIt = pParser.mControllerLibrary.find(mid.mMeshOrController);
             if (srcContrIt != pParser.mControllerLibrary.end()) {
                 srcController = &srcContrIt->second;
                 srcMeshIt = pParser.mMeshLibrary.find(srcController->mMeshId);
@@ -468,7 +470,7 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node
                 continue;
             }
         } else {
-            // ID found in the mesh library -> direct reference to an unskinned mesh
+            // ID found in the mesh library -> direct reference to a not skinned mesh
             srcMesh = srcMeshIt->second;
         }
 
@@ -482,7 +484,7 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node
 
             // find material assigned to this submesh
             std::string meshMaterial;
-            std::map<std::string, SemanticMappingTable>::const_iterator meshMatIt = mid.mMaterials.find(submesh.mMaterial);
+            auto meshMatIt = mid.mMaterials.find(submesh.mMaterial);
 
             const Collada::SemanticMappingTable *table = nullptr;
             if (meshMatIt != mid.mMaterials.end()) {
@@ -498,7 +500,7 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node
 
             // OK ... here the *real* fun starts ... we have the vertex-input-to-effect-semantic-table
             // given. The only mapping stuff which we do actually support is the UV channel.
-            std::map<std::string, size_t>::const_iterator matIt = mMaterialIndexByName.find(meshMaterial);
+            auto matIt = mMaterialIndexByName.find(meshMaterial);
             unsigned int matIdx = 0;
             if (matIt != mMaterialIndexByName.end()) {
                 matIdx = static_cast<unsigned int>(matIt->second);
@@ -521,7 +523,7 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node
             ColladaMeshIndex index(mid.mMeshOrController, sm, meshMaterial);
 
             // if we already have the mesh at the library, just add its index to the node's array
-            std::map<ColladaMeshIndex, size_t>::const_iterator dstMeshIt = mMeshIndexByID.find(index);
+            auto dstMeshIt = mMeshIndexByID.find(index);
             if (dstMeshIt != mMeshIndexByID.end()) {
                 newMeshRefs.push_back(dstMeshIt->second);
             } else {
@@ -536,7 +538,7 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node
                 faceStart += submesh.mNumFaces;
 
                 // assign the material index
-                std::map<std::string, size_t>::const_iterator subMatIt = mMaterialIndexByName.find(submesh.mMaterial);
+                auto subMatIt = mMaterialIndexByName.find(submesh.mMaterial);
                 if (subMatIt != mMaterialIndexByName.end()) {
                     dstMesh->mMaterialIndex = static_cast<unsigned int>(subMatIt->second);
                 } else {
@@ -624,23 +626,21 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
         std::copy(pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() + pStartVertex + numVertices, dstMesh->mTangents);
     }
 
-    // bitangents, if given.
+    // bi-tangents, if given.
     if (pSrcMesh->mBitangents.size() >= pStartVertex + numVertices) {
         dstMesh->mBitangents = new aiVector3D[numVertices];
         std::copy(pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() + pStartVertex + numVertices, dstMesh->mBitangents);
     }
 
     // same for texture coords, as many as we have
-    // empty slots are not allowed, need to pack and adjust UV indexes accordingly
-    for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
         if (pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices) {
-            dstMesh->mTextureCoords[real] = new aiVector3D[numVertices];
+            dstMesh->mTextureCoords[a] = new aiVector3D[numVertices];
             for (size_t b = 0; b < numVertices; ++b) {
-                dstMesh->mTextureCoords[real][b] = pSrcMesh->mTexCoords[a][pStartVertex + b];
+                dstMesh->mTextureCoords[a][b] = pSrcMesh->mTexCoords[a][pStartVertex + b];
             }
 
-            dstMesh->mNumUVComponents[real] = pSrcMesh->mNumUVComponents[a];
-            ++real;
+            dstMesh->mNumUVComponents[a] = pSrcMesh->mNumUVComponents[a];
         }
     }
 
@@ -672,7 +672,7 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
     std::vector<float> targetWeights;
     Collada::MorphMethod method = Normalized;
 
-    for (std::map<std::string, Controller>::const_iterator it = pParser.mControllerLibrary.begin();
+    for (auto it = pParser.mControllerLibrary.begin();
             it != pParser.mControllerLibrary.end(); ++it) {
         const Controller &c = it->second;
         const Collada::Mesh *baseMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, c.mMeshId);
@@ -762,7 +762,7 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
         std::vector<IndexPairVector::const_iterator> weightStartPerVertex;
         weightStartPerVertex.resize(pSrcController->mWeightCounts.size(), pSrcController->mWeights.end());
 
-        IndexPairVector::const_iterator pit = pSrcController->mWeights.begin();
+        auto pit = pSrcController->mWeights.begin();
         for (size_t a = 0; a < pSrcController->mWeightCounts.size(); ++a) {
             weightStartPerVertex[a] = pit;
             pit += pSrcController->mWeightCounts[a];
@@ -774,7 +774,7 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
             // the controller assigns the vertex weights
             size_t orgIndex = pSrcMesh->mFacePosIndices[a];
             // find the vertex weights for this vertex
-            IndexPairVector::const_iterator iit = weightStartPerVertex[orgIndex];
+            auto iit = weightStartPerVertex[orgIndex];
             size_t pairCount = pSrcController->mWeightCounts[orgIndex];
 
             for (size_t b = 0; b < pairCount; ++b, ++iit) {
@@ -815,7 +815,7 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
             }
 
             // create bone with its weights
-            aiBone *bone = new aiBone;
+            auto bone = new aiBone;
             bone->mName = ReadString(jointNamesAcc, jointNames, a);
             bone->mOffsetMatrix.a1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 0);
             bone->mOffsetMatrix.a2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 1);
@@ -981,7 +981,7 @@ void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParse
 
             // if there are other animations which fit the template anim, combine all channels into a single anim
             if (!collectedAnimIndices.empty()) {
-                aiAnimation *combinedAnim = new aiAnimation();
+                auto *combinedAnim = new aiAnimation();
                 combinedAnim->mName = aiString(std::string("combinedAnim_") + char('0' + a));
                 combinedAnim->mDuration = templateAnim->mDuration;
                 combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond;
@@ -1048,7 +1048,7 @@ struct MorphTimeValues {
 };
 
 void insertMorphTimeValue(std::vector<MorphTimeValues> &values, float time, float weight, unsigned int value) {
-    MorphTimeValues::key k;
+    MorphTimeValues::key k{};
     k.mValue = value;
     k.mWeight = weight;
     if (values.empty() || time < values[0].mTime) {
@@ -1085,6 +1085,7 @@ static float getWeightAtKey(const std::vector<MorphTimeValues> &values, int key,
             return mKey.mWeight;
         }
     }
+
     // no value at key found, try to interpolate if present at other keys. if not, return zero
     // TODO: interpolation
     return 0.0f;
@@ -1113,7 +1114,7 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
 
         // now check all channels if they affect the current node
         std::string targetID, subElement;
-        for (std::vector<AnimationChannel>::const_iterator cit = pSrcAnim->mChannels.begin();
+        for (auto cit = pSrcAnim->mChannels.begin();
                 cit != pSrcAnim->mChannels.end(); ++cit) {
             const AnimationChannel &srcChannel = *cit;
             ChannelEntry entry;
@@ -1264,12 +1265,12 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
             // now for every unique point in time, find or interpolate the key values for that time
             // and apply them to the transform chain. Then the node's present transformation can be calculated.
             ai_real time = startTime;
-            while (1) {
+            while (true) {
                 for (ChannelEntry & e : entries) {
                     // find the keyframe behind the current point in time
                     size_t pos = 0;
                     ai_real postTime = 0.0;
-                    while (1) {
+                    while (true) {
                         if (pos >= e.mTimeAccessor->mCount) {
                             break;
                         }
@@ -1356,7 +1357,7 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
 
         // build an animation channel for the given node out of these trafo keys
         if (!resultTrafos.empty()) {
-            aiNodeAnim *dstAnim = new aiNodeAnim;
+            auto *dstAnim = new aiNodeAnim;
             dstAnim->mNodeName = nodeName;
             dstAnim->mNumPositionKeys = static_cast<unsigned int>(resultTrafos.size());
             dstAnim->mNumRotationKeys = static_cast<unsigned int>(resultTrafos.size());
@@ -1398,7 +1399,7 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
                 // or     2) one channel with morph target count arrays
                 // assume first
 
-                aiMeshMorphAnim *morphAnim = new aiMeshMorphAnim;
+                auto *morphAnim = new aiMeshMorphAnim;
                 morphAnim->mName.Set(nodeName);
 
                 std::vector<MorphTimeValues> morphTimeValues;
@@ -1441,7 +1442,7 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
     }
 
     if (!anims.empty() || !morphAnims.empty()) {
-        aiAnimation *anim = new aiAnimation;
+        auto anim = new aiAnimation;
         anim->mName.Set(pName);
         anim->mNumChannels = static_cast<unsigned int>(anims.size());
         if (anim->mNumChannels > 0) {
@@ -1521,9 +1522,9 @@ void ColladaLoader::AddTexture(aiMaterial &mat,
         map = sampler.mUVId;
     } else {
         map = -1;
-        for (std::string::const_iterator it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) {
+        for (auto it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) {
             if (IsNumeric(*it)) {
-                map = strtoul10(&(*it));        
+                map = strtoul10(&(*it));
                 break;
             }
         }
@@ -1539,7 +1540,7 @@ void ColladaLoader::AddTexture(aiMaterial &mat,
 // Fills materials from the collada material definitions
 void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pScene*/) {
     for (auto &elem : newMats) {
-        aiMaterial &mat = (aiMaterial &)*elem.second;
+        auto &mat = (aiMaterial &)*elem.second;
         Collada::Effect &effect = *elem.first;
 
         // resolve shading mode
@@ -1649,17 +1650,17 @@ void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pSce
 void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/) {
     newMats.reserve(pParser.mMaterialLibrary.size());
 
-    for (ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin();
+    for (auto matIt = pParser.mMaterialLibrary.begin();
             matIt != pParser.mMaterialLibrary.end(); ++matIt) {
         const Material &material = matIt->second;
         // a material is only a reference to an effect
-        ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect);
+        auto effIt = pParser.mEffectLibrary.find(material.mEffect);
         if (effIt == pParser.mEffectLibrary.end())
             continue;
         Effect &effect = effIt->second;
 
         // create material
-        aiMaterial *mat = new aiMaterial;
+        auto *mat = new aiMaterial;
         aiString name(material.mName.empty() ? matIt->first : material.mName);
         mat->AddProperty(&name, AI_MATKEY_NAME);
 
@@ -1680,9 +1681,9 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParse
 
     // recurse through the param references until we end up at an image
     std::string name = pName;
-    while (1) {
+    while (true) {
         // the given string is a param entry. Find it
-        Effect::ParamLibrary::const_iterator it = pEffect.mParams.find(name);
+        auto it = pEffect.mParams.find(name);
         // if not found, we're at the end of the recursion. The resulting string should be the image ID
         if (it == pEffect.mParams.end())
             break;
@@ -1692,7 +1693,7 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParse
     }
 
     // find the image referred by this name in the image library of the scene
-    ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find(name);
+    auto imIt = pParser.mImageLibrary.find(name);
     if (imIt == pParser.mImageLibrary.end()) {
         ASSIMP_LOG_WARN("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\".");
 
@@ -1704,7 +1705,7 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParse
 
     // if this is an embedded texture image setup an aiTexture for it
     if (!imIt->second.mImageData.empty()) {
-        aiTexture *tex = new aiTexture();
+        auto *tex = new aiTexture();
 
         // Store embedded texture name reference
         tex->mFilename.Set(imIt->second.mFileName.c_str());
@@ -1736,14 +1737,6 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParse
     return result;
 }
 
-// ------------------------------------------------------------------------------------------------
-// Reads a float value from an accessor and its data array.
-ai_real ColladaLoader::ReadFloat(const Accessor &pAccessor, const Data &pData, size_t pIndex, size_t pOffset) const {
-    size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset;
-    ai_assert(pos < pData.mValues.size());
-    return pData.mValues[pos];
-}
-
 // ------------------------------------------------------------------------------------------------
 // Reads a string value from an accessor and its data array.
 const std::string &ColladaLoader::ReadString(const Accessor &pAccessor, const Data &pData, size_t pIndex) const {
@@ -1826,4 +1819,4 @@ std::string ColladaLoader::FindNameForNode(const Node *pNode) {
 
 } // Namespace Assimp
 
-#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER
+#endif // !! ASSIMP_BUILD_NO_COLLADA_IMPORTER

code/AssetLib/Collada/ColladaLoader.h

@@ -4,8 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2022, assimp team
-
+Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
 
@@ -77,16 +76,19 @@ struct ColladaMeshIndex {
     }
 };
 
-/** Loader class to read Collada scenes. Collada is over-engineered to death, with every new iteration bringing
- * more useless stuff, so I limited the data to what I think is useful for games.
+/**
+ * @brief Loader class to read Collada scenes.
+ *
+ * Collada is over-engineered to death, with every new iteration bringing  more useless stuff,
+ * so I limited the data to what I think is useful for games.
 */
-class ColladaLoader : public BaseImporter {
+class ColladaLoader final : public BaseImporter {
 public:
     /// The class constructor.
     ColladaLoader();
 
     /// The class destructor.
-    ~ColladaLoader() override;
+    ~ColladaLoader() override = default;
 
     /// Returns whether the class can handle the format of the given file.
     /// @see BaseImporter::CanRead() for more details.
@@ -102,50 +104,51 @@ protected:
     /// See #BaseImporter::InternReadFile for the details
     void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
 
-    /** Recursively constructs a scene node for the given parser node and returns it. */
+    /// Recursively constructs a scene node for the given parser node and returns it.
     aiNode *BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode);
 
-    /** Resolve node instances */
+    /// Resolve node instances
     void ResolveNodeInstances(const ColladaParser &pParser, const Collada::Node *pNode,
-            std::vector<const Collada::Node *> &resolved);
+            std::vector<const Collada::Node *> &resolved) const;
 
-    /** Builds meshes for the given node and references them */
+    /// Builds meshes for the given node and references them
     void BuildMeshesForNode(const ColladaParser &pParser, const Collada::Node *pNode,
             aiNode *pTarget);
 
+    /// Lookup for meshes by their name
     aiMesh *findMesh(const std::string &meshid);
 
-    /** Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh */
+    /// Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh
     aiMesh *CreateMesh(const ColladaParser &pParser, const Collada::Mesh *pSrcMesh, const Collada::SubMesh &pSubMesh,
             const Collada::Controller *pSrcController, size_t pStartVertex, size_t pStartFace);
 
-    /** Builds cameras for the given node and references them */
+    /// Builds cameras for the given node and references them
     void BuildCamerasForNode(const ColladaParser &pParser, const Collada::Node *pNode,
             aiNode *pTarget);
 
-    /** Builds lights for the given node and references them */
+    /// Builds lights for the given node and references them
     void BuildLightsForNode(const ColladaParser &pParser, const Collada::Node *pNode,
             aiNode *pTarget);
 
-    /** Stores all meshes in the given scene */
+    /// Stores all meshes in the given scene
     void StoreSceneMeshes(aiScene *pScene);
 
-    /** Stores all materials in the given scene */
+    /// Stores all materials in the given scene
     void StoreSceneMaterials(aiScene *pScene);
 
-    /** Stores all lights in the given scene */
+    /// Stores all lights in the given scene
     void StoreSceneLights(aiScene *pScene);
 
-    /** Stores all cameras in the given scene */
+    /// Stores all cameras in the given scene
     void StoreSceneCameras(aiScene *pScene);
 
-    /** Stores all textures in the given scene */
+    /// Stores all textures in the given scene
     void StoreSceneTextures(aiScene *pScene);
 
-    /** Stores all animations
-     * @param pScene target scene to store the anims
-     */
-    void StoreAnimations(aiScene *pScene, const ColladaParser &pParser);
+    /// Stores all animations
+    /// @param pScene   Target scene to store the anims
+    /// @param parser   The collada parser
+    void StoreAnimations(aiScene *pScene, const ColladaParser &parser);
 
     /** Stores all animations for the given source anim and its nested child animations
      * @param pScene target scene to store the anims
@@ -163,10 +166,6 @@ protected:
     /** Fill materials from the collada material definitions */
     void FillMaterials(const ColladaParser &pParser, aiScene *pScene);
 
-    /** Resolve UV channel mappings*/
-    void ApplyVertexToEffectSemanticMapping(Collada::Sampler &sampler,
-            const Collada::SemanticMappingTable &table);
-
     /** Add a texture and all of its sampling properties to a material*/
     void AddTexture(aiMaterial &mat, const ColladaParser &pParser,
             const Collada::Effect &effect,
@@ -177,22 +176,13 @@ protected:
     aiString FindFilenameForEffectTexture(const ColladaParser &pParser,
             const Collada::Effect &pEffect, const std::string &pName);
 
-    /** Reads a float value from an accessor and its data array.
-     * @param pAccessor The accessor to use for reading
-     * @param pData The data array to read from
-     * @param pIndex The index of the element to retrieve
-     * @param pOffset Offset into the element, for multipart elements such as vectors or matrices
-     * @return the specified value
-     */
-    ai_real ReadFloat(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex, size_t pOffset) const;
-
     /** Reads a string value from an accessor and its data array.
      * @param pAccessor The accessor to use for reading
      * @param pData The data array to read from
      * @param pIndex The index of the element to retrieve
      * @return the specified value
      */
-    const std::string &ReadString(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex) const;
+    [[nodiscard]] const std::string &ReadString(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex) const;
 
     /** Recursively collects all nodes into the given array */
     void CollectNodes(const aiNode *pNode, std::vector<const aiNode *> &poNodes) const;
@@ -205,7 +195,7 @@ protected:
     /** Finds a proper name for a node derived from the collada-node's properties */
     std::string FindNameForNode(const Collada::Node *pNode);
 
-protected:
+private:
     /** Filename, for a verbose error message */
     std::string mFileName;
 
@@ -239,6 +229,7 @@ protected:
     bool noSkeletonMesh;
     bool removeEmptyBones;
     bool ignoreUpDirection;
+    bool ignoreUnitSize;
     bool useColladaName;
 
     /** Used by FindNameForNode() to generate unique node names */