Add internal JSON backend option

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,45 +0,0 @@
-## Description
-
-What does this PR do? Provide a brief summary of the changes. 
-
-## Type of Change
-
-- [ ] Bug fix
-- [ ] New feature
-- [ ] Refactoring (no functional changes)
-- [ ] Documentation update
-- [ ] Other (please describe):
-
-## Checklist
-
-### Required for All PRs
-
-- [ ] Reproducible glTF test file(s) are included (e.g., `models/regression/`, `tests/issue-***.gltf`, etc.)
-- [ ] Unit tests are written and pass locally (`cd tests && make run`)
-
-### Required for Feature PRs
-
-- [ ] Specification document is included (e.g., `docs/spec/<feature-name>.md`)
-  - The spec should cover: purpose, API design, usage examples, and edge cases
-
-### Security Policy
-
-This project manages CVE assignments exclusively through GitHub Security Advisories.
-PRs that include or reference independently obtained CVE IDs or external vulnerability disclosures will be closed.
-
-## Test Instructions
-
-How can reviewers verify your changes? 
-
-```
-# Example:
-cd build && cmake .. && make test
-```
-
-## Related Issues
-
-Link related issues: 
-
-## Additional Notes
-
-Any other context, screenshots, or information relevant to the review.

.github/workflows/c-cpp.yml

@@ -4,65 +4,166 @@ on: [push, pull_request]
 
 jobs:
 
+  # gcc4.8 is too old and ubuntu-18.04 image is not supported in GitHub Actions anymore,
+  # so disable this build.
+  ## compile with older gcc4.8
+  #build-gcc48:
+
+  #  runs-on: ubuntu-18.04
+  #  name: Build with gcc 4.8
+
+  #  steps:
+  #    - name: Checkout
+  #      uses: actions/checkout@v1
+
+  #    - name: Build
+  #      run: |
+  #          sudo apt-get update
+  #          sudo apt-get install -y build-essential
+  #          sudo apt-get install -y gcc-4.8 g++-4.8
+  #          g++-4.8 -std=c++11 -o loader_example loader_example.cc
+
+  #    - name: NoexceptBuild
+  #      run: |
+  #          g++-4.8 -DTINYGLTF_NOEXCEPTION -std=c++11 -o loader_example loader_example.cc
+
+  #    - name: RapidjsonBuild
+  #      run: |
+  #          git clone https://github.com/Tencent/rapidjson
+  #          g++-4.8 -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -o loader_example loader_example.cc
+
   # compile with mingw gcc cross
   build-mingw-cross:
 
     runs-on: ubuntu-latest
-    name: Build v3 C tests with MinGW gcc cross
+    name: Build with MinGW gcc cross
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v2
 
       - name: Build
         run: |
             sudo apt-get update
             sudo apt-get install -y build-essential
             sudo apt-get install -y mingw-w64
-            cd tests
-            x86_64-w64-mingw32-gcc -I../ -std=c11 -DTINYGLTF3_ENABLE_FS -o tester_v3_c.exe tester_v3_c.c ../tiny_gltf_v3.c
+            x86_64-w64-mingw32-g++ -std=c++11 -o loader_example loader_example.cc
 
-  # Windows(x64) + MSVC build (VS version agnostic: msvc-dev-cmd locates
-  # whatever Visual Studio the runner image ships, e.g. VS2022 or VS2026)
+  # Windows(x64) + Visual Studio 2022 build
+  # Assume windows-latest have VS2022 installed
   build-windows-msvc:
 
     runs-on: windows-latest
-    name: Build v3 C tests on Windows(x64, MSVC)
+    name: Build for Windows(x64, MSVC)
 
+    # Use system installed cmake
+    # https://help.github.com/en/actions/reference/software-installed-on-github-hosted-runners
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
-      - name: Set up MSVC environment
-        uses: ilammy/msvc-dev-cmd@v1
+        uses: actions/checkout@v1
       - name: Configure
-        run: cmake -B build -G Ninja -DTINYGLTF3_BUILD_TESTS=ON
+        run: |
+          mkdir build
+          cd build
+          cmake --help
+          cmake -G "Visual Studio 17 2022" -A x64 -DTINYGLTF_BUILD_LOADER_EXAMPLE=On -DTINYGLTF_BUILD_GL_EXAMPLES=Off -DTINYGLTF_BUILD_VALIDATOR_EXAMPLE=On ..
+          cd ..
       - name: Build
-        run: cmake --build build
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
+        run: cmake --build build --config Release
 
 
   build-linux:
 
     runs-on: ubuntu-latest
-    name: Build v3 C tests with gcc
+    name: Buld with gcc
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v2
     - name: build
       run: |
-        cd tests
-        cc -I../ -std=c11 -g -O0 -DTINYGLTF3_ENABLE_FS -o tester_v3_c tester_v3_c.c ../tiny_gltf_v3.c
+        g++ -std=c++11 -o loader_example loader_example.cc
     - name: test
       run: |
-        ./tests/tester_v3_c models/Cube/Cube.gltf
+        ./loader_example models/Cube/Cube.gltf
 
     - name: tests
       run: |
         cd tests
-        make all
-        ./tester_v3_c
-        ./tester_v3_c_v1port
-        ./tester_v3_json_c
-        ./tester_v3_freestanding
+        g++ -I../  -std=c++11 -g -O0 -o tester tester.cc
+        ./tester
         cd ..
+
+    - name: noexcept_tests
+      run: |
+        cd tests
+        g++ -DTINYGLTF_NOEXCEPTION -I../  -std=c++11 -g -O0 -o tester_noexcept tester.cc
+        ./tester_noexcept
+        cd ..
+
+
+  build-rapidjson-linux:
+
+    runs-on: ubuntu-latest
+    name: Buld with gcc + rapidjson
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: build
+      run: |
+        git clone https://github.com/Tencent/rapidjson
+        g++ -v
+        g++ -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -o loader_example loader_example.cc
+
+    - name: loader_example_test
+      run: |
+        ./loader_example models/Cube/Cube.gltf
+
+    - name: tests
+      run: |
+        cd tests
+        g++ -DTINYGLTF_USE_RAPIDJSON -I../rapidjson/include/rapidjson -I../  -std=c++11 -g -O0 -o tester tester.cc
+        ./tester
+        cd ..
+
+    - name: noexcept_tests
+      run: |
+        cd tests
+        g++ -DTINYGLTF_USE_RAPIDJSON -I../rapidjson/include/rapidjson -DTINYGLTF_NOEXCEPTION -I../  -std=c++11 -g -O0 -o tester_noexcept tester.cc
+        ./tester_noexcept
+        cd ..
+
+  # Cross-compile for aarch64 linux target
+  build-cross-aarch64:
+
+    runs-on: ubuntu-latest
+    name: Build on cross aarch64
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Build
+        run: |
+            sudo apt-get update
+            sudo apt-get install -y build-essential
+            sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
+
+            git clone https://github.com/Tencent/rapidjson
+            aarch64-linux-gnu-g++ -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -g -O0 -o loader_example loader_example.cc
+
+  # macOS clang
+  build-macos:
+
+    runs-on: macos-latest
+    name: Build on macOS
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Build
+        run: |
+            clang++ -std=c++11 -g -O0 -o loader_example loader_example.cc
+            ./loader_example models/Cube/Cube.gltf
+
+            git clone https://github.com/Tencent/rapidjson
+            clang++ -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -g -O0 -o loader_example loader_example.cc
+

.github/workflows/ci.yml

@@ -1,389 +0,0 @@
-name: Comprehensive CI
-
-on:
-  push:
-    branches:
-      - master
-      - release
-      - devel
-  pull_request:
-    branches:
-      - master
-      - release
-      - devel
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  # Linux x64 - GCC
-  linux-gcc-x64:
-    runs-on: ubuntu-latest
-    name: Linux x64 (GCC)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Configure
-        run: cmake -B build -DTINYGLTF3_BUILD_TESTS=ON
-
-      - name: Build
-        run: cmake --build build
-
-      - name: Run tester_v3_c on a sample model
-        run: ./build/tester_v3_c models/Cube/Cube.gltf
-
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
-
-  # Linux x64 - Clang 21
-  linux-clang-x64:
-    runs-on: ubuntu-24.04
-    name: Linux x64 (Clang 21)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Install Clang 21
-        run: |
-          wget https://apt.llvm.org/llvm.sh
-          chmod +x llvm.sh
-          sudo ./llvm.sh 21
-
-      - name: Configure
-        run: |
-          cmake -B build -DCMAKE_C_COMPILER=clang-21 -DTINYGLTF3_BUILD_TESTS=ON
-
-      - name: Build
-        run: cmake --build build
-
-      - name: Run tester_v3_c on a sample model
-        run: ./build/tester_v3_c models/Cube/Cube.gltf
-
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
-
-  # Linux ARM64 - GCC (native)
-  linux-arm64:
-    runs-on: ubuntu-24.04-arm
-    name: Linux ARM64 (GCC)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Configure
-        run: cmake -B build -DTINYGLTF3_BUILD_TESTS=ON
-
-      - name: Build
-        run: cmake --build build
-
-      - name: Run tester_v3_c on a sample model
-        run: ./build/tester_v3_c models/Cube/Cube.gltf
-
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
-
-  # macOS ARM64 Apple Silicon
-  macos-arm64:
-    runs-on: macos-14
-    name: macOS ARM64 Apple Silicon (Clang)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Configure
-        run: cmake -B build -DTINYGLTF3_BUILD_TESTS=ON
-
-      - name: Build
-        run: cmake --build build
-
-      - name: Run tester_v3_c on a sample model
-        run: ./build/tester_v3_c models/Cube/Cube.gltf
-
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
-
-  # Windows x64 - MSVC (VS version agnostic; msvc-dev-cmd locates the
-  # Visual Studio shipped with the runner image, e.g. VS2022 or VS2026)
-  windows-msvc-x64:
-    runs-on: windows-latest
-    name: Windows x64 (MSVC)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Set up MSVC environment
-        uses: ilammy/msvc-dev-cmd@v1
-
-      - name: Configure
-        run: cmake -B build -G Ninja -DTINYGLTF3_BUILD_TESTS=ON
-
-      - name: Build
-        run: cmake --build build
-
-      - name: Run tester_v3_c on a sample model
-        run: |
-          .\build\tester_v3_c.exe models\Cube\Cube.gltf
-
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
-
-  # Windows MinGW - MSYS2
-  windows-mingw-msys2:
-    runs-on: windows-latest
-    name: Windows x64 (MinGW MSYS2)
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup MSYS2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: UCRT64
-          install: base-devel
-          pacboy: >-
-            cc:p cmake:p ninja:p
-          update: true
-          release: false
-
-      - name: Build with CMake
-        run: |
-          cmake -G"Ninja" -S . -B build -DTINYGLTF3_BUILD_TESTS=ON
-          cmake --build build
-
-      - name: Run tester_v3_c on a sample model
-        run: |
-          ./build/tester_v3_c models/Cube/Cube.gltf
-
-      - name: Run tests
-        run: ctest --test-dir build --output-on-failure
-
-  # Linux -> Windows MinGW Cross-compile
-  linux-mingw-cross:
-    runs-on: ubuntu-latest
-    name: Linux→Windows (MinGW Cross) - Build Only
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Install MinGW
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y build-essential mingw-w64
-
-      - name: Build
-        run: |
-          cd tests
-          x86_64-w64-mingw32-gcc -I../ -std=c11 -g -O0 -DTINYGLTF3_ENABLE_FS -o tester_v3_c.exe tester_v3_c.c ../tiny_gltf_v3.c
-
-  # v3 C tests through Meson on the primary desktop platforms.
-  v3-c-meson:
-    runs-on: ${{ matrix.os }}
-    name: v3 C Meson (${{ matrix.os }})
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Install Meson
-        run: python -m pip install meson ninja
-
-      - name: Configure
-        run: meson setup build-meson -Dtests=true
-
-      - name: Build
-        run: meson compile -C build-meson
-
-      - name: Run v3 C tests
-        run: meson test -C build-meson --print-errorlogs
-
-  # v3 C runtime: internal security regression tests + ported v1 unit tests.
-  v3-c-tests:
-    runs-on: ubuntu-latest
-    name: v3 C tests (Linux x64, GCC)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Build tester_v3_c
-        run: |
-          cd tests
-          cc -I../ -std=c11 -g -O0 -Wall -Wextra -Wpedantic -Werror -DTINYGLTF3_ENABLE_FS \
-             -o tester_v3_c tester_v3_c.c ../tiny_gltf_v3.c
-
-      - name: Build tester_v3_c_v1port
-        run: |
-          cd tests
-          cc -I../ -std=c11 -g -O0 -Wall -Wextra -Wpedantic -Werror -DTINYGLTF3_ENABLE_FS \
-             -o tester_v3_c_v1port tester_v3_c_v1port.c ../tiny_gltf_v3.c
-
-      - name: Run tester_v3_c (security regressions)
-        run: |
-          cd tests
-          ./tester_v3_c
-
-      - name: Run tester_v3_c_v1port (ported unit tests)
-        run: |
-          cd tests
-          ./tester_v3_c_v1port
-
-  # v3 C runtime under stock Ubuntu clang.
-  v3-c-tests-clang:
-    runs-on: ubuntu-latest
-    name: v3 C tests (Linux x64, Clang)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Install clang
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y clang
-
-      - name: Build tester_v3_c
-        run: |
-          cd tests
-          clang -I../ -std=c11 -g -O0 -Werror -Weverything \
-                -Wno-padded -Wno-unsafe-buffer-usage -Wno-switch-default \
-                -Wno-format-nonliteral -Wno-float-equal -Wno-cast-align \
-                -Wno-declaration-after-statement -Wno-unknown-warning-option \
-                -Wno-pre-c11-compat \
-                -DTINYGLTF3_ENABLE_FS \
-                -o tester_v3_c tester_v3_c.c ../tiny_gltf_v3.c
-
-      - name: Build tester_v3_c_v1port
-        run: |
-          cd tests
-          clang -I../ -std=c11 -g -O0 -Werror -Weverything \
-                -Wno-padded -Wno-unsafe-buffer-usage -Wno-switch-default \
-                -Wno-format-nonliteral -Wno-float-equal -Wno-cast-align \
-                -Wno-declaration-after-statement -Wno-unknown-warning-option \
-                -Wno-pre-c11-compat \
-                -DTINYGLTF3_ENABLE_FS \
-                -o tester_v3_c_v1port tester_v3_c_v1port.c ../tiny_gltf_v3.c
-
-      - name: Run tester_v3_c
-        run: |
-          cd tests
-          ./tester_v3_c
-
-      - name: Run tester_v3_c_v1port
-        run: |
-          cd tests
-          ./tester_v3_c_v1port
-
-  # v3 C runtime under bleeding-edge clang 21 (matches local dev environment).
-  v3-c-tests-clang21:
-    runs-on: ubuntu-24.04
-    name: v3 C tests (Linux x64, Clang 21)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Install clang 21
-        run: |
-          wget https://apt.llvm.org/llvm.sh
-          chmod +x llvm.sh
-          sudo ./llvm.sh 21
-
-      - name: Build tester_v3_c
-        run: |
-          cd tests
-          clang-21 -I../ -std=c11 -g -O0 -Werror -Weverything \
-                   -Wno-padded -Wno-unsafe-buffer-usage -Wno-switch-default \
-                   -Wno-format-nonliteral -Wno-float-equal -Wno-cast-align \
-                   -Wno-declaration-after-statement -Wno-unknown-warning-option \
-                -Wno-pre-c11-compat \
-                   -DTINYGLTF3_ENABLE_FS \
-                   -o tester_v3_c tester_v3_c.c ../tiny_gltf_v3.c
-
-      - name: Build tester_v3_c_v1port
-        run: |
-          cd tests
-          clang-21 -I../ -std=c11 -g -O0 -Werror -Weverything \
-                   -Wno-padded -Wno-unsafe-buffer-usage -Wno-switch-default \
-                   -Wno-format-nonliteral -Wno-float-equal -Wno-cast-align \
-                   -Wno-declaration-after-statement -Wno-unknown-warning-option \
-                -Wno-pre-c11-compat \
-                   -DTINYGLTF3_ENABLE_FS \
-                   -o tester_v3_c_v1port tester_v3_c_v1port.c ../tiny_gltf_v3.c
-
-      - name: Run tester_v3_c
-        run: |
-          cd tests
-          ./tester_v3_c
-
-      - name: Run tester_v3_c_v1port
-        run: |
-          cd tests
-          ./tester_v3_c_v1port
-
-  # v3 C runtime built with MSVC at warning-level 4 (/W4 /WX).
-  v3-c-tests-msvc:
-    runs-on: windows-latest
-    name: v3 C tests (Windows x64, MSVC /W4)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Set up MSVC environment
-        uses: ilammy/msvc-dev-cmd@v1
-
-      - name: Build and run tester_v3_c
-        shell: cmd
-        run: |
-          cd tests
-          cl /nologo /W4 /WX /std:c11 /Zi /Od /D_CRT_SECURE_NO_WARNINGS /DTINYGLTF3_ENABLE_FS /I.. tester_v3_c.c ..\tiny_gltf_v3.c /Fe:tester_v3_c.exe
-          tester_v3_c.exe
-
-      - name: Build and run tester_v3_c_v1port
-        shell: cmd
-        run: |
-          cd tests
-          cl /nologo /W4 /WX /std:c11 /Zi /Od /D_CRT_SECURE_NO_WARNINGS /DTINYGLTF3_ENABLE_FS /I.. tester_v3_c_v1port.c ..\tiny_gltf_v3.c /Fe:tester_v3_c_v1port.exe
-          tester_v3_c_v1port.exe
-
-  # v3 C runtime under ASan + UBSan for memory-safety + UB checks.
-  v3-c-tests-sanitizers:
-    runs-on: ubuntu-latest
-    name: v3 C tests (Clang ASan + UBSan)
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Build tester_v3_c with ASan + UBSan
-        run: |
-          cd tests
-          clang -I../ -std=c11 -g -O1 -DTINYGLTF3_ENABLE_FS \
-                -fsanitize=address,undefined -fno-omit-frame-pointer \
-                -o tester_v3_c tester_v3_c.c ../tiny_gltf_v3.c
-
-      - name: Build tester_v3_c_v1port with ASan + UBSan
-        run: |
-          cd tests
-          clang -I../ -std=c11 -g -O1 -DTINYGLTF3_ENABLE_FS \
-                -fsanitize=address,undefined -fno-omit-frame-pointer \
-                -o tester_v3_c_v1port tester_v3_c_v1port.c ../tiny_gltf_v3.c
-
-      - name: Run tester_v3_c
-        env:
-          ASAN_OPTIONS: detect_leaks=1:halt_on_error=1
-          UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
-        run: |
-          cd tests
-          ./tester_v3_c
-
-      - name: Run tester_v3_c_v1port
-        env:
-          ASAN_OPTIONS: detect_leaks=1:halt_on_error=1
-          UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
-        run: |
-          cd tests
-          ./tester_v3_c_v1port

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '21 20 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp', 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/mingw-w64-msys2.yml

@@ -7,11 +7,7 @@ on:
       - devel
     paths:
     - 'tiny_gltf.*'
-    - 'tinygltf_json_c.h'
     - 'CMakeLists.txt'
-    - 'meson.build'
-    - 'meson_options.txt'
-    - 'tests/tester_v3*.c'
     - '.github/workflows/mingw-w64-msys2.yml'
   pull_request:
   workflow_dispatch:
@@ -24,7 +20,7 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v3
 
       - name: Install core & build dependencies
         uses: msys2/setup-msys2@v2
@@ -41,13 +37,9 @@ jobs:
           cmake \
             -G"Ninja" \
             -S . \
-            -B build \
-            -DTINYGLTF3_BUILD_TESTS=ON
+            -B build
 
       - name: Build
         run: |
           cmake --build build
 
-      - name: Run tests
-        run: |
-          ctest --test-dir build --output-on-failure

.gitignore

@@ -1,5 +1,4 @@
 # CMake
-/build/
 CMakeCache.txt
 CMakeFiles
 CMakeScripts
@@ -22,9 +21,6 @@ premake5.tar.gz
 *.vcxproj*
 .vs
 
-# default cmake build dir
-build/
-
 #binary directories
 bin/
 obj/
@@ -70,22 +66,14 @@ imgui.ini
 *.app
 
 loader_example
-# Compiled test binaries (built by tests/Makefile, CMakeLists.txt, meson.build)
-tests/tester_v3
-tests/tester_v3_c
-tests/tester_v3_c_cpp
-tests/tester_v3_c_v1port
-tests/tester_v3_c_v1port_cpp
-tests/tester_v3_freestanding
-tests/tester_v3_json_c
-tests/v3/fuzzer/fuzz_gltf_v3
-tests/v3/fuzzer/fuzz_gltf_v3_c
-
-# Generated by web/Makefile (make / make sample)
-web/tinygltf_v3.js
-web/tinygltf_v3.wasm
-web/Cube.glb
+tests/tester
+tests/tester_noexcept
+tests/issue-97.gltf
+tests/issue-261.gltf
 
 # unignore
 !Makefile
+!examples/build-gltf/Makefile
+!examples/raytrace/cornellbox_suzanne.obj
 !tests/Makefile
+!tools/windows/premake5.exe

AGENTS.md

@@ -1,55 +1,34 @@
-# AGENTS.md — tinygltf v3 (C)
+# Repository Guidelines
 
-TinyGLTF v3 C (`tiny_gltf_v3.h` + `tiny_gltf_v3.c` + `tinygltf_json_c.h`) is the
-mainline. Legacy v1/v2/v3-C++ code lives under `attic/` and is not built or
-tested.
+## Project Structure & Module Organization
+- Core library lives in `tiny_gltf.h` (header-only) with `tiny_gltf.cc` provided for the amalgamated implementation flags. Keep public API updates localized and documented.
+- Example viewers and utilities sit under `examples/`; use them as references for loading, validation, and WASM builds. Temporary build outputs belong in `build/` (git-ignored).
+- Tests reside in `tests/` with sample assets in `data/` and `models/`; avoid committing generated binaries in `build/`, `tmp/`, or `tests/tester*`.
 
-## Commands
+## Build, Test, and Development Commands
+- Quick build of the loader example: `make` (uses clang++, C++11, optional `EXTRA_CXXFLAGS` for sanitizers).
+- Unit tests: `cd tests && make && ./tester && ./tester_noexcept`.
+- Parsing regression run: build `loader_example`, then `python test_runner.py` (requires local glTF-Sample-Models checkout and path update inside the script).
+- CMake alternative: `cmake -S . -B build && cmake --build build` for IDE integration or non-clang toolchains.
+- Lint header: `python deps/cpplint.py tiny_gltf.h`.
 
-- Unit tests (C): `make -C tests all && make -C tests run`
-- CMake: `cmake -B build -DTINYGLTF3_BUILD_TESTS=ON && cmake --build build && ctest --test-dir build --output-on-failure`
-- Meson: `meson setup build && meson compile -C build && meson test -C build`
-- WASM/web demo (requires Emscripten SDK, default `~/work/emsdk`):
-  `make -C web && make -C web sample` — then open `http://localhost:8000` via `make -C web serve`
-- Fuzzers: `make -C tests/v3/fuzzer` (clang + libFuzzer)
+## Coding Style & Naming Conventions
+- C++11, two-space indent, braces on the same line; mirror existing spacing and comment style in `tiny_gltf.h`.
+- Prefer `std::` facilities and minimal dependencies; keep new symbols in the `tinygltf` namespace.
+- Public API names stay PascalCase for types and camelCase for functions; keep enums/macros consistent with existing `TINYGLTF_*` patterns.
+- Guard optional features with the established `TINYGLTF_*` defines; avoid introducing new globals without discussion.
 
-## Pre-push audit checklist
+## Testing Guidelines
+- Framework: Catch2 single-header (`tests/catch.hpp`); add `TEST_CASE` blocks alongside related helpers in `tests/tester.cc`.
+- Provide coverage for both exception-enabled and `TINYGLTF_NOEXCEPTION` builds; run both `tester` binaries before submitting.
+- For new formats or parsing code, add assets under `tests/` or reference `data/` and note provenance.
 
-Run **before every push**. Fix or unstage anything found; the audit must pass
-clean.
+## Commit & Pull Request Guidelines
+- Commit messages: concise, present-tense imperatives mirroring existing history (e.g., “Add bounds check to images loaded from bufferviews”).
+- PRs should describe the change, motivation, and testing (`tester`, `tester_noexcept`, fuzzing if relevant); link related issues.
+- Include platform notes if behavior differs (Windows vs. POSIX, filesystem callbacks, WASM). Add before/after metrics when touching performance-sensitive paths.
 
-1. **Working tree sanity**
-   - `git status --short` — no staged build artifacts, no surprise files.
-   - Never `git add -A` / `git add .`: stage only intended paths. The repo
-     root frequently contains untracked scratch files (`Fox.glb`,
-     `benchmark/synthetic_*`, `log*`, `.cache/`, `tests/v3/fuzzer/artifacts|corpus`,
-     stray `*.gltf`/`*.bin` files). Verify `git status` before staging.
-
-2. **Secret scan**
-   - `gitleaks detect --source . --no-banner -r /tmp/gitleaks.json`
-   - `~/local/bin/trufflehog git file://$PWD --no-update --only-verified`
-   - Both must report 0 real secrets. Known allowed finding: `B3G_LEFT_ARROW`
-     generic-api-key hits in `attic/examples/common/OpenGLWindow/` are false
-     positives (keyboard key constants).
-
-3. **No build artifacts or unwanted large binaries**
-   - `git ls-files -z | xargs -0 du -b | sort -rn | head -30` — review the top.
-   - Rule of thumb: nothing over ~1 MB unless it is a tracked, intentional
-     asset (e.g. `attic/tools/windows/premake5.exe`, `models/Cube/*.png`).
-   - Watch for: compiled executables, `*.wasm`/`*.exr`/`*.log`/`*.o`/`*.obj`,
-     generated `output.*`/`cloth*`/`sim*.bin`/`out_*.exr` files, and large
-     `.gltf`/`.glb` files. Small test/regression fixture `.gltf` files
-     (e.g. under `tests/`, `models/regression/`, `tests/v3/security/`) are OK.
-   - `web/tinygltf_v3.js`, `web/tinygltf_v3.wasm`, `web/Cube.glb` are
-     generated by `make -C web` and must stay gitignored (never commit them).
-
-4. **History is lean**
-   - If an unwanted file was added in an unpushed commit, rewrite it
-     (`git rebase -i origin/<branch>`, `git rm` + `--amend`) so the blob never
-     reaches the remote, then `git gc --prune=now` locally.
-   - Push only intended branches (`git push origin <branch>` — never `--all`
-     or `--force` unless explicitly asked).
-
-5. **Final smoke check**
-   - `make -C tests run` passes (all 4 testers).
-   - If touched: `cmake`/`meson` builds and `make -C web` still succeed.
+## Security & Configuration Tips
+- Handle external data defensively: validate buffer sizes, offsets, and URI handling; prefer bounded allocations.
+- Keep optional callbacks (`fs::`, URI, image) robust against untrusted input; document new failure modes.
+- Avoid committing sample assets with unclear licensing; reuse existing test fixtures where possible.

CMakeLists.txt

@@ -1,56 +1,87 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.6)
 
-project(tinygltf_v3 C)
+project(tinygltf)
 
 include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
 
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED On)
-set(CMAKE_C_EXTENSIONS Off)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED On)
+set(CMAKE_CXX_EXTENSIONS Off)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-option(TINYGLTF3_BUILD_TESTS "Build and run tinygltf v3 C unit tests" ON)
-option(TINYGLTF3_INSTALL "Install tinygltf v3 files during install step" ON)
+option(TINYGLTF_BUILD_LOADER_EXAMPLE "Build loader_example(load glTF and dump infos)" ON)
+option(TINYGLTF_BUILD_GL_EXAMPLES "Build GL exampels(requires glfw, OpenGL, etc)" OFF)
+option(TINYGLTF_BUILD_VALIDATOR_EXAMPLE "Build validator exampe" OFF)
+option(TINYGLTF_BUILD_BUILDER_EXAMPLE "Build glTF builder example" OFF)
+option(TINYGLTF_HEADER_ONLY "On: header-only mode. Off: create tinygltf library(No TINYGLTF_IMPLEMENTATION required in your project)" OFF)
+option(TINYGLTF_INSTALL "Install tinygltf files during install step. Usually set to OFF if you include tinygltf through add_subdirectory()" ON)
+option(TINYGLTF_INSTALL_VENDOR "Install vendored nlohmann/json and nothings/stb headers" ON)
 
-set(TINYGLTF3_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
-
-if (TINYGLTF3_BUILD_TESTS)
-  enable_testing()
-
-  function(add_tinygltf_v3_c_test target)
-    add_executable(${target} ${ARGN})
-    target_include_directories(${target} PRIVATE
-      ${CMAKE_CURRENT_SOURCE_DIR}
-      ${CMAKE_CURRENT_SOURCE_DIR}/tests
+if (TINYGLTF_BUILD_LOADER_EXAMPLE)
+  add_executable(loader_example
+    loader_example.cc
     )
-    set_target_properties(${target} PROPERTIES
-      C_STANDARD 11
-      C_STANDARD_REQUIRED ON
-      C_EXTENSIONS OFF
-    )
-    add_test(NAME ${target} COMMAND ${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
-  endfunction()
+endif (TINYGLTF_BUILD_LOADER_EXAMPLE)
 
-  add_tinygltf_v3_c_test(tester_v3_c tests/tester_v3_c.c tiny_gltf_v3.c)
-  target_compile_definitions(tester_v3_c PRIVATE TINYGLTF3_ENABLE_FS)
+if (TINYGLTF_BUILD_GL_EXAMPLES)
+  add_subdirectory( examples/gltfutil )
+  add_subdirectory( examples/glview )
+endif (TINYGLTF_BUILD_GL_EXAMPLES)
 
-  add_tinygltf_v3_c_test(tester_v3_c_v1port tests/tester_v3_c_v1port.c tiny_gltf_v3.c)
-  target_compile_definitions(tester_v3_c_v1port PRIVATE TINYGLTF3_ENABLE_FS)
+if (TINYGLTF_BUILD_VALIDATOR_EXAMPLE)
+  add_subdirectory( examples/validator )
+endif (TINYGLTF_BUILD_VALIDATOR_EXAMPLE)
 
-  add_tinygltf_v3_c_test(tester_v3_json_c tests/tester_v3_json_c.c)
+if (TINYGLTF_BUILD_BUILDER_EXAMPLE)
+  add_subdirectory ( examples/build-gltf )
+endif (TINYGLTF_BUILD_BUILDER_EXAMPLE)
 
-  add_tinygltf_v3_c_test(tester_v3_freestanding tests/tester_v3_freestanding.c)
-  if (CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
-    target_compile_options(tester_v3_freestanding PRIVATE -ffreestanding)
-  endif()
-endif ()
+#
+# for add_subdirectory and standalone build
+#
+if (TINYGLTF_HEADER_ONLY)
+  add_library(tinygltf INTERFACE)
 
-if (TINYGLTF3_INSTALL)
-  install(FILES
-    tiny_gltf_v3.h
-    tiny_gltf_v3.c
-    tinygltf_json_c.h
-    DESTINATION
-    ${TINYGLTF3_INSTALL_DIR}
+  target_include_directories(tinygltf
+          INTERFACE
+          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
   )
-endif ()
+
+else (TINYGLTF_HEADER_ONLY)
+  add_library(tinygltf)
+  target_sources(tinygltf PRIVATE
+          ${CMAKE_CURRENT_SOURCE_DIR}/tiny_gltf.cc)
+  target_include_directories(tinygltf
+          INTERFACE
+          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+          )
+endif (TINYGLTF_HEADER_ONLY)
+
+if (TINYGLTF_INSTALL)
+  install(TARGETS tinygltf EXPORT tinygltfTargets)
+  install(EXPORT tinygltfTargets NAMESPACE tinygltf:: FILE TinyGLTFTargets.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/tinygltf)
+  configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/TinyGLTFConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/TinyGLTFConfig.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/TinyGLTFConfig.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/tinygltf)
+  # Do not install .lib even if !TINYGLTF_HEADER_ONLY
+
+  INSTALL ( FILES
+    tiny_gltf.h
+    ${TINYGLTF_EXTRA_SOUECES}
+    DESTINATION
+    include
+    )
+
+    if(TINYGLTF_INSTALL_VENDOR)
+      INSTALL ( FILES
+        json.hpp
+        stb_image.h
+        stb_image_write.h
+        DESTINATION
+        include
+        )
+    endif()
+
+endif(TINYGLTF_INSTALL)

Makefile

@@ -1,14 +1,13 @@
-# tinygltf v3 (C) — convenience build entry point.
-#
-#   make            — build all v3 C unit testers
-#   make test       — build and run all v3 C unit testers
-#   make clean      — remove test binaries
+
+# Use this for strict compilation check(will work on clang 3.8+)
+#EXTRA_CXXFLAGS := -fsanitize=address -Wall -Werror -Weverything -Wno-c++11-long-long -Wno-c++98-compat
+
+# With draco
+# EXTRA_CXXFLAGS := -I../draco/src/ -I../draco/build -DTINYGLTF_ENABLE_DRACO -L../draco/build
+# EXTRA_LINKFLAGS := -L../draco/build/ -ldracodec -ldraco
 
 all:
-	$(MAKE) -C tests all
+	clang++  $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o loader_example loader_example.cc $(EXTRA_LINKFLAGS)
 
-test: all
-	$(MAKE) -C tests run
-
-clean:
-	$(MAKE) -C tests clean
+lint:
+	deps/cpplint.py tiny_gltf.h

README.md

@@ -1,105 +1,272 @@
-# tinygltf v3 — C glTF 2.0 loader/saver
+# Header only C++ tiny glTF library(loader/saver).
 
-`TinyGLTF v3` is a C11-first implementation of a glTF 2.0
-https://github.com/KhronosGroup/glTF loader and writer.
+`TinyGLTF` is a header only C++11 glTF 2.0 https://github.com/KhronosGroup/glTF library.
 
-- **Pure C POD API** (`tiny_gltf_v3.h` + `tiny_gltf_v3.c` + `tinygltf_json_c.h`) — no STL, no RTTI, no exceptions required; easy to bind to other languages.
-- **Arena-based memory management** — all parse-time allocations come from a single arena; a single `tg3_model_free()` frees everything.
-- **Structured error reporting** — `tg3_error_stack` provides machine-readable errors with severity levels and source locations.
-- **Custom JSON backend** — `tinygltf_json_c.h` is a locale-independent pure-C JSON parser/serializer used by the v3 runtime.
-- **Streaming callbacks** — opt-in streaming parse/write via user-supplied callbacks.
-- **Opt-in filesystem and image I/O** — `TINYGLTF3_ENABLE_FS` / `TINYGLTF3_ENABLE_STB_IMAGE` are off by default; you control when and how assets are loaded.
-- **C++20 coroutine facade** (optional, auto-detected). C17/C++17 default.
-- **Hardened against untrusted input** — URI sanitization, post-parse index-bounds validation (default-on, opt-out via `tg3_parse_options.validate_indices = 0`), strict numeric range checks; exercised by a libFuzzer harness. See the `Security Considerations` block at the top of `tiny_gltf_v3.h`.
-
-## Quick start
-
-Copy `tiny_gltf_v3.h`, `tiny_gltf_v3.c`, and `tinygltf_json_c.h` to your project.
-Compile `tiny_gltf_v3.c` as C11 or newer. Define `TINYGLTF3_ENABLE_FS` when
-building `tiny_gltf_v3.c` if you want `tg3_parse_file()` to use stdio-backed
-filesystem helpers. The legacy `TINYGLTF3_IMPLEMENTATION` include path remains
-available for compatibility.
-
-```c
-#include "tiny_gltf_v3.h"
-```
-
-Loading a glTF file:
-
-```c
-tg3_parse_options opts;
-tg3_error_stack errors;
-tg3_model model;
-
-tg3_parse_options_init(&opts);
-tg3_error_stack_init(&errors);
-
-tg3_error_code err = tg3_parse_file(&model, &errors, "scene.gltf", 10, &opts);
-if (err != TG3_OK) {
-    for (uint32_t i = 0; i < errors.count; i++) {
-        fprintf(stderr, "[%d] %s\n", (int)errors.entries[i].severity,
-                errors.entries[i].message ? errors.entries[i].message : "(null)");
-    }
-}
-// ... use model ...
-tg3_model_free(&model);
-tg3_error_stack_free(&errors);
-```
-
-## Testing & verification
-
-The v3 C runtime ships with three layers of automated coverage:
-
-- **`tests/tester_v3_c.c`** — internal unit checks plus security regression tests (path traversal, negative `byteStride`, OOB indices, error-message lifetime, …). Build via `make` in `tests/`; run `./tester_v3_c` for the internal suite or `./tester_v3_c <file.gltf|file.glb>` to parse a single asset.
-- **`tests/tester_v3_c_v1port.c`** — v3 C port of the legacy unit tests, keeping behavioral parity with the old C++ API.
-- **`tests/tester_v3_json_c.c`** and **`tests/tester_v3_freestanding.c`** — JSON backend and freestanding (no libc) checks.
-- **`test_runner.py`** — model verifier that runs `tests/tester_v3_c` against every model in `glTF-Sample-Models/2.0` and validates the structured COUNTS/DIGEST output.
-- **`tests/v3/fuzzer/`** — libFuzzer harness with ASan + UBSan (`make run` builds and runs `fuzz_gltf_v3_c`). Crafted regression inputs live in `tests/v3/security/` and are seeded into `tests/v3/fuzzer/corpus/`.
-
-### Building
-
-```bash
-# Plain make (gcc/clang)
-$ make -C tests && make -C tests run
-
-# CMake
-$ cmake -B build && cmake --build build && ctest --test-dir build --output-on-failure
-
-# Meson
-$ meson setup build && meson compile -C build && meson test -C build
-
-# WebAssembly (requires an Emscripten SDK, defaults to ~/work/emsdk)
-$ make -C web && make -C web sample
-```
-
-## Web/WASM demo
-
-[`web/`](web/) contains a browser demo that compiles the v3 C runtime with
-Emscripten and renders glTF/GLB files with three.js (file picker + drag &
-drop). See [`web/README.md`](web/README.md) for build instructions.
-
-## Legacy v1/v2 (C++)
-
-The previous C++ implementation (`tiny_gltf.h`, `tiny_gltf.cc`,
-`tinygltf_json.h`, `json.hpp`, `loader_example.cc`, the C++ examples and
-tests) is deprecated and has been moved to [`attic/`](attic/) for reference.
-It is no longer built, tested, or installed. TinyGLTF v3 C is the mainline.
+`TinyGLTF` uses Niels Lohmann's json library (https://github.com/nlohmann/json), so now it requires C++11 compiler.
+(Also, you can use RadpidJSON as an JSON backend)
+If you are looking for old, C++03 version, please use `devel-picojson` branch (but not maintained anymore).
 
 ## Status
 
-TinyGLTF v3 (`tiny_gltf_v3.h` + `tiny_gltf_v3.c`) is the mainline release.
-API additions and behavior changes go through the usual review process.
+Currently TinyGLTF is stable and maintenance mode. No drastic changes and feature additions planned.
+ - v2.9.0 Various fixes and improvements. Filesystem callback API change.
+ - v2.8.0 Add URICallbacks for custom URI handling in Buffer and Image. PR#397
+ - v2.7.0 Change WriteImageDataFunction user callback function signature. PR#393
+ - v2.6.0 Support serializing sparse accessor(Thanks to @fynv).
+ - v2.5.0 Add SetPreserveImageChannels() option to load image data as is.
+ - v2.4.0 Experimental RapidJSON support. Experimental C++14 support(C++14 may give better performance)
+ - v2.3.0 Modified Material representation according to glTF 2.0 schema(and introduced TextureInfo class)
+ - v2.2.0 release(Support loading 16bit PNG. Sparse accessor support)
+ - v2.1.0 release(Draco decoding support)
+ - v2.0.0 release(22 Aug, 2018)!
+
+### Branches
+
+* `sajson` : Use sajson to parse JSON. Parsing only but faster compile time(2x reduction compared to json.hpp and RapidJson), but not well maintained.
 
 ## Builds
 
+[![Build status](https://ci.appveyor.com/api/projects/status/warngenu9wjjhlm8?svg=true)](https://ci.appveyor.com/project/syoyo/tinygltf)
+
 ![C/C++ CI](https://github.com/syoyo/tinygltf/workflows/C/C++%20CI/badge.svg)
 
+## Features
+
+Probably mostly feature-complete. Last missing feature is Draco encoding: https://github.com/syoyo/tinygltf/issues/207
+
+* Written in portable C++. C++-11 with STL dependency only.
+  * [x] macOS + clang(LLVM)
+  * [x] iOS + clang
+  * [x] Linux + gcc/clang
+  * [x] Windows + MinGW
+  * [x] Windows + Visual Studio 2015 Update 3 or later.
+    * Visual Studio 2013 is not supported since they have limited C++11 support and failed to compile `json.hpp`.
+  * [x] Android NDK
+  * [x] Android + CrystaX(NDK drop-in replacement) GCC
+  * [x] Web using Emscripten(LLVM)
+* Moderate parsing time and memory consumption.
+* glTF specification v2.0.0
+  * [x] ASCII glTF
+    * [x] Load
+    * [x] Save
+  * [x] Binary glTF(GLB)
+    * [x] Load
+    * [x] Save(.bin embedded .glb)
+* Buffers
+  * [x] Parse BASE64 encoded embedded buffer data(DataURI).
+  * [x] Load `.bin` file.
+* Image(Using stb_image)
+  * [x] Parse BASE64 encoded embedded image data(DataURI).
+  * [x] Load external image file.
+  * [x] Load PNG(8bit and 16bit)
+  * [x] Load JPEG(8bit only)
+  * [x] Load BMP
+  * [x] Load GIF
+  * [x] Custom Image decoder callback(e.g. for decoding OpenEXR image)
+* Morph traget
+  * [x] Sparse accessor
+* Load glTF from memory
+* Custom callback handler
+  * [x] Image load
+  * [x] Image save
+* Extensions
+  * [x] Draco mesh decoding
+  * [ ] Draco mesh encoding
+
+## Note on extension property
+
+In extension(`ExtensionMap`), JSON number value is parsed as int or float(number) and stored as `tinygltf::Value` object. If you want a floating point value from `tinygltf::Value`, use `GetNumberAsDouble()` method.
+
+`IsNumber()` returns true if the underlying value is an int value or a floating point value.
+
+## Examples
+
+* [glview](examples/glview) : Simple glTF geometry viewer.
+* [validator](examples/validator) : Simple glTF validator with JSON schema.
+* [basic](examples/basic) : Basic glTF viewer with texturing support.
+* [build-gltf](examples/build-gltf) : Build simple glTF scene from a scratch.
+
+### WASI/WASM build
+
+Users who want to run TinyGLTF securely and safely(e.g. need to handle malcious glTF file to serve online glTF conver),
+I recommend to build TinyGLTF for WASM target.
+WASI build example is located in [wasm](wasm) .
+
+## Projects using TinyGLTF
+
+* px_render Single header C++ Libraries for Thread Scheduling, Rendering, and so on... https://github.com/pplux/px
+* Physical based rendering with Vulkan using glTF 2.0 models https://github.com/SaschaWillems/Vulkan-glTF-PBR
+* GLTF loader plugin for OGRE 2.1. Support for PBR materials via HLMS/PBS https://github.com/Ybalrid/Ogre_glTF
+* [TinyGltfImporter](http://doc.magnum.graphics/magnum/classMagnum_1_1Trade_1_1TinyGltfImporter.html) plugin for [Magnum](https://github.com/mosra/magnum), a lightweight and modular C++11/C++14 graphics middleware for games and data visualization.
+* [Diligent Engine](https://github.com/DiligentGraphics/DiligentEngine) - A modern cross-platform low-level graphics library and rendering framework
+* Lighthouse 2: a rendering framework for real-time ray tracing / path tracing experiments. https://github.com/jbikker/lighthouse2
+* [QuickLook GLTF](https://github.com/toshiks/glTF-quicklook) - quicklook plugin for macos. Also SceneKit wrapper for tinygltf.
+* [GlslViewer](https://github.com/patriciogonzalezvivo/glslViewer) - live GLSL coding for MacOS and Linux
+* [Vulkan-Samples](https://github.com/KhronosGroup/Vulkan-Samples) - The Vulkan Samples is collection of resources to help you develop optimized Vulkan applications.
+* [TDME2](https://github.com/andreasdr/tdme2) - TDME2 - ThreeDeeMiniEngine2 is a lightweight 3D engine including tools suited for 3D game development using C++11
+* [SanityEngine](https://github.com/DethRaid/SanityEngine) - A C++/D3D12 renderer focused on the personal and professional development of its developer
+* [Open3D](http://www.open3d.org/) - A Modern Library for 3D Data Processing
+* [Supernova Engine](https://github.com/supernovaengine/supernova) - Game engine for 2D and 3D projects with Lua or C++ in data oriented design.
+* [Wicked Engine<img src="https://github.com/turanszkij/WickedEngine/blob/master/Content/logo_small.png" width="28px" align="center"/>](https://github.com/turanszkij/WickedEngine) - 3D engine with modern graphics
+* Your projects here! (Please send PR)
+
+## TODOs
+
+* [ ] Robust URI decoding/encoding. https://github.com/syoyo/tinygltf/issues/369
+* [ ] Mesh Compression/decompression(Open3DGC, etc)
+  * [x] Load Draco compressed mesh
+  * [ ] Save Draco compressed mesh
+  * [ ] Open3DGC?
+* [x] Support `extensions` and `extras` property
+* [ ] HDR image?
+  * [ ] OpenEXR extension through TinyEXR.
+* [ ] 16bit PNG support in Serialization
+* [ ] Write example and tests for `animation` and `skin`
+
+### Optional
+
+* [ ] Write C++ code generator which emits C++ code from JSON schema for robust parsing?
+
 ## Licenses
 
-TinyGLTF is licensed under MIT license. See [LICENSE](LICENSE).
+TinyGLTF is licensed under MIT license.
 
-TinyGLTF v3 uses the following third party code:
+TinyGLTF uses the following third party libraries.
 
-* fast_float (JSON number parsing, in `tinygltf_json_c.h`): Copyright (c) 2021 The fast_float authors. Apache License 2.0 / MIT / Boost 1.0.
-* dragonbox (JSON number serialization, in `tinygltf_json_c.h`): Copyright 2020-2024 Junekey Jeon. Apache 2.0 with LLVM exceptions / Boost 1.0.
-* stb_image.h (optional, `TINYGLTF3_ENABLE_STB_IMAGE`) : public domain image loader - [Github link](https://github.com/nothings/stb/blob/master/stb_image.h)
+* json.hpp : Copyright (c) 2013-2017 Niels Lohmann. MIT license.
+* base64 : Copyright (C) 2004-2008 René Nyffenegger
+* stb_image.h : v2.08 - public domain image loader - [Github link](https://github.com/nothings/stb/blob/master/stb_image.h)
+* stb_image_write.h : v1.09 - public domain image writer - [Github link](https://github.com/nothings/stb/blob/master/stb_image_write.h)
+
+
+## Build and example
+
+Copy `stb_image.h`, `stb_image_write.h`, `json.hpp` and `tiny_gltf.h` to your project.
+
+### Loading glTF 2.0 model
+
+```c++
+// Define these only in *one* .cc file.
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+// #define TINYGLTF_NOEXCEPTION // optional. disable exception handling.
+#include "tiny_gltf.h"
+
+using namespace tinygltf;
+
+Model model;
+TinyGLTF loader;
+std::string err;
+std::string warn;
+
+bool ret = loader.LoadASCIIFromFile(&model, &err, &warn, argv[1]);
+//bool ret = loader.LoadBinaryFromFile(&model, &err, &warn, argv[1]); // for binary glTF(.glb)
+
+if (!warn.empty()) {
+  printf("Warn: %s\n", warn.c_str());
+}
+
+if (!err.empty()) {
+  printf("Err: %s\n", err.c_str());
+}
+
+if (!ret) {
+  printf("Failed to parse glTF\n");
+  return -1;
+}
+```
+
+#### Loader options
+
+* `TinyGLTF::SetPreserveimageChannels(bool onoff)`. `true` to preserve image channels as stored in image file for loaded image. `false` by default for backward compatibility(image channels are widen to `RGBA` 4 channels). Effective only when using builtin image loader(STB image loader).
+
+## Compile options
+
+* `TINYGLTF_NOEXCEPTION` : Disable C++ exception in JSON parsing. You can use `-fno-exceptions` or by defining the symbol `JSON_NOEXCEPTION` and `TINYGLTF_NOEXCEPTION`  to fully remove C++ exception codes when compiling TinyGLTF.
+* `TINYGLTF_NO_STB_IMAGE` : Do not load images with stb_image. Instead use `TinyGLTF::SetImageLoader(LoadimageDataFunction LoadImageData, void *user_data)` to set a callback for loading images.
+* `TINYGLTF_NO_STB_IMAGE_WRITE` : Do not write images with stb_image_write. Instead use `TinyGLTF::SetImageWriter(WriteimageDataFunction WriteImageData, void *user_data)` to set a callback for writing images.
+* `TINYGLTF_NO_EXTERNAL_IMAGE` : Do not try to load external image file. This option would be helpful if you do not want to load image files during glTF parsing.
+* `TINYGLTF_ANDROID_LOAD_FROM_ASSETS`: Load all files from packaged app assets instead of the regular file system. **Note:** You must pass a valid asset manager from your android app to `tinygltf::asset_manager` beforehand.
+* `TINYGLTF_ENABLE_DRACO`: Enable Draco compression. User must provide include path and link correspnding libraries in your project file.
+* `TINYGLTF_NO_INCLUDE_JSON `: Disable including `json.hpp` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
+* `TINYGLTF_NO_INCLUDE_RAPIDJSON `: Disable including RapidJson's header files from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
+* `TINYGLTF_NO_INCLUDE_STB_IMAGE `: Disable including `stb_image.h` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
+* `TINYGLTF_NO_INCLUDE_STB_IMAGE_WRITE `: Disable including `stb_image_write.h` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
+* `TINYGLTF_USE_RAPIDJSON` : Use RapidJSON as a JSON parser/serializer. RapidJSON files are not included in TinyGLTF repo. Please set an include path to RapidJSON if you enable this feature.
+* `TINYGLTF_USE_CPP14` : Use C++14 feature(requires C++14 compiler). This may give better performance than C++11.
+
+
+## CMake options
+
+You can add tinygltf using `add_subdirectory` feature.
+If you add tinygltf to your project using `add_subdirectory`, it would be better to set `TINYGLTF_HEADER_ONLY` on(just add an include path to tinygltf) and `TINYGLTF_INSTALL` off(Which does not install tinygltf files).
+
+```
+// Your project's CMakeLists.txt
+...
+
+set(TINYGLTF_HEADER_ONLY ON CACHE INTERNAL "" FORCE)
+set(TINYGLTF_INSTALL OFF CACHE INTERNAL "" FORCE)
+add_subdirectory(/path/to/tinygltf)
+```
+
+NOTE: Using tinygltf as a submodule doesn't automatically add the headers to your include path (as standard for many libraries). To get this functionality, add the following to the CMakeLists.txt file from above:
+
+```
+target_include_directories(${PROJECT_NAME} PRIVATE "/path/to/tinygltf")
+```
+
+### Saving gltTF 2.0 model
+
+* Buffers.
+  * [x] To file
+  * [x] Embedded
+  * [ ] Draco compressed?
+* [x] Images
+  * [x] To file
+  * [x] Embedded
+* Binary(.glb)
+  * [x] .bin embedded single .glb
+  * [ ] External .bin
+
+## Running tests.
+
+### glTF parsing test
+
+#### Setup
+
+Python required.
+Git clone https://github.com/KhronosGroup/glTF-Sample-Models to your local dir.
+
+#### Run parsing test
+
+After building `loader_example`, edit `test_runner.py`, then,
+
+```bash
+$ python test_runner.py
+```
+
+### Unit tests
+
+```bash
+$ cd tests
+$ make
+$ ./tester
+$ ./tester_noexcept
+```
+
+### Fuzzing tests
+
+See `tests/fuzzer` for details.
+
+After running fuzzer on Ryzen9 3950X a week, at least `LoadASCIIFromString` looks safe except for out-of-memory error in Fuzzer.
+We may be better to introduce bounded memory size checking when parsing glTF data.
+
+## Third party licenses
+
+* json.hpp : Licensed under the MIT License <http://opensource.org/licenses/MIT>. Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
+* stb_image : Public domain.
+* catch : Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. Distributed under the Boost Software License, Version 1.0.
+* RapidJSON : Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved. http://rapidjson.org/
+* dlib(uridecode, uriencode) : Copyright (C) 2003  Davis E. King Boost Software License 1.0. http://dlib.net/dlib/server/server_http.cpp.html

appveyor.yml

@@ -0,0 +1,18 @@
+version: 0.9.{build}
+
+image:
+  - Visual Studio 2015
+
+# scripts that runs after repo cloning.
+install:
+  - vcsetup.bat
+
+platform: x64
+configuration: Release
+
+build:
+  parallel: true
+  project: TinyGLTFSolution.sln
+
+after_build:
+  - examples.bat

attic/Makefile

@@ -1,13 +0,0 @@
-
-# Use this for strict compilation check(will work on clang 3.8+)
-#EXTRA_CXXFLAGS := -fsanitize=address -Wall -Werror -Weverything -Wno-c++11-long-long -Wno-c++98-compat
-
-# With draco
-# EXTRA_CXXFLAGS := -I../draco/src/ -I../draco/build -DTINYGLTF_ENABLE_DRACO -L../draco/build
-# EXTRA_LINKFLAGS := -L../draco/build/ -ldracodec -ldraco
-
-all:
-	clang++  $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o loader_example loader_example.cc $(EXTRA_LINKFLAGS)
-
-lint:
-	deps/cpplint.py tiny_gltf.h

attic/examples/anim-dump/AnimatedTriangle.gltf

@@ -1,117 +0,0 @@
-{
-  "scenes" : [
-    {
-      "nodes" : [ 0 ]
-    }
-  ],
-  
-  "nodes" : [
-    {
-      "mesh" : 0,
-      "rotation" : [ 0.0, 0.0, 0.0, 1.0 ]
-    }
-  ],
-  
-  "meshes" : [
-    {
-      "primitives" : [ {
-        "attributes" : {
-          "POSITION" : 1
-        },
-        "indices" : 0
-      } ]
-    }
-  ],
-  
-  "animations": [
-    {
-      "samplers" : [
-        {
-          "input" : 2,
-          "interpolation" : "LINEAR",
-          "output" : 3
-        }
-      ],
-      "channels" : [ {
-        "sampler" : 0,
-        "target" : {
-          "node" : 0,
-          "path" : "rotation"
-        }
-      } ]
-    }
-  ],
-
-  "buffers" : [
-    {
-      "uri" : "data:application/octet-stream;base64,AAABAAIAAAAAAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAAAAAACAPwAAAAA=",
-      "byteLength" : 44
-    },
-    {
-      "uri" : "data:application/octet-stream;base64,AAAAAAAAgD4AAAA/AABAPwAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAD0/TQ/9P00PwAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAPT9ND/0/TS/AAAAAAAAAAAAAAAAAACAPw==",
-      "byteLength" : 100
-    }
-  ],
-  "bufferViews" : [
-    {
-      "buffer" : 0,
-      "byteOffset" : 0,
-      "byteLength" : 6,
-      "target" : 34963
-    },
-    {
-      "buffer" : 0,
-      "byteOffset" : 8,
-      "byteLength" : 36,
-      "target" : 34962
-    },
-    {
-      "buffer" : 1,
-      "byteOffset" : 0,
-      "byteLength" : 100
-    }
-  ],
-  "accessors" : [
-    {
-      "bufferView" : 0,
-      "byteOffset" : 0,
-      "componentType" : 5123,
-      "count" : 3,
-      "type" : "SCALAR",
-      "max" : [ 2 ],
-      "min" : [ 0 ]
-    },
-    {
-      "bufferView" : 1,
-      "byteOffset" : 0,
-      "componentType" : 5126,
-      "count" : 3,
-      "type" : "VEC3",
-      "max" : [ 1.0, 1.0, 0.0 ],
-      "min" : [ 0.0, 0.0, 0.0 ]
-    },
-    {
-      "bufferView" : 2,
-      "byteOffset" : 0,
-      "componentType" : 5126,
-      "count" : 5,
-      "type" : "SCALAR",
-      "max" : [ 1.0 ],
-      "min" : [ 0.0 ]
-    },
-    {
-      "bufferView" : 2,
-      "byteOffset" : 20,
-      "componentType" : 5126,
-      "count" : 5,
-      "type" : "VEC4",
-      "max" : [ 0.0, 0.0, 1.0, 1.0 ],
-      "min" : [ 0.0, 0.0, 0.0, -0.707 ]
-    }
-  ],
-  
-  "asset" : {
-    "version" : "2.0"
-  }
-  
-}

attic/examples/audio/LICENSE.dr_mp3

@@ -1,47 +0,0 @@
-This software is available as a choice of the following licenses. Choose
-whichever you prefer.
-
-===============================================================================
-ALTERNATIVE 1 - Public Domain (www.unlicense.org)
-===============================================================================
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <http://unlicense.org/>
-
-===============================================================================
-ALTERNATIVE 2 - MIT No Attribution
-===============================================================================
-Copyright 2020 David Reid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

attic/examples/audio/Makefile

@@ -1,2 +0,0 @@
-all:
-	clang++ -O1 -g -I../../ main.cc

attic/examples/audio/README.md

@@ -1,3 +0,0 @@
-Simple example playing embedded audio data thorough OMI_audio_emitter.
-
-Supported audio file: mp3

attic/examples/audio/main.cc

@@ -1,67 +0,0 @@
-#define TINYGLTF_IMPLEMENTATION
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "tiny_gltf.h"
-
-#define DR_MP3_IMPLEMENTATION
-#include "dr_mp3.h"
-
-#include <iostream>
-
-static std::string GetFilePathExtension(const std::string &FileName) {
-  if (FileName.find_last_of(".") != std::string::npos)
-    return FileName.substr(FileName.find_last_of(".") + 1);
-  return "";
-}
-
-int main(int argc, char **argv) {
-
-  if (argc < 2) {
-    std::cout << "gltf_audio input.gltf/.glb" << std::endl;
-  }
-
-  float scale = 1.0f;
-  if (argc > 2) {
-    scale = atof(argv[2]);
-  }
-
-  tinygltf::Model model;
-  tinygltf::TinyGLTF loader;
-  std::string err;
-  std::string warn;
-
-#ifdef _WIN32
-#ifdef _DEBUG
-  std::string input_filename(argv[1] ? argv[1]
-                                     : "../../../models/Cube/Cube.gltf");
-#endif
-#else
-  std::string input_filename(argv[1] ? argv[1] : "../../models/Cube/Cube.gltf");
-#endif
-
-  std::string ext = GetFilePathExtension(input_filename);
-
-  bool ret = false;
-  if (ext.compare("glb") == 0) {
-    // assume binary glTF.
-    ret =
-        loader.LoadBinaryFromFile(&model, &err, &warn, input_filename.c_str());
-  } else {
-    // assume ascii glTF.
-    ret = loader.LoadASCIIFromFile(&model, &err, &warn, input_filename.c_str());
-  }
-
-  if (!warn.empty()) {
-    printf("Warn: %s\n", warn.c_str());
-  }
-
-  if (!err.empty()) {
-    printf("ERR: %s\n", err.c_str());
-  }
-  if (!ret) {
-    printf("Failed to load .glTF : %s\n", argv[1]);
-    exit(-1);
-  }
-
-  return EXIT_SUCCESS;
-}

attic/examples/basic/Makefile

@@ -1,61 +0,0 @@
-# GNU Make workspace makefile autogenerated by Premake
-
-ifndef config
-  config=debug_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-ifeq ($(config),debug_native)
-  basic_viewer_config = debug_native
-endif
-ifeq ($(config),debug_x64)
-  basic_viewer_config = debug_x64
-endif
-ifeq ($(config),debug_x32)
-  basic_viewer_config = debug_x32
-endif
-ifeq ($(config),release_native)
-  basic_viewer_config = release_native
-endif
-ifeq ($(config),release_x64)
-  basic_viewer_config = release_x64
-endif
-ifeq ($(config),release_x32)
-  basic_viewer_config = release_x32
-endif
-
-PROJECTS := basic_viewer
-
-.PHONY: all clean help $(PROJECTS) 
-
-all: $(PROJECTS)
-
-basic_viewer:
-ifneq (,$(basic_viewer_config))
-	@echo "==== Building basic_viewer ($(basic_viewer_config)) ===="
-	@${MAKE} --no-print-directory -C . -f basic_viewer.make config=$(basic_viewer_config)
-endif
-
-clean:
-	@${MAKE} --no-print-directory -C . -f basic_viewer.make clean
-
-help:
-	@echo "Usage: make [config=name] [target]"
-	@echo ""
-	@echo "CONFIGURATIONS:"
-	@echo "  debug_native"
-	@echo "  debug_x64"
-	@echo "  debug_x32"
-	@echo "  release_native"
-	@echo "  release_x64"
-	@echo "  release_x32"
-	@echo ""
-	@echo "TARGETS:"
-	@echo "   all (default)"
-	@echo "   clean"
-	@echo "   basic_viewer"
-	@echo ""
-	@echo "For more information, see https://github.com/premake/premake-core/wiki"

attic/examples/basic/basic_viewer.make

@@ -1,250 +0,0 @@
-# GNU Make project makefile autogenerated by Premake
-
-ifndef config
-  config=debug_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-.PHONY: clean prebuild prelink
-
-ifeq ($(config),debug_native)
-  RESCOMP = windres
-  TARGETDIR = bin/native/Debug
-  TARGET = $(TARGETDIR)/basic_viewer
-  OBJDIR = obj/native/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../.. -I../common/glm
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -g -Wall -Wextra -fsanitize=address
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -g -Wall -Wextra -std=c++11 -fsanitize=address
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -fsanitize=address `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),debug_x64)
-  RESCOMP = windres
-  TARGETDIR = bin/x64/Debug
-  TARGET = $(TARGETDIR)/basic_viewer
-  OBJDIR = obj/x64/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../.. -I../common/glm
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -g -Wall -Wextra -fsanitize=address
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -g -Wall -Wextra -std=c++11 -fsanitize=address
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 -fsanitize=address `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),debug_x32)
-  RESCOMP = windres
-  TARGETDIR = bin/x32/Debug
-  TARGET = $(TARGETDIR)/basic_viewer
-  OBJDIR = obj/x32/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../.. -I../common/glm
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -g -Wall -Wextra -fsanitize=address
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -g -Wall -Wextra -std=c++11 -fsanitize=address
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 -fsanitize=address `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_native)
-  RESCOMP = windres
-  TARGETDIR = bin/native/Release
-  TARGET = $(TARGETDIR)/basic_viewer
-  OBJDIR = obj/native/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../.. -I../common/glm
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -O2 -Wall -Wextra -fsanitize=address
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -O2 -Wall -Wextra -std=c++11 -fsanitize=address
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -s -fsanitize=address `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_x64)
-  RESCOMP = windres
-  TARGETDIR = bin/x64/Release
-  TARGET = $(TARGETDIR)/basic_viewer
-  OBJDIR = obj/x64/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../.. -I../common/glm
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -Wall -Wextra -fsanitize=address
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -Wall -Wextra -std=c++11 -fsanitize=address
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 -s -fsanitize=address `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_x32)
-  RESCOMP = windres
-  TARGETDIR = bin/x32/Release
-  TARGET = $(TARGETDIR)/basic_viewer
-  OBJDIR = obj/x32/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../.. -I../common/glm
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -Wall -Wextra -fsanitize=address
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -Wall -Wextra -std=c++11 -fsanitize=address
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 -s -fsanitize=address `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-OBJECTS := \
-	$(OBJDIR)/main.o \
-	$(OBJDIR)/shaders.o \
-	$(OBJDIR)/window.o \
-
-RESOURCES := \
-
-CUSTOMFILES := \
-
-SHELLTYPE := posix
-ifeq (.exe,$(findstring .exe,$(ComSpec)))
-	SHELLTYPE := msdos
-endif
-
-$(TARGET): $(GCH) ${CUSTOMFILES} $(OBJECTS) $(LDDEPS) $(RESOURCES) | $(TARGETDIR)
-	@echo Linking basic_viewer
-	$(SILENT) $(LINKCMD)
-	$(POSTBUILDCMDS)
-
-$(CUSTOMFILES): | $(OBJDIR)
-
-$(TARGETDIR):
-	@echo Creating $(TARGETDIR)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(TARGETDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(TARGETDIR))
-endif
-
-$(OBJDIR):
-	@echo Creating $(OBJDIR)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-
-clean:
-	@echo Cleaning basic_viewer
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) rm -f  $(TARGET)
-	$(SILENT) rm -rf $(OBJDIR)
-else
-	$(SILENT) if exist $(subst /,\\,$(TARGET)) del $(subst /,\\,$(TARGET))
-	$(SILENT) if exist $(subst /,\\,$(OBJDIR)) rmdir /s /q $(subst /,\\,$(OBJDIR))
-endif
-
-prebuild:
-	$(PREBUILDCMDS)
-
-prelink:
-	$(PRELINKCMDS)
-
-ifneq (,$(PCH))
-$(OBJECTS): $(GCH) $(PCH) | $(OBJDIR)
-$(GCH): $(PCH) | $(OBJDIR)
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) -x c++-header $(ALL_CXXFLAGS) -o "$@" -MF "$(@:%.gch=%.d)" -c "$<"
-else
-$(OBJECTS): | $(OBJDIR)
-endif
-
-$(OBJDIR)/main.o: main.cpp
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/shaders.o: shaders.cpp
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/window.o: window.cpp
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-
--include $(OBJECTS:%.o=%.d)
-ifneq (,$(PCH))
-  -include $(OBJDIR)/$(notdir $(PCH)).d
-endif

attic/examples/basic/cube.gltf

@@ -1,152 +0,0 @@
-{
-    "asset" : {
-        "generator" : "Khronos glTF Blender I/O v1.1.46",
-        "version" : "2.0"
-    },
-    "scene" : 0,
-    "scenes" : [
-        {
-            "name" : "Scene",
-            "nodes" : [
-                0,
-                1,
-                2
-            ]
-        }
-    ],
-    "nodes" : [
-        {
-            "mesh" : 0,
-            "name" : "Cube"
-        },
-        {
-            "name" : "Light",
-            "rotation" : [
-                0.16907575726509094,
-                0.7558803558349609,
-                -0.27217137813568115,
-                0.570947527885437
-            ],
-            "translation" : [
-                4.076245307922363,
-                5.903861999511719,
-                -1.0054539442062378
-            ]
-        },
-        {
-            "name" : "Camera",
-            "rotation" : [
-                0.483536034822464,
-                0.33687159419059753,
-                -0.20870360732078552,
-                0.7804827094078064
-            ],
-            "translation" : [
-                7.358891487121582,
-                4.958309173583984,
-                6.925790786743164
-            ]
-        }
-    ],
-    "materials" : [
-        {
-            "doubleSided" : true,
-            "emissiveFactor" : [
-                0,
-                0,
-                0
-            ],
-            "name" : "Material",
-            "pbrMetallicRoughness" : {
-                "baseColorFactor" : [
-                    0.800000011920929,
-                    0.800000011920929,
-                    0.800000011920929,
-                    1
-                ],
-                "metallicFactor" : 0,
-                "roughnessFactor" : 0.4000000059604645
-            }
-        }
-    ],
-    "meshes" : [
-        {
-            "name" : "Cube",
-            "primitives" : [
-                {
-                    "attributes" : {
-                        "POSITION" : 0,
-                        "NORMAL" : 1,
-                        "TEXCOORD_0" : 2
-                    },
-                    "indices" : 3,
-                    "material" : 0
-                }
-            ]
-        }
-    ],
-    "accessors" : [
-        {
-            "bufferView" : 0,
-            "componentType" : 5126,
-            "count" : 24,
-            "max" : [
-                1,
-                1,
-                1
-            ],
-            "min" : [
-                -1,
-                -1,
-                -1
-            ],
-            "type" : "VEC3"
-        },
-        {
-            "bufferView" : 1,
-            "componentType" : 5126,
-            "count" : 24,
-            "type" : "VEC3"
-        },
-        {
-            "bufferView" : 2,
-            "componentType" : 5126,
-            "count" : 24,
-            "type" : "VEC2"
-        },
-        {
-            "bufferView" : 3,
-            "componentType" : 5123,
-            "count" : 36,
-            "type" : "SCALAR"
-        }
-    ],
-    "bufferViews" : [
-        {
-            "buffer" : 0,
-            "byteLength" : 288,
-            "byteOffset" : 0
-        },
-        {
-            "buffer" : 0,
-            "byteLength" : 288,
-            "byteOffset" : 288
-        },
-        {
-            "buffer" : 0,
-            "byteLength" : 192,
-            "byteOffset" : 576
-        },
-        {
-            "buffer" : 0,
-            "byteLength" : 72,
-            "byteOffset" : 768
-        }
-    ],
-    "buffers" : [
-        {
-            "byteLength" : 840,
-            "uri" : "data:application/octet-stream;base64,AACAPwAAgD8AAIA/AACAPwAAgD8AAIC/AACAvwAAgD8AAIC/AACAvwAAgD8AAIA/AACAvwAAgD8AAIA/AACAvwAAgL8AAIA/AACAPwAAgL8AAIA/AACAPwAAgD8AAIA/AACAvwAAgD8AAIC/AACAvwAAgL8AAIC/AACAvwAAgL8AAIA/AACAvwAAgD8AAIA/AACAvwAAgL8AAIA/AACAvwAAgL8AAIC/AACAPwAAgL8AAIC/AACAPwAAgL8AAIA/AACAPwAAgD8AAIA/AACAPwAAgL8AAIA/AACAPwAAgL8AAIC/AACAPwAAgD8AAIC/AACAPwAAgD8AAIC/AACAPwAAgL8AAIC/AACAvwAAgL8AAIC/AACAvwAAgD8AAIC/AAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAgPwAAgD4AACA/AAAAPwAAYD8AAAA/AABgPwAAgD4AACA/AAAAAAAAwD4AAAAAAADAPgAAgD4AACA/AACAPgAAID8AAEA/AADAPgAAQD8AAMA+AACAPwAAID8AAIA/AAAAPgAAgD4AAAA+AAAAPwAAwD4AAAA/AADAPgAAgD4AACA/AACAPgAAwD4AAIA+AADAPgAAAD8AACA/AAAAPwAAID8AAAA/AADAPgAAAD8AAMA+AABAPwAAID8AAEA/AAABAAIAAAACAAMABAAFAAYABAAGAAcACAAJAAoACAAKAAsADAANAA4ADAAOAA8AEAARABIAEAASABMAFAAVABYAFAAWABcA"
-        }
-    ]
-}

attic/examples/build-gltf/create_triangle_gltf-light.cpp

@@ -1,129 +0,0 @@
-// An example of how to generate a gltf file from scratch. This example
-// was translated from the pygltlib documentation in the pypi project page,
-// which in turn is based on the Khronos Sample Models at:
-//
-// https://github.com/KhronosGroup/glTF-Sample-Models
-//
-// This example is released under the MIT license.
-//
-// 2021-02-25 Thu
-// Dov Grobgeld <dov.grobgeld@gmail.com>
-
-
-// Define these only in *one* .cc file.
-#define TINYGLTF_IMPLEMENTATION
-#define TINYGLTF_USE_RAPIDJSON
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-
-// #define TINYGLTF_NOEXCEPTION // optional. disable exception handling.
-#include "tiny_gltf.h"
-
-int main(int argc, char **argv)
-{
-  // Create a model with a single mesh and save it as a gltf file
-  tinygltf::Model m;
-  tinygltf::Scene scene;
-  tinygltf::Mesh mesh;
-  tinygltf::Primitive primitive;
-  tinygltf::Node node;
-  tinygltf::Buffer buffer;
-  tinygltf::BufferView bufferView1;
-  tinygltf::BufferView bufferView2;
-  tinygltf::Accessor accessor1;
-  tinygltf::Accessor accessor2;
-  tinygltf::Asset asset;
-
-  // This is the raw data buffer.
-  buffer.data = {
-    // 6 bytes of indices and two bytes of padding
-    0x00,0x00,0x01,0x00,0x02,0x00,0x00,0x00,
-    // 36 bytes of floating point numbers
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x3f,
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x3f,
-    0x00,0x00,0x00,0x00};
-
-  // "The indices of the vertices (ELEMENT_ARRAY_BUFFER) take up 6 bytes in the
-  // start of the buffer.
-  bufferView1.buffer = 0;
-  bufferView1.byteOffset=0;
-  bufferView1.byteLength=6;
-  bufferView1.target = TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER;
-
-  // The vertices take up 36 bytes (3 vertices * 3 floating points * 4 bytes)
-  // at position 8 in the buffer and are of type ARRAY_BUFFER
-  bufferView2.buffer = 0;
-  bufferView2.byteOffset=8;
-  bufferView2.byteLength=36;
-  bufferView2.target = TINYGLTF_TARGET_ARRAY_BUFFER;
-
-  // Describe the layout of bufferView1, the indices of the vertices
-  accessor1.bufferView = 0;
-  accessor1.byteOffset = 0;
-  accessor1.componentType = TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT;
-  accessor1.count = 3;
-  accessor1.type = TINYGLTF_TYPE_SCALAR;
-  accessor1.maxValues.push_back(2);
-  accessor1.minValues.push_back(0);
-
-  // Describe the layout of bufferView2, the vertices themself
-  accessor2.bufferView = 1;
-  accessor2.byteOffset = 0;
-  accessor2.componentType = TINYGLTF_COMPONENT_TYPE_FLOAT;
-  accessor2.count = 3;
-  accessor2.type = TINYGLTF_TYPE_VEC3;
-  accessor2.maxValues = {1.0, 1.0, 0.0};
-  accessor2.minValues = {0.0, 0.0, 0.0};
-
-  // Build the mesh primitive and add it to the mesh
-  primitive.indices = 0;                 // The index of the accessor for the vertex indices
-  primitive.attributes["POSITION"] = 1;  // The index of the accessor for positions
-  primitive.material = 0;
-  primitive.mode = TINYGLTF_MODE_TRIANGLES;
-  mesh.primitives.push_back(primitive);
-
-  // Other tie ups
-  node.mesh = 0;
-  scene.nodes.push_back(0); // Default scene
-
-  // Define the asset. The version is required
-  asset.version = "2.0";
-  asset.generator = "tinygltf";
-
-  // Now all that remains is to tie back all the loose objects into the
-  // our single model.
-  m.scenes.push_back(scene);
-  m.meshes.push_back(mesh);
-  m.nodes.push_back(node);
-  m.buffers.push_back(buffer);
-  m.bufferViews.push_back(bufferView1);
-  m.bufferViews.push_back(bufferView2);
-  m.accessors.push_back(accessor1);
-  m.accessors.push_back(accessor2);
-  m.asset = asset;
-
-  // Create a simple material
-  tinygltf::Material mat;
-  mat.pbrMetallicRoughness.baseColorFactor = {1.0f, 0.9f, 0.9f, 1.0f};
-  mat.doubleSided = true;
-  m.materials.push_back(mat);
-
-  // lights
-  tinygltf::Light dummyLight;
-  dummyLight.name = "bora";
-  m.lights.push_back(dummyLight);
-  tinygltf::Value dummyVal(3.14);
-  m.extensions.emplace("ext1", dummyVal);
-
-  // Save it to a file
-  tinygltf::TinyGLTF gltf;
-  gltf.WriteGltfSceneToFile(&m, "triangle.gltf",
-                           true, // embedImages
-                           true, // embedBuffers
-                           true, // pretty print
-                           false); // write binary
-
-  exit(0);
-}

attic/examples/build-gltf/triangle.gltf

@@ -1,94 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5123,
-      "count": 3,
-      "max": [
-        2
-      ],
-      "min": [
-        0
-      ],
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "componentType": 5126,
-      "count": 3,
-      "max": [
-        1.0,
-        1.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC3"
-    }
-  ],
-  "asset": {
-    "generator": "tinygltf",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 6,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 36,
-      "byteOffset": 8,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 44,
-      "uri": "data:application/octet-stream;base64,AAABAAIAAAAAAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAAAAAACAPwAAAAA="
-    }
-  ],
-  "materials": [
-    {
-      "doubleSided": true,
-      "pbrMetallicRoughness": {
-        "baseColorFactor": [
-          1.0,
-          0.8999999761581421,
-          0.8999999761581421,
-          1.0
-        ]
-      }
-    }
-  ],
-  "meshes": [
-    {
-      "primitives": [
-        {
-          "attributes": {
-            "POSITION": 1
-          },
-          "indices": 0,
-          "material": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0
-    }
-  ],
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ]
-}

attic/examples/glview/Makefile

@@ -1,61 +0,0 @@
-# GNU Make workspace makefile autogenerated by Premake
-
-ifndef config
-  config=debug_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-ifeq ($(config),debug_native)
-  glview_config = debug_native
-endif
-ifeq ($(config),debug_x64)
-  glview_config = debug_x64
-endif
-ifeq ($(config),debug_x32)
-  glview_config = debug_x32
-endif
-ifeq ($(config),release_native)
-  glview_config = release_native
-endif
-ifeq ($(config),release_x64)
-  glview_config = release_x64
-endif
-ifeq ($(config),release_x32)
-  glview_config = release_x32
-endif
-
-PROJECTS := glview
-
-.PHONY: all clean help $(PROJECTS) 
-
-all: $(PROJECTS)
-
-glview:
-ifneq (,$(glview_config))
-	@echo "==== Building glview ($(glview_config)) ===="
-	@${MAKE} --no-print-directory -C . -f glview.make config=$(glview_config)
-endif
-
-clean:
-	@${MAKE} --no-print-directory -C . -f glview.make clean
-
-help:
-	@echo "Usage: make [config=name] [target]"
-	@echo ""
-	@echo "CONFIGURATIONS:"
-	@echo "  debug_native"
-	@echo "  debug_x64"
-	@echo "  debug_x32"
-	@echo "  release_native"
-	@echo "  release_x64"
-	@echo "  release_x32"
-	@echo ""
-	@echo "TARGETS:"
-	@echo "   all (default)"
-	@echo "   clean"
-	@echo "   glview"
-	@echo ""
-	@echo "For more information, see https://github.com/premake/premake-core/wiki"

attic/examples/glview/glview.make

@@ -1,246 +0,0 @@
-# GNU Make project makefile autogenerated by Premake
-
-ifndef config
-  config=debug_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-.PHONY: clean prebuild prelink
-
-ifeq ($(config),debug_native)
-  RESCOMP = windres
-  TARGETDIR = bin/native/Debug
-  TARGET = $(TARGETDIR)/glview
-  OBJDIR = obj/native/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../.. -I../common
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -g -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -g -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),debug_x64)
-  RESCOMP = windres
-  TARGETDIR = bin/x64/Debug
-  TARGET = $(TARGETDIR)/glview
-  OBJDIR = obj/x64/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../.. -I../common
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -g -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -g -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),debug_x32)
-  RESCOMP = windres
-  TARGETDIR = bin/x32/Debug
-  TARGET = $(TARGETDIR)/glview
-  OBJDIR = obj/x32/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../.. -I../common
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -g -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -g -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_native)
-  RESCOMP = windres
-  TARGETDIR = bin/native/Release
-  TARGET = $(TARGETDIR)/glview
-  OBJDIR = obj/native/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../.. -I../common
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -O2 -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -O2 -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -s `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_x64)
-  RESCOMP = windres
-  TARGETDIR = bin/x64/Release
-  TARGET = $(TARGETDIR)/glview
-  OBJDIR = obj/x64/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../.. -I../common
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 -s `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_x32)
-  RESCOMP = windres
-  TARGETDIR = bin/x32/Release
-  TARGET = $(TARGETDIR)/glview
-  OBJDIR = obj/x32/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../.. -I../common
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 -s `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-OBJECTS := \
-	$(OBJDIR)/trackball.o \
-	$(OBJDIR)/glview.o \
-
-RESOURCES := \
-
-CUSTOMFILES := \
-
-SHELLTYPE := posix
-ifeq (.exe,$(findstring .exe,$(ComSpec)))
-	SHELLTYPE := msdos
-endif
-
-$(TARGET): $(GCH) ${CUSTOMFILES} $(OBJECTS) $(LDDEPS) $(RESOURCES) | $(TARGETDIR)
-	@echo Linking glview
-	$(SILENT) $(LINKCMD)
-	$(POSTBUILDCMDS)
-
-$(CUSTOMFILES): | $(OBJDIR)
-
-$(TARGETDIR):
-	@echo Creating $(TARGETDIR)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(TARGETDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(TARGETDIR))
-endif
-
-$(OBJDIR):
-	@echo Creating $(OBJDIR)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-
-clean:
-	@echo Cleaning glview
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) rm -f  $(TARGET)
-	$(SILENT) rm -rf $(OBJDIR)
-else
-	$(SILENT) if exist $(subst /,\\,$(TARGET)) del $(subst /,\\,$(TARGET))
-	$(SILENT) if exist $(subst /,\\,$(OBJDIR)) rmdir /s /q $(subst /,\\,$(OBJDIR))
-endif
-
-prebuild:
-	$(PREBUILDCMDS)
-
-prelink:
-	$(PRELINKCMDS)
-
-ifneq (,$(PCH))
-$(OBJECTS): $(GCH) $(PCH) | $(OBJDIR)
-$(GCH): $(PCH) | $(OBJDIR)
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) -x c++-header $(ALL_CXXFLAGS) -o "$@" -MF "$(@:%.gch=%.d)" -c "$<"
-else
-$(OBJECTS): | $(OBJDIR)
-endif
-
-$(OBJDIR)/trackball.o: ../common/trackball.cc
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/glview.o: glview.cc
-	@echo $(notdir $<)
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-
--include $(OBJECTS:%.o=%.d)
-ifneq (,$(PCH))
-  -include $(OBJDIR)/$(notdir $(PCH)).d
-endif

attic/examples/jsonnet/README.md

@@ -1,12 +0,0 @@
-Jsonnet representation of glTF
-
-https://jsonnet.org/
-
-# Benefit
-
-You can assign id programatically
-
-```
-{
-
-```

attic/examples/mesh-conv/LowPolyBake/cage_polygon.mtl

@@ -1,11 +0,0 @@
-newmtl hairSG
-Ka 0.000000 0.000000 0.000000
-Kd 0.000000 0.000000 0.000000
-Ks 0.000000 0.000000 0.000000
-Kt 1.000000 0.000000 0.000000
-Ke 0.000000 0.000000 0.000000
-Ns 1.000000
-Ni 1.000000
-illum 4
-map_Kd color.png
-

attic/examples/mesh-conv/face-nosubd.mtl

@@ -1,102 +0,0 @@
-newmtl _blinn1SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl blinn1SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-map_Kd skin_dif.tif
-Ni 1.00
-Ks 0.28 0.28 0.28
-newmtl eyeMTLSG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl eyebrows_hairTubeShader2SG1
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl eyelushes_hairTubeShader3SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl face_eye_mouth_blinn2SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-map_Kd HWI_male_gum_dif.jpg
-Ni 1.00
-Ks 0.50 0.50 0.50
-newmtl hairFrontHair_hairTubeShader1SG1
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl hairMainHair_hairTubeShader1SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl hairStrayHair_hairTubeShader1SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl hairTopFix_hairTubeShader1SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl hairTopFix_surfaceShader13SG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl initialShadingGroup
-illum 4
-Kd 0.37 0.37 0.37
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 1.00
-newmtl irisMTLSG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl skinSG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-map_Kd skin_dif.tif
-Ni 1.00
-Ks 0.14 0.14 0.14
-newmtl teethMTLSG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00
-newmtl tongueMTLSG
-illum 4
-Kd 0.00 0.00 0.00
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 0.00

attic/examples/mesh-conv/hairsimtest/sim.json

@@ -1,11 +0,0 @@
-{
-	"sim": {
-		"version": 1,
-		"id": "sim",
-		"name": "1",
-		"kind": "Puppeteer",
-		"mood": null,
-		"postPlaybackMood": null,
-		"duration": 3.75
-	}
-}

attic/examples/mesh-conv/hairskintest/lowpoly.json

@@ -1,11 +0,0 @@
-{
-	"lowpoly": {
-		"version": 1,
-		"id": "lowpoly",
-		"name": "1",
-		"kind": "Puppeteer",
-		"mood": null,
-		"postPlaybackMood": null,
-		"duration": 62.5
-	}
-}

attic/examples/mesh-conv/output.gltf

@@ -1,128 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5125,
-      "count": 11532,
-      "max": [
-        11531.0
-      ],
-      "min": [
-        0.0
-      ],
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "componentType": 5126,
-      "count": 11532,
-      "max": [
-        14679.0,
-        1.0,
-        9728.0
-      ],
-      "min": [
-        14678.0,
-        0.0,
-        9216.0
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "componentType": 5126,
-      "count": 11532,
-      "max": [
-        1.0,
-        1.0,
-        1.0
-      ],
-      "min": [
-        -1.0,
-        -1.0,
-        -1.0
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "componentType": 5126,
-      "count": 11532,
-      "max": [
-        0.96875,
-        0.96875
-      ],
-      "min": [
-        0.03125,
-        0.03125
-      ],
-      "type": "VEC2"
-    }
-  ],
-  "asset": {
-    "generator": "mesh-modify",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 46128,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 138384,
-      "byteOffset": 46128,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 138384,
-      "byteOffset": 184512,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 92256,
-      "byteOffset": 322896,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 415152,
-      "name": "bufffer0",
-      "uri": "output.bin"
-    }
-  ],
-  "meshes": [
-    {
-      "name": "r.28.18.obj",
-      "primitives": [
-        {
-          "attributes": {
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TEXCOORD_0": 3
-          },
-          "indices": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "mesh"
-    }
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ]
-}

attic/examples/mesh-conv/plane.gltf

@@ -1,185 +0,0 @@
-{
-    "asset": {
-        "copyright": "(C)2020 syoyo",
-        "generator": "maya2glTF master d293e09",
-        "version": "2.0"
-    },
-    "scenes": [
-        {
-            "nodes": [
-                0
-            ]
-        }
-    ],
-    "scene": 0,
-    "nodes": [
-        {
-            "name": "pPlane1",
-            "mesh": 0
-        }
-    ],
-    "meshes": [
-        {
-            "name": "pPlaneShape1",
-            "extras": {
-                "targetNames": []
-            },
-            "primitives": [
-                {
-                    "attributes": {
-                        "NORMAL": 1,
-                        "POSITION": 2,
-                        "TANGENT": 3,
-                        "TEXCOORD_0": 4
-                    },
-                    "indices": 0,
-                    "mode": 4,
-                    "material": 0
-                }
-            ]
-        }
-    ],
-    "materials": [
-        {
-            "name": "lambert1",
-            "pbrMetallicRoughness": {
-                "baseColorFactor": [
-                    0.4000000059604645,
-                    0.4000000059604645,
-                    0.4000000059604645,
-                    1.0
-                ],
-                "metallicFactor": 0.0,
-                "roughnessFactor": 1.0
-            }
-        }
-    ],
-    "accessors": [
-        {
-            "name": "pPlaneShape1#0/indices",
-            "bufferView": 0,
-            "byteOffset": 0,
-            "componentType": 5123,
-            "count": 24,
-            "max": [
-                8
-            ],
-            "min": [
-                0
-            ],
-            "type": "SCALAR"
-        },
-        {
-            "name": "pPlaneShape1#0/vertices/NORMAL",
-            "bufferView": 1,
-            "byteOffset": 0,
-            "componentType": 5126,
-            "count": 9,
-            "max": [
-                0.0,
-                1.0,
-                0.0
-            ],
-            "min": [
-                0.0,
-                1.0,
-                0.0
-            ],
-            "type": "VEC3"
-        },
-        {
-            "name": "pPlaneShape1#0/vertices/POSITION",
-            "bufferView": 1,
-            "byteOffset": 108,
-            "componentType": 5126,
-            "count": 9,
-            "max": [
-                0.5,
-                0.0,
-                0.5
-            ],
-            "min": [
-                -0.5,
-                0.0,
-                -0.5
-            ],
-            "type": "VEC3"
-        },
-        {
-            "name": "pPlaneShape1#0/vertices/TANGENT",
-            "bufferView": 2,
-            "byteOffset": 0,
-            "componentType": 5126,
-            "count": 9,
-            "max": [
-                1.0,
-                0.0,
-                0.0,
-                1.0
-            ],
-            "min": [
-                1.0,
-                0.0,
-                0.0,
-                1.0
-            ],
-            "type": "VEC4"
-        },
-        {
-            "name": "pPlaneShape1#0/vertices/TEXCOORD_0",
-            "bufferView": 3,
-            "byteOffset": 0,
-            "componentType": 5126,
-            "count": 9,
-            "max": [
-                1.0,
-                1.0
-            ],
-            "min": [
-                0.0,
-                0.0
-            ],
-            "type": "VEC2"
-        }
-    ],
-    "bufferViews": [
-        {
-            "name": "plane/data/indices-2",
-            "buffer": 0,
-            "byteOffset": 432,
-            "byteLength": 48,
-            "target": 34963
-        },
-        {
-            "name": "plane/data/vertices-12",
-            "buffer": 0,
-            "byteOffset": 144,
-            "byteLength": 216,
-            "byteStride": 12,
-            "target": 34962
-        },
-        {
-            "name": "plane/data/vertices-16",
-            "buffer": 0,
-            "byteOffset": 0,
-            "byteLength": 144,
-            "byteStride": 16,
-            "target": 34962
-        },
-        {
-            "name": "plane/data/vertices-8",
-            "buffer": 0,
-            "byteOffset": 360,
-            "byteLength": 72,
-            "byteStride": 8,
-            "target": 34962
-        }
-    ],
-    "buffers": [
-        {
-            "name": "plane/data",
-            "byteLength": 480,
-            "uri": "plane0.bin"
-        }
-    ]
-}

attic/examples/mesh-conv/runner.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-./mesh-conv --op gltf2obj -i ../hairsimtest/sim.gltf
-
-#./mesh-conv --op obj2gltf --verbose -i hair_bfShape_0.obj
-./mesh-conv --op obj2gltf -i hair_bfShape_1.obj -o hair_bfShape_1.gltf
-

attic/examples/mesh-conv/sandbox/Cube-textransform.gltf

@@ -1,224 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "byteOffset": 0,
-      "componentType": 5123,
-      "count": 36,
-      "max": [
-        35
-      ],
-      "min": [
-        0
-      ],
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1,
-        1.000001
-      ],
-      "min": [
-        -1,
-        -1,
-        -1
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1,
-        1
-      ],
-      "min": [
-        -1,
-        -1,
-        -1
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        -0,
-        -0,
-        1
-      ],
-      "min": [
-        0,
-        -0,
-        -1,
-        -1
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 4,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1
-      ],
-      "min": [
-        -1,
-        -1
-      ],
-      "type": "VEC2"
-    }
-  ],
-  "asset": {
-    "generator": "VKTS glTF 2.0 exporter",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 72,
-      "byteOffset": 0,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 432,
-      "byteOffset": 72,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 432,
-      "byteOffset": 504,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 576,
-      "byteOffset": 936,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 288,
-      "byteOffset": 1512,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 1800,
-      "uri": "Cube.bin"
-    }
-  ],
-  "images": [
-    {
-      "0comment": "Use Cube_MetallicRoughness.png to reduce scene filesize",
-      "uri": "Cube_MetallicRoughness.png"
-    },
-    {
-      "uri": "Cube_MetallicRoughness.png"
-    }
-  ],
-  "materials": [
-    {
-      "emissiveTexture": {
-        "index": 0,
-        "extensions": {
-          "KHR_texture_transform": {
-            "offset": [
-              0,
-              1
-            ],
-            "scale": [
-              1,
-              -1
-            ]
-          }
-        }
-      }
-    },
-    {
-      "name": "Cube",
-      "pbrMetallicRoughness": {
-        "baseColorTexture": {
-          "index": 0
-        },
-        "metallicRoughnessTexture": {
-          "index": 1,
-          "extensions": {
-            "KHR_texture_transform": {
-              "offset": [
-                0,
-                1
-              ],
-              "rotation": 1.57079632679,
-              "scale": [
-                0.5,
-                0.5
-              ]
-            }
-          }
-        }
-      }
-    }
-  ],
-  "meshes": [
-    {
-      "name": "Cube",
-      "primitives": [
-        {
-          "attributes": {
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TANGENT": 3,
-            "TEXCOORD_0": 4
-          },
-          "indices": 0,
-          "material": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "Cube"
-    }
-  ],
-  "samplers": [
-    {}
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ],
-  "textures": [
-    {
-      "sampler": 0,
-      "source": 0
-    },
-    {
-      "sampler": 0,
-      "source": 1
-    }
-  ]
-}

attic/examples/mesh-conv/sandbox/Cube-textransform1.gltf

@@ -1,224 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "byteOffset": 0,
-      "componentType": 5123,
-      "count": 36,
-      "max": [
-        35
-      ],
-      "min": [
-        0
-      ],
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1,
-        1.000001
-      ],
-      "min": [
-        -1,
-        -1,
-        -1
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1,
-        1
-      ],
-      "min": [
-        -1,
-        -1,
-        -1
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        -0,
-        -0,
-        1
-      ],
-      "min": [
-        0,
-        -0,
-        -1,
-        -1
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 4,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1
-      ],
-      "min": [
-        -1,
-        -1
-      ],
-      "type": "VEC2"
-    }
-  ],
-  "asset": {
-    "generator": "VKTS glTF 2.0 exporter",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 72,
-      "byteOffset": 0,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 432,
-      "byteOffset": 72,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 432,
-      "byteOffset": 504,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 576,
-      "byteOffset": 936,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 288,
-      "byteOffset": 1512,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 1800,
-      "uri": "Cube.bin"
-    }
-  ],
-  "images": [
-    {
-      "0comment": "Use Cube_MetallicRoughness.png to reduce scene filesize",
-      "uri": "Cube_MetallicRoughness.png"
-    },
-    {
-      "uri": "Cube_MetallicRoughness.png"
-    }
-  ],
-  "materials": [
-    {
-      "emissiveTexture": {
-        "index": 0,
-        "extensions": {
-          "KHR_texture_transform": {
-            "offset": [
-              0,
-              1
-            ],
-            "scale": [
-              1,
-              -1
-            ]
-          }
-        }
-      }
-    },
-    {
-      "name": "Cube",
-      "pbrMetallicRoughness": {
-        "baseColorTexture": {
-          "index": 0
-        },
-        "metallicRoughnessTexture": {
-          "index": 1,
-          "extensions": {
-            "KHR_texture_transform": {
-              "offset": [
-                0,
-                1
-              ],
-              "rotation": 1.57079632679,
-              "scale": [
-                0.5,
-                0.5
-              ]
-            }
-          }
-        }
-      }
-    }
-  ],
-  "meshes": [
-    {
-      "name": "Cube",
-      "primitives": [
-        {
-          "attributes": {
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TANGENT": 3,
-            "TEXCOORD_0": 4
-          },
-          "indices": 0,
-          "material": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "Cube"
-    }
-  ],
-  "samplers": [
-    {}
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ],
-  "textures": [
-    {
-      "sampler": 0,
-      "source": 0
-    },
-    {
-      "sampler": 0,
-      "source": 1
-    }
-  ]
-}

attic/examples/mesh-conv/sandbox/Makefile

@@ -1,3 +0,0 @@
-all:
-	python concat_mesh.py hair_bfShape_1.gltf hair_bfShape_0.gltf sim.gltf merged-sim.gltf
-#	python replace_attrib.py merged-sim.gltf replaced.gltf "added/hair_bfShape_1.obj" "hair_bfShape" 0 1

attic/examples/mesh-conv/sandbox/hair_bfShape_0.gltf

@@ -1,288 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5125,
-      "count": 79434,
-      "max": [
-        28135.0
-      ],
-      "min": [
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/indices",
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        11.10669994354248,
-        170.1320037841797,
-        7.035999774932861
-      ],
-      "min": [
-        -11.581600189208984,
-        142.8719940185547,
-        -15.023500442504883
-      ],
-      "name": "hair_bfShape_1.obj#0/POSITION",
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.9999430179595947,
-        0.9999679923057556,
-        0.9999390244483948
-      ],
-      "min": [
-        -0.9997580051422119,
-        -0.8950620293617249,
-        -0.9999200105667114
-      ],
-      "name": "hair_bfShape_1.obj#0/NORMAL",
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.889851987361908,
-        0.998104989528656
-      ],
-      "min": [
-        0.0014202300226315856,
-        -0.0010660899570211768
-      ],
-      "name": "hair_bfShape_1.obj#0/TEXCOORD_0",
-      "type": "VEC2"
-    },
-    {
-      "bufferView": 4,
-      "componentType": 5123,
-      "count": 28136,
-      "max": [
-        97.0,
-        97.0,
-        94.0,
-        93.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/JOINTS_0",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 5,
-      "componentType": 5123,
-      "count": 28136,
-      "max": [
-        93.0,
-        93.0,
-        92.0,
-        92.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/JOINTS_1",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 6,
-      "componentType": 5123,
-      "count": 28136,
-      "max": [
-        91.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/JOINTS_2",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 7,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        1.0,
-        0.5,
-        0.3330000042915344,
-        0.24390600621700287
-      ],
-      "min": [
-        0.2014250010251999,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/WEIGHTS_0",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 8,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.18594099581241608,
-        0.11678200215101242,
-        0.10268200188875198,
-        0.03563150018453598
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/WEIGHTS_1",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 9,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.001464050030335784,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/WEIGHTS_2",
-      "type": "VEC4"
-    }
-  ],
-  "asset": {
-    "generator": "mesh-modify",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 317736,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 337632,
-      "byteOffset": 317736,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 337632,
-      "byteOffset": 655368,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 993000,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 1218088,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 1443176,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 1668264,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 450176,
-      "byteOffset": 1893352,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 450176,
-      "byteOffset": 2343528,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 450176,
-      "byteOffset": 2793704,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 3243880,
-      "name": "bufffer0",
-      "uri": "hair_bfShape_1.bin"
-    }
-  ],
-  "meshes": [
-    {
-      "name": "hair_bfShape_1.obj",
-      "primitives": [
-        {
-          "attributes": {
-            "JOINTS_0": 4,
-            "JOINTS_1": 5,
-            "JOINTS_2": 6,
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TEXCOORD_0": 3,
-            "WEIGHTS_0": 7,
-            "WEIGHTS_1": 8,
-            "WEIGHTS_2": 9
-          },
-          "indices": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "mesh"
-    }
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ]
-}

attic/examples/mesh-conv/sandbox/hair_bfShape_1.gltf

@@ -1,288 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5125,
-      "count": 79434,
-      "max": [
-        28135.0
-      ],
-      "min": [
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/indices",
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        11.10669994354248,
-        170.1320037841797,
-        7.035999774932861
-      ],
-      "min": [
-        -11.581600189208984,
-        142.8719940185547,
-        -15.023500442504883
-      ],
-      "name": "hair_bfShape_1.obj#0/POSITION",
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.9999430179595947,
-        0.9999679923057556,
-        0.9999390244483948
-      ],
-      "min": [
-        -0.9997580051422119,
-        -0.8950620293617249,
-        -0.9999200105667114
-      ],
-      "name": "hair_bfShape_1.obj#0/NORMAL",
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.889851987361908,
-        0.998104989528656
-      ],
-      "min": [
-        0.0014202300226315856,
-        -0.0010660899570211768
-      ],
-      "name": "hair_bfShape_1.obj#0/TEXCOORD_0",
-      "type": "VEC2"
-    },
-    {
-      "bufferView": 4,
-      "componentType": 5123,
-      "count": 28136,
-      "max": [
-        97.0,
-        97.0,
-        94.0,
-        93.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/JOINTS_0",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 5,
-      "componentType": 5123,
-      "count": 28136,
-      "max": [
-        93.0,
-        93.0,
-        92.0,
-        92.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/JOINTS_1",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 6,
-      "componentType": 5123,
-      "count": 28136,
-      "max": [
-        91.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/JOINTS_2",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 7,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        1.0,
-        0.5,
-        0.3330000042915344,
-        0.24390600621700287
-      ],
-      "min": [
-        0.2014250010251999,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/WEIGHTS_0",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 8,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.18594099581241608,
-        0.11678200215101242,
-        0.10268200188875198,
-        0.03563150018453598
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/WEIGHTS_1",
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 9,
-      "componentType": 5126,
-      "count": 28136,
-      "max": [
-        0.001464050030335784,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "name": "hair_bfShape_1.obj#0/WEIGHTS_2",
-      "type": "VEC4"
-    }
-  ],
-  "asset": {
-    "generator": "mesh-modify",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 317736,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 337632,
-      "byteOffset": 317736,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 337632,
-      "byteOffset": 655368,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 993000,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 1218088,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 1443176,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 225088,
-      "byteOffset": 1668264,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 450176,
-      "byteOffset": 1893352,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 450176,
-      "byteOffset": 2343528,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 450176,
-      "byteOffset": 2793704,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 3243880,
-      "name": "bufffer0",
-      "uri": "hair_bfShape_1.bin"
-    }
-  ],
-  "meshes": [
-    {
-      "name": "hair_bfShape_1.obj",
-      "primitives": [
-        {
-          "attributes": {
-            "JOINTS_0": 4,
-            "JOINTS_1": 5,
-            "JOINTS_2": 6,
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TEXCOORD_0": 3,
-            "WEIGHTS_0": 7,
-            "WEIGHTS_1": 8,
-            "WEIGHTS_2": 9
-          },
-          "indices": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "mesh"
-    }
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ]
-}

attic/examples/mesh-conv/sandbox/reuv.gltf

@@ -1,278 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5125,
-      "count": 120,
-      "max": [
-        41.0
-      ],
-      "min": [
-        0.0
-      ],
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "componentType": 5126,
-      "count": 42,
-      "max": [
-        7.569169998168945,
-        158.69000244140625,
-        0.8566960096359253
-      ],
-      "min": [
-        6.6432600021362305,
-        151.98899841308594,
-        -3.55295991897583
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "componentType": 5126,
-      "count": 42,
-      "max": [
-        0.980184018611908,
-        0.3233279883861542,
-        0.4895069897174835
-      ],
-      "min": [
-        0.8707389831542969,
-        -0.3086549937725067,
-        -0.2010059952735901
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "componentType": 5126,
-      "count": 42,
-      "max": [
-        0.7207019925117493,
-        0.8640819787979126
-      ],
-      "min": [
-        0.7156370282173157,
-        0.8067020177841187
-      ],
-      "type": "VEC2"
-    },
-    {
-      "bufferView": 4,
-      "componentType": 5123,
-      "count": 42,
-      "max": [
-        0.0,
-        74.0,
-        73.0,
-        75.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 5,
-      "componentType": 5123,
-      "count": 42,
-      "max": [
-        68.0,
-        78.0,
-        70.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 6,
-      "componentType": 5123,
-      "count": 42,
-      "max": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 7,
-      "componentType": 5126,
-      "count": 42,
-      "max": [
-        1.0,
-        0.02313319966197014,
-        0.01985890045762062,
-        0.005621309857815504
-      ],
-      "min": [
-        0.9537339806556702,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 8,
-      "componentType": 5126,
-      "count": 42,
-      "max": [
-        0.0003756110090762377,
-        0.0002766030083876103,
-        2.8980000479350565e-06,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 9,
-      "componentType": 5126,
-      "count": 42,
-      "max": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "min": [
-        0.0,
-        0.0,
-        0.0,
-        0.0
-      ],
-      "type": "VEC4"
-    }
-  ],
-  "asset": {
-    "generator": "mesh-modify",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 480,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 504,
-      "byteOffset": 480,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 504,
-      "byteOffset": 984,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 336,
-      "byteOffset": 1488,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 336,
-      "byteOffset": 1824,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 336,
-      "byteOffset": 2160,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 336,
-      "byteOffset": 2496,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 672,
-      "byteOffset": 2832,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 672,
-      "byteOffset": 3504,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 672,
-      "byteOffset": 4176,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 4848,
-      "name": "bufffer0",
-      "uri": "output.bin"
-    }
-  ],
-  "meshes": [
-    {
-      "name": "hair_bfShape_0.obj",
-      "primitives": [
-        {
-          "attributes": {
-            "JOINTS_0": 4,
-            "JOINTS_1": 5,
-            "JOINTS_2": 6,
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TEXCOORD_0": 3,
-            "WEIGHTS_0": 7,
-            "WEIGHTS_1": 8,
-            "WEIGHTS_2": 9
-          },
-          "indices": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "mesh"
-    }
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ]
-}

attic/examples/mesh-conv/strip-buffer/Makefile

@@ -1,2 +0,0 @@
-all:
-	python strip-buffer.py cloth.gltf

attic/examples/mesh-conv/strip-buffer/README.md

@@ -1,3 +0,0 @@
-# Strip unused buffer data.
-
-T.B.W.

attic/examples/mesh-conv/strip-buffer/strip-buffer.py

@@ -1,24 +0,0 @@
-import json
-import struct
-import sys
-
-if len(sys.argv) < 2:
-    print("Need input.gltf")
-    sys.exit(-1)
-
-gltf_file = sys.argv[1]
-#bin_file = sys.argv[1]
-
-gltf = json.loads(open(gltf_file, "r", encoding='utf-8').read())
-print(gltf)
-
-#data = open(bin_file, "rb").read()
-#print(len(data))
-#
-#out = data[100:]
-#print(len(out))
-#
-#with open("output.bin", "wb") as f:
-#    f.write(out)
-#
-#print("DONE!")

attic/examples/mesh-conv/test.json

@@ -1 +0,0 @@
-{ "buffer" : 0 }

attic/examples/mesh-conv/test.jsonnet

@@ -1,6 +0,0 @@
-local lib = import 'lowpoly-nodes.gltf';
-{
-	//"muda": lib.skins[0].joints,
-	"bora": if std.length(lib.assets) then 0 else 1,
-}
-

attic/examples/mesh-conv/torus.mtl

@@ -1,6 +0,0 @@
-newmtl initialShadingGroup
-illum 4
-Kd 0.50 0.50 0.50
-Ka 0.00 0.00 0.00
-Tf 1.00 1.00 1.00
-Ni 1.00

attic/examples/raytrace/Makefile

@@ -1,61 +0,0 @@
-# GNU Make workspace makefile autogenerated by Premake
-
-ifndef config
-  config=release_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-ifeq ($(config),release_native)
-  viwewer_config = release_native
-endif
-ifeq ($(config),release_x64)
-  viwewer_config = release_x64
-endif
-ifeq ($(config),release_x32)
-  viwewer_config = release_x32
-endif
-ifeq ($(config),debug_native)
-  viwewer_config = debug_native
-endif
-ifeq ($(config),debug_x64)
-  viwewer_config = debug_x64
-endif
-ifeq ($(config),debug_x32)
-  viwewer_config = debug_x32
-endif
-
-PROJECTS := viwewer
-
-.PHONY: all clean help $(PROJECTS) 
-
-all: $(PROJECTS)
-
-viwewer:
-ifneq (,$(viwewer_config))
-	@echo "==== Building viwewer ($(viwewer_config)) ===="
-	@${MAKE} --no-print-directory -C . -f viwewer.make config=$(viwewer_config)
-endif
-
-clean:
-	@${MAKE} --no-print-directory -C . -f viwewer.make clean
-
-help:
-	@echo "Usage: make [config=name] [target]"
-	@echo ""
-	@echo "CONFIGURATIONS:"
-	@echo "  release_native"
-	@echo "  release_x64"
-	@echo "  release_x32"
-	@echo "  debug_native"
-	@echo "  debug_x64"
-	@echo "  debug_x32"
-	@echo ""
-	@echo "TARGETS:"
-	@echo "   all (default)"
-	@echo "   clean"
-	@echo "   viwewer"
-	@echo ""
-	@echo "For more information, see http://industriousone.com/premake/quick-start"

attic/examples/saver/Makefile

@@ -1 +0,0 @@
-Makefile.dev

attic/examples/saver/bora.gltf

@@ -1,191 +0,0 @@
-{
-    "accessors": [
-        {
-            "bufferView": 0,
-            "componentType": 5123,
-            "count": 36,
-            "min": [
-                0.0
-            ],
-            "max": [
-                35.0
-            ],
-            "normalized": false,
-            "type": "SCALAR"
-        },
-        {
-            "bufferView": 1,
-            "componentType": 5126,
-            "count": 36,
-            "min": [
-                -1.0,
-                -1.0,
-                -1.0
-            ],
-            "max": [
-                1.0,
-                1.0,
-                1.000001
-            ],
-            "normalized": false,
-            "type": "VEC3"
-        },
-        {
-            "bufferView": 2,
-            "componentType": 5126,
-            "count": 36,
-            "min": [
-                -1.0,
-                -1.0,
-                -1.0
-            ],
-            "max": [
-                1.0,
-                1.0,
-                1.0
-            ],
-            "normalized": false,
-            "type": "VEC3"
-        },
-        {
-            "bufferView": 3,
-            "componentType": 5126,
-            "count": 36,
-            "min": [
-                0.0,
-                -0.0,
-                -1.0,
-                -1.0
-            ],
-            "max": [
-                1.0,
-                -0.0,
-                -0.0,
-                1.0
-            ],
-            "normalized": false,
-            "type": "VEC4"
-        },
-        {
-            "bufferView": 4,
-            "componentType": 5126,
-            "count": 36,
-            "min": [
-                -1.0,
-                -1.0
-            ],
-            "max": [
-                1.0,
-                1.0
-            ],
-            "normalized": false,
-            "type": "VEC2"
-        }
-    ],
-    "asset": {
-        "generator": "VKTS glTF 2.0 exporter",
-        "version": "2.0"
-    },
-    "buffers": [
-        {
-            "byteLength": 1800,
-            "uri": "Cube.bin"
-        }
-    ],
-    "bufferViews": [
-        {
-            "buffer": 0,
-            "byteLength": 72,
-            "target": 34963
-        },
-        {
-            "buffer": 0,
-            "byteLength": 432,
-            "byteOffset": 72,
-            "target": 34962
-        },
-        {
-            "buffer": 0,
-            "byteLength": 432,
-            "byteOffset": 504,
-            "target": 34962
-        },
-        {
-            "buffer": 0,
-            "byteLength": 576,
-            "byteOffset": 936,
-            "target": 34962
-        },
-        {
-            "buffer": 0,
-            "byteLength": 288,
-            "byteOffset": 1512,
-            "target": 34962
-        }
-    ],
-    "images": [
-        {
-            "uri": "Cube_BaseColor.png"
-        },
-        {
-            "uri": "Cube_MetallicRoughness.png"
-        }
-    ],
-    "materials": [
-        {
-            "name": "Cube"
-        }
-    ],
-    "meshes": [
-        {
-            "primitives": [
-                {
-                    "attributes": {
-                        "NORMAL": 2,
-                        "POSITION": 1,
-                        "TANGENT": 3,
-                        "TEXCOORD_0": 4
-                    },
-                    "indices": 0,
-                    "material": 0,
-                    "mode": 4
-                }
-            ],
-            "name": "Cube"
-        }
-    ],
-    "nodes": [
-        {
-            "mesh": 0,
-            "name": "Cube",
-            "children": []
-        }
-    ],
-    "scene": 0,
-    "scenes": [
-        {
-            "nodes": [
-                0
-            ]
-        }
-    ],
-    "textures": [
-        {
-            "sampler": 0,
-            "source": 0
-        },
-        {
-            "sampler": 0,
-            "source": 1
-        }
-    ],
-    "samplers": [
-        {
-            "magFilter": 9729,
-            "minFilter": 9986,
-            "wrapR": 10497,
-            "wrapS": 10497,
-            "wrapT": 10497
-        }
-    ]
-}

attic/examples/skinning/Makefile

@@ -1,61 +0,0 @@
-# GNU Make workspace makefile autogenerated by Premake
-
-ifndef config
-  config=debug_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-ifeq ($(config),debug_native)
-  skinning_config = debug_native
-endif
-ifeq ($(config),debug_x64)
-  skinning_config = debug_x64
-endif
-ifeq ($(config),debug_x32)
-  skinning_config = debug_x32
-endif
-ifeq ($(config),release_native)
-  skinning_config = release_native
-endif
-ifeq ($(config),release_x64)
-  skinning_config = release_x64
-endif
-ifeq ($(config),release_x32)
-  skinning_config = release_x32
-endif
-
-PROJECTS := skinning
-
-.PHONY: all clean help $(PROJECTS) 
-
-all: $(PROJECTS)
-
-skinning:
-ifneq (,$(skinning_config))
-	@echo "==== Building skinning ($(skinning_config)) ===="
-	@${MAKE} --no-print-directory -C . -f skinning.make config=$(skinning_config)
-endif
-
-clean:
-	@${MAKE} --no-print-directory -C . -f skinning.make clean
-
-help:
-	@echo "Usage: make [config=name] [target]"
-	@echo ""
-	@echo "CONFIGURATIONS:"
-	@echo "  debug_native"
-	@echo "  debug_x64"
-	@echo "  debug_x32"
-	@echo "  release_native"
-	@echo "  release_x64"
-	@echo "  release_x32"
-	@echo ""
-	@echo "TARGETS:"
-	@echo "   all (default)"
-	@echo "   clean"
-	@echo "   skinning"
-	@echo ""
-	@echo "For more information, see http://industriousone.com/premake/quick-start"

attic/examples/skinning/skinning.make

@@ -1,276 +0,0 @@
-# GNU Make project makefile autogenerated by Premake
-
-ifndef config
-  config=debug_native
-endif
-
-ifndef verbose
-  SILENT = @
-endif
-
-.PHONY: clean prebuild prelink
-
-ifeq ($(config),debug_native)
-  RESCOMP = windres
-  TARGETDIR = bin/native/Debug
-  TARGET = $(TARGETDIR)/skinning
-  OBJDIR = obj/native/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../..
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -g -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -g -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),debug_x64)
-  RESCOMP = windres
-  TARGETDIR = bin/x64/Debug
-  TARGET = $(TARGETDIR)/skinning
-  OBJDIR = obj/x64/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../..
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -g -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -g -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),debug_x32)
-  RESCOMP = windres
-  TARGETDIR = bin/x32/Debug
-  TARGET = $(TARGETDIR)/skinning
-  OBJDIR = obj/x32/Debug
-  DEFINES += -DDEBUG
-  INCLUDES += -I. -I../..
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -g -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -g -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_native)
-  RESCOMP = windres
-  TARGETDIR = bin/native/Release
-  TARGET = $(TARGETDIR)/skinning
-  OBJDIR = obj/native/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../..
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -O2 -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -O2 -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -s `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_x64)
-  RESCOMP = windres
-  TARGETDIR = bin/x64/Release
-  TARGET = $(TARGETDIR)/skinning
-  OBJDIR = obj/x64/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../..
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 -s `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-ifeq ($(config),release_x32)
-  RESCOMP = windres
-  TARGETDIR = bin/x32/Release
-  TARGET = $(TARGETDIR)/skinning
-  OBJDIR = obj/x32/Release
-  DEFINES += -DNDEBUG
-  INCLUDES += -I. -I../..
-  FORCE_INCLUDE +=
-  ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES)
-  ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -Wall -Wextra
-  ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -Wall -Wextra -std=c++11
-  ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)
-  LIBS += -lGL -lGLU -lm -lGLEW -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -ldl
-  LDDEPS +=
-  ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 -s `pkg-config --libs glfw3`
-  LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS)
-  define PREBUILDCMDS
-  endef
-  define PRELINKCMDS
-  endef
-  define POSTBUILDCMDS
-  endef
-all: prebuild prelink $(TARGET)
-	@:
-
-endif
-
-OBJECTS := \
-	$(OBJDIR)/matrix.o \
-	$(OBJDIR)/trackball.o \
-	$(OBJDIR)/main.o \
-	$(OBJDIR)/morph-targets.o \
-	$(OBJDIR)/skinning.o \
-
-RESOURCES := \
-
-CUSTOMFILES := \
-
-SHELLTYPE := msdos
-ifeq (,$(ComSpec)$(COMSPEC))
-  SHELLTYPE := posix
-endif
-ifeq (/bin,$(findstring /bin,$(SHELL)))
-  SHELLTYPE := posix
-endif
-
-$(TARGET): $(GCH) ${CUSTOMFILES} $(OBJECTS) $(LDDEPS) $(RESOURCES)
-	@echo Linking skinning
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(TARGETDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(TARGETDIR))
-endif
-	$(SILENT) $(LINKCMD)
-	$(POSTBUILDCMDS)
-
-clean:
-	@echo Cleaning skinning
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) rm -f  $(TARGET)
-	$(SILENT) rm -rf $(OBJDIR)
-else
-	$(SILENT) if exist $(subst /,\\,$(TARGET)) del $(subst /,\\,$(TARGET))
-	$(SILENT) if exist $(subst /,\\,$(OBJDIR)) rmdir /s /q $(subst /,\\,$(OBJDIR))
-endif
-
-prebuild:
-	$(PREBUILDCMDS)
-
-prelink:
-	$(PRELINKCMDS)
-
-ifneq (,$(PCH))
-$(OBJECTS): $(GCH) $(PCH)
-$(GCH): $(PCH)
-	@echo $(notdir $<)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-	$(SILENT) $(CXX) -x c++-header $(ALL_CXXFLAGS) -o "$@" -MF "$(@:%.gch=%.d)" -c "$<"
-endif
-
-$(OBJDIR)/matrix.o: ../common/matrix.cc
-	@echo $(notdir $<)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/trackball.o: ../common/trackball.cc
-	@echo $(notdir $<)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/main.o: main.cc
-	@echo $(notdir $<)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/morph-targets.o: morph-targets.cc
-	@echo $(notdir $<)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-$(OBJDIR)/skinning.o: skinning.cc
-	@echo $(notdir $<)
-ifeq (posix,$(SHELLTYPE))
-	$(SILENT) mkdir -p $(OBJDIR)
-else
-	$(SILENT) mkdir $(subst /,\\,$(OBJDIR))
-endif
-	$(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<"
-
--include $(OBJECTS:%.o=%.d)
-ifneq (,$(PCH))
-  -include $(OBJDIR)/$(notdir $(PCH)).d
-endif

attic/examples/tmp/Makefile

@@ -1,7 +0,0 @@
-
-# Use this for strict compilation check(will work on clang 3.8+)
-EXTRA_CXXFLAGS := -Wall -Werror -Weverything -Wno-c++11-long-long -Wno-c++98-compat
-
-all:
-	clang++  $(EXTRA_CXXFLAGS) -I../../ -std=c++11 -g -O0 -o main main.cpp
-

attic/examples/tmp/box.gltf

@@ -1,122 +0,0 @@
-{
-    "accessors" : [
-        {
-            "bufferView" : 0,
-            "componentType" : 5121,
-            "count" : 36,
-            "max" : [
-                23
-            ],
-            "min" : [
-                0
-            ],
-            "type" : "SCALAR"
-        },
-        {
-            "bufferView" : 1,
-            "componentType" : 5126,
-            "count" : 24,
-            "max" : [
-                1.0000004768371582,
-                1.0,
-                1.0000005960464478
-            ],
-            "min" : [
-                -1.0000003576278687,
-                -1.0,
-                -1.0000003576278687
-            ],
-            "type" : "VEC3"
-        },
-        {
-            "bufferView" : 2,
-            "componentType" : 5126,
-            "count" : 24,
-            "max" : [
-                1.0,
-                1.0,
-                1.0
-            ],
-            "min" : [
-                -1.0,
-                -1.0,
-                -1.0
-            ],
-            "type" : "VEC3"
-        }
-    ],
-    "asset" : {
-        "generator" : "Khronos Blender glTF 2.0 exporter",
-        "version" : "2.0"
-    },
-    "bufferViews" : [
-        {
-            "buffer" : 0,
-            "byteLength" : 36,
-            "byteOffset" : 0,
-            "target" : 34963
-        },
-        {
-            "buffer" : 0,
-            "byteLength" : 288,
-            "byteOffset" : 36,
-            "target" : 34962
-        },
-        {
-            "buffer" : 0,
-            "byteLength" : 288,
-            "byteOffset" : 324,
-            "target" : 34962
-        }
-    ],
-    "buffers" : [
-        {
-            "byteLength" : 612,
-            "uri" : "data:application/octet-stream;base64,AAECAwEABAUGBAcFCAkKCAsJDA0ODA8NEBESEBMRFBUWFBcVAACAPwAAgL///3+/AQCAvwAAgL/9/38/+v9/vwAAgL8DAIC/AACAPwAAgL8AAIA/AwCAvwAAgD/6/38/BACAPwAAgD/3/3+///9/vwAAgD8AAIC/9f9/PwAAgD8FAIA/BACAPwAAgD/3/3+/AACAPwAAgL8AAIA/AACAPwAAgL///3+/9f9/PwAAgD8FAIA/9f9/PwAAgD8FAIA/AQCAvwAAgL/9/38/AACAPwAAgL8AAIA/AwCAvwAAgD/6/38/AwCAvwAAgD/6/38/+v9/vwAAgL8DAIC/AQCAvwAAgL/9/38///9/vwAAgD8AAIC///9/vwAAgD8AAIC/AACAPwAAgL///3+/+v9/vwAAgL8DAIC/BACAPwAAgD/3/3+/AAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAP+z/PzMAAJg0AACAP+z/PzMAAJg0AACAP+z/PzMAAJg0AACAP+z/PzMAAJg0AACYtAkA4LMAAIA/AACYtAkA4LMAAIA/AACYtAkA4LMAAIA/AACYtAkA4LMAAIA/AACAv///D7QCAHC0AACAv///D7QCAHC0AACAv///D7QCAHC0AACAv///D7QCAHC0AACANAAAYDQAAIC/AACANAAAYDQAAIC/AACANAAAYDQAAIC/AACANAAAYDQAAIC/"
-        }
-    ],
-    "materials" : [
-        {
-            "name" : "Material",
-            "pbrMetallicRoughness" : {
-                "baseColorFactor" : [
-                    0.6400000190734865,
-                    0.6400000190734865,
-                    0.6400000190734865,
-                    1.0
-                ],
-                "metallicFactor" : 0.0
-            }
-        }
-    ],
-    "meshes" : [
-        {
-            "name" : "Cube",
-            "primitives" : [
-                {
-                    "attributes" : {
-                        "NORMAL" : 2,
-                        "POSITION" : 1
-                    },
-                    "indices" : 0,
-                    "material" : 0
-                }
-            ]
-        }
-    ],
-    "nodes" : [
-        {
-            "mesh" : 0,
-            "name" : "Cube"
-        }
-    ],
-    "scene" : 0,
-    "scenes" : [
-        {
-            "name" : "Scene",
-            "nodes" : [
-                0
-            ]
-        }
-    ]
-}

attic/examples/tmp/main.cpp

@@ -1,67 +0,0 @@
-#include <stdio.h>
-#define TINYGLTF_IMPLEMENTATION
-#define TINYGLTF_NO_STB_IMAGE
-#define TINYGLTF_NO_STB_IMAGE_WRITE
-#include "tiny_gltf.h"
-
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Weverything"
-#endif
-
-
-static int _allocs = 0;
-
-void* operator new( size_t size )
-{
-    ++_allocs;
-    return malloc( size );
-}
-
-void* operator new[]( size_t size )
-{
-    ++_allocs;
-    return malloc( size );
-}
-
-void operator delete( void* memory )
-{
-    --_allocs;
-    free( memory );
-}
-
-void operator delete( void* memory, size_t size )
-{
-    --_allocs;
-    free( memory );
-}
-
-void operator delete[]( void* memory )
-{
-    --_allocs;
-    free( memory );
-}
-
-void operator delete[]( void* memory, size_t size )
-{
-    --_allocs;
-    free( memory );
-}
-
-void test()
-{
-    tinygltf::TinyGLTF  loader;
-    tinygltf::Model     model;
-    
-    bool status = loader.LoadASCIIFromFile( &model, NULL, NULL, "box.gltf" );
-    printf( "status: %d\n", status );
-}
-
-int main()
-{
-    printf( "before: %d\n", _allocs );
-    test();
-    printf( "after:  %d\n", _allocs );
-    return 0;
-}
-

attic/examples/validator/test_json11_adapter.cpp

@@ -1,87 +0,0 @@
-#ifdef VALIJSON_BUILD_CXX11_ADAPTERS
-
-#include <gtest/gtest.h>
-
-#include <valijson/adapters/json11_adapter.hpp>
-
-class TestJson11Adapter : public testing::Test
-{
-
-};
-
-TEST_F(TestJson11Adapter, BasicArrayIteration)
-{
-    const unsigned int numElements = 10;
-
-    // Create a Json11 document that consists of an array of numbers
-    json11::Json::array array;
-    for (unsigned int i = 0; i < numElements; i++) {
-        json11::Json value(static_cast<double>(i));
-        array.push_back(value);
-    }
-    json11::Json document(array);
-
-    // Ensure that wrapping the document preserves the array and does not allow
-    // it to be cast to other types
-    valijson::adapters::Json11Adapter adapter(document);
-    ASSERT_NO_THROW( adapter.getArray() );
-    ASSERT_ANY_THROW( adapter.getBool() );
-    ASSERT_ANY_THROW( adapter.getDouble() );
-    ASSERT_ANY_THROW( adapter.getObject() );
-    ASSERT_ANY_THROW( adapter.getString() );
-
-    // Ensure that the array contains the expected number of elements
-    EXPECT_EQ( numElements, adapter.getArray().size() );
-
-    // Ensure that the elements are returned in the order they were inserted
-    unsigned int expectedValue = 0;
-    for (const valijson::adapters::Json11Adapter value : adapter.getArray()) {
-        ASSERT_TRUE( value.isNumber() );
-        EXPECT_EQ( double(expectedValue), value.getDouble() );
-        expectedValue++;
-    }
-
-    // Ensure that the correct number of elements were iterated over
-    EXPECT_EQ(numElements, expectedValue);
-}
-
-TEST_F(TestJson11Adapter, BasicObjectIteration)
-{
-    const unsigned int numElements = 10;
-
-    // Create a DropBoxJson11 document that consists of an object that maps numeric
-    // strings their corresponding numeric values
-    json11::Json::object object;
-    for (unsigned int i = 0; i < numElements; i++) {
-        std::string name(std::to_string(i));
-        object[name] = json11::Json(static_cast<double>(i));
-    }
-    json11::Json document(object);
-
-    // Ensure that wrapping the document preserves the object and does not
-    // allow it to be cast to other types
-    valijson::adapters::Json11Adapter adapter(document);
-    ASSERT_NO_THROW( adapter.getObject() );
-    ASSERT_ANY_THROW( adapter.getArray() );
-    ASSERT_ANY_THROW( adapter.getBool() );
-    ASSERT_ANY_THROW( adapter.getDouble() );
-    ASSERT_ANY_THROW( adapter.getString() );
-
-    // Ensure that the object contains the expected number of members
-    EXPECT_EQ( numElements, adapter.getObject().size() );
-
-    // Ensure that the members are returned in the order they were inserted
-    unsigned int expectedValue = 0;
-    for (const valijson::adapters::Json11Adapter::ObjectMember member : adapter.getObject()) {
-        ASSERT_TRUE( member.second.isNumber() );
-        EXPECT_EQ( std::to_string(expectedValue), member.first );
-        EXPECT_EQ( double(expectedValue), member.second.getDouble() );
-        expectedValue++;
-    }
-
-    // Ensure that the correct number of elements were iterated over
-    EXPECT_EQ( numElements, expectedValue );
-}
-
-#endif // VALIJSON_BUILD_CXX11_ADAPTERS
-

attic/experimental/Makefile

@@ -1,2 +0,0 @@
-all:
-	python gen.py /home/syoyo/work/glTF/specification/2.0/schema/

attic/tests/Makefile.mingw-cross

@@ -1,5 +0,0 @@
-CXX=/mnt/data/local/llvm-mingw-20200325-ubuntu-18.04/bin/x86_64-w64-mingw32-clang++
-#CXX=x86_64-w64-mingw32-g++
-
-all: ../tiny_gltf.h
-	$(CXX) -fuse-ld=lld -I../ $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o tester.exe tester.cc

attic/tests/fuzzer/fuzz_gltf_customjson.cc

@@ -1,76 +0,0 @@
-/*
- * LLVM libFuzzer harness for tinygltf with the custom JSON backend
- * (tinygltf_json.h).
- *
- * Exercises:
- *   1. LoadASCIIFromString  – glTF JSON parsing
- *   2. LoadBinaryFromMemory – GLB binary parsing
- *
- * Build (clang with libFuzzer):
- *   clang++ -std=c++11 -fsanitize=address,fuzzer \
- *           -DTINYGLTF_USE_CUSTOM_JSON           \
- *           -I../../ fuzz_gltf_customjson.cc      \
- *           -o fuzz_gltf_customjson
- *
- * Run:
- *   ./fuzz_gltf_customjson -rss_limit_mb=20000 -jobs 4
- */
-
-#include <cstdint>
-#include <cstring>
-
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#define TINYGLTF_IMPLEMENTATION
-#ifndef TINYGLTF_USE_CUSTOM_JSON
-#define TINYGLTF_USE_CUSTOM_JSON
-#endif
-#include "tiny_gltf.h"
-
-/* Fuzz the ASCII (JSON) parser path */
-static void fuzz_ascii(const uint8_t *data, size_t size) {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  const char *str = reinterpret_cast<const char *>(data);
-
-  bool ret =
-      ctx.LoadASCIIFromString(&model, &err, &warn, str,
-                              static_cast<unsigned int>(size), /* base_dir */ "");
-  (void)ret;
-}
-
-/* Fuzz the binary (GLB) parser path */
-static void fuzz_binary(const uint8_t *data, size_t size) {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  bool ret = ctx.LoadBinaryFromMemory(&model, &err, &warn, data,
-                                      static_cast<unsigned int>(size),
-                                      /* base_dir */ "");
-  (void)ret;
-}
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  if (size == 0) return 0;
-
-  /* Use the lowest bit of the first byte to select the parse path.
-   * The remaining bits are left for the fuzzer engine to explore;
-   * additional paths (e.g. LoadASCIIFromFile, check_sections flags)
-   * can be added here in the future using more selector bits. */
-  uint8_t selector = data[0];
-  const uint8_t *payload = data + 1;
-  size_t payload_size = size - 1;
-
-  if (selector & 1) {
-    fuzz_binary(payload, payload_size);
-  } else {
-    fuzz_ascii(payload, payload_size);
-  }
-
-  return 0;
-}

attic/wasm/Cube-textransform.gltf

@@ -1,209 +0,0 @@
-{
-   "accessors" : [
-      {
-         "bufferView" : 0,
-         "byteOffset" : 0,
-         "componentType" : 5123,
-         "count" : 36,
-         "max" : [
-            35
-         ],
-         "min" : [
-            0
-         ],
-         "type" : "SCALAR"
-      },
-      {
-         "bufferView" : 1,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000001
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 2,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 3,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            -0.000000,
-            -0.000000,
-            1.000000
-         ],
-         "min" : [
-            0.000000,
-            -0.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC4"
-      },
-      {
-         "bufferView" : 4,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC2"
-      }
-   ],
-   "asset" : {
-      "generator" : "VKTS glTF 2.0 exporter",
-      "version" : "2.0"
-   },
-   "bufferViews" : [
-      {
-         "buffer" : 0,
-         "byteLength" : 72,
-         "byteOffset" : 0,
-         "target" : 34963
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 72,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 504,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 576,
-         "byteOffset" : 936,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 288,
-         "byteOffset" : 1512,
-         "target" : 34962
-      }
-   ],
-   "buffers" : [
-      {
-         "byteLength" : 1800,
-         "uri" : "Cube.bin"
-      }
-   ],
-   "images" : [
-      {
-         "uri" : "Cube_BaseColor.png"
-      },
-      {
-         "uri" : "Cube_MetallicRoughness.png"
-      }
-   ],
-   "materials" : [
-    {"emissiveTexture": {
-      "index": 0,
-      "extensions": {
-        "KHR_texture_transform": {
-          "offset": [0, 1],
-          "scale": [1, -1]
-        }
-      }
-    }},
-      {
-         "name" : "Cube",
-         "pbrMetallicRoughness" : {
-            "baseColorTexture" : {
-               "index" : 0
-            },
-            "metallicRoughnessTexture" : {
-               "index" : 1,
-		"extensions": {
-			"KHR_texture_transform": {
-			  "offset": [0, 1],
-			  "rotation": 1.57079632679,
-			  "scale": [0.5, 0.5]
-			}
-		      }
-            }
-         }
-      }
-   ],
-   "meshes" : [
-      {
-         "name" : "Cube",
-         "primitives" : [
-            {
-               "attributes" : {
-                  "NORMAL" : 2,
-                  "POSITION" : 1,
-                  "TANGENT" : 3,
-                  "TEXCOORD_0" : 4
-               },
-               "indices" : 0,
-               "material" : 0,
-               "mode" : 4
-            }
-         ]
-      }
-   ],
-   "nodes" : [
-      {
-         "mesh" : 0,
-         "name" : "Cube"
-      }
-   ],
-   "samplers" : [
-      {}
-   ],
-   "scene" : 0,
-   "scenes" : [
-      {
-         "nodes" : [
-            0
-         ]
-      }
-   ],
-   "textures" : [
-      {
-         "sampler" : 0,
-         "source" : 0
-      },
-      {
-         "sampler" : 0,
-         "source" : 1
-      }
-   ]
-}

attic/wasm/Cube.gltf

@@ -1,193 +0,0 @@
-{
-   "accessors" : [
-      {
-         "bufferView" : 0,
-         "byteOffset" : 0,
-         "componentType" : 5123,
-         "count" : 36,
-         "max" : [
-            35
-         ],
-         "min" : [
-            0
-         ],
-         "type" : "SCALAR"
-      },
-      {
-         "bufferView" : 1,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000001
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 2,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 3,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            -0.000000,
-            -0.000000,
-            1.000000
-         ],
-         "min" : [
-            0.000000,
-            -0.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC4"
-      },
-      {
-         "bufferView" : 4,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC2"
-      }
-   ],
-   "asset" : {
-      "generator" : "VKTS glTF 2.0 exporter",
-      "version" : "2.0"
-   },
-   "bufferViews" : [
-      {
-         "buffer" : 0,
-         "byteLength" : 72,
-         "byteOffset" : 0,
-         "target" : 34963
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 72,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 504,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 576,
-         "byteOffset" : 936,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 288,
-         "byteOffset" : 1512,
-         "target" : 34962
-      }
-   ],
-   "buffers" : [
-      {
-         "byteLength" : 1800,
-         "uri" : "Cube.bin"
-      }
-   ],
-   "images" : [
-      {
-         "uri" : "Cube_BaseColor.png"
-      },
-      {
-         "uri" : "Cube_MetallicRoughness.png"
-      }
-   ],
-   "materials" : [
-      {
-         "name" : "Cube",
-         "pbrMetallicRoughness" : {
-            "baseColorTexture" : {
-               "index" : 0
-            },
-            "metallicRoughnessTexture" : {
-               "index" : 1
-            }
-         }
-      }
-   ],
-   "meshes" : [
-      {
-         "name" : "Cube",
-         "primitives" : [
-            {
-               "attributes" : {
-                  "NORMAL" : 2,
-                  "POSITION" : 1,
-                  "TANGENT" : 3,
-                  "TEXCOORD_0" : 4
-               },
-               "indices" : 0,
-               "material" : 0,
-               "mode" : 4
-            }
-         ]
-      }
-   ],
-   "nodes" : [
-      {
-         "mesh" : 0,
-         "name" : "Cube"
-      }
-   ],
-   "samplers" : [
-      {}
-   ],
-   "scene" : 0,
-   "scenes" : [
-      {
-         "nodes" : [
-            0
-         ]
-      }
-   ],
-   "textures" : [
-      {
-         "sampler" : 0,
-         "source" : 0
-      },
-      {
-         "sampler" : 0,
-         "source" : 1
-      }
-   ]
-}

attic/wasm/Cube2.gltf

@@ -1,197 +0,0 @@
-{
-   "accessors" : [
-      {
-         "bufferView" : 0,
-         "byteOffset" : 0,
-         "componentType" : 5123,
-         "count" : 36,
-         "max" : [
-            35
-         ],
-         "min" : [
-            0
-         ],
-         "type" : "SCALAR"
-      },
-      {
-         "bufferView" : 1,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000001
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 2,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 3,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            -0.000000,
-            -0.000000,
-            1.000000
-         ],
-         "min" : [
-            0.000000,
-            -0.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC4"
-      },
-      {
-         "bufferView" : 4,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC2"
-      }
-   ],
-   "asset" : {
-      "generator" : "VKTS glTF 2.0 exporter",
-      "version" : "2.0"
-   },
-   "bufferViews" : [
-      {
-         "buffer" : 1,
-         "byteLength" : 72,
-         "byteOffset" : 0,
-         "target" : 34963
-      },
-      {
-         "buffer" : 1,
-         "byteLength" : 432,
-         "byteOffset" : 72,
-         "target" : 34962
-      },
-      {
-         "buffer" : 1,
-         "byteLength" : 432,
-         "byteOffset" : 504,
-         "target" : 34962
-      },
-      {
-         "buffer" : 1,
-         "byteLength" : 576,
-         "byteOffset" : 936,
-         "target" : 34962
-      },
-      {
-         "buffer" : 1,
-         "byteLength" : 288,
-         "byteOffset" : 1512,
-         "target" : 34962
-      }
-   ],
-   "buffers" : [
-      {
-         "byteLength" : 1800,
-         "uri" : "Cube.bin"
-      },
-      {
-         "byteLength" : 1800,
-         "uri" : "Cube.bin2"
-      }
-   ],
-   "images" : [
-      {
-         "uri" : "Cube_BaseColor.png"
-      },
-      {
-         "uri" : "Cube_MetallicRoughness.png"
-      }
-   ],
-   "materials" : [
-      {
-         "name" : "Cube",
-         "pbrMetallicRoughness" : {
-            "baseColorTexture" : {
-               "index" : 0
-            },
-            "metallicRoughnessTexture" : {
-               "index" : 1
-            }
-         }
-      }
-   ],
-   "meshes" : [
-      {
-         "name" : "Cube",
-         "primitives" : [
-            {
-               "attributes" : {
-                  "NORMAL" : 2,
-                  "POSITION" : 1,
-                  "TANGENT" : 3,
-                  "TEXCOORD_0" : 4
-               },
-               "indices" : 0,
-               "material" : 0,
-               "mode" : 4
-            }
-         ]
-      }
-   ],
-   "nodes" : [
-      {
-         "mesh" : 0,
-         "name" : "Cube"
-      }
-   ],
-   "samplers" : [
-      {}
-   ],
-   "scene" : 0,
-   "scenes" : [
-      {
-         "nodes" : [
-            0
-         ]
-      }
-   ],
-   "textures" : [
-      {
-         "sampler" : 0,
-         "source" : 0
-      },
-      {
-         "sampler" : 0,
-         "source" : 1
-      }
-   ]
-}

attic/wasm/bootstrap-wasi.sh

@@ -1,9 +0,0 @@
-rm -rf build
-mkdir build
-
-WASI_VERSION=16
-WASI_VERSION_FULL=${WASI_VERSION}.0
-
-WASI_SDK_PATH=$HOME/local/wasi-sdk-${WASI_VERSION_FULL}
-
-CC=${WASI_SDK_PATH}/bin/clang CXX=${WASI_SDK_PATH}/bin/clang++ cmake -DWASI_SDK_PATH=${WASI_SDK_PATH} -Bbuild -DCMAKE_BUILD_TYPE=MinSizeRel -S.

attic/wasm/runwasi.py

@@ -1,7 +0,0 @@
-import wasmtime.loader
-
-# Assuming `your_wasm_file.wasm` is in the python load path...
-import loader_example
-
-# Now you're compiled and instantiated and ready to go!
-print(loader_example.main())

attic/wasm/test.gltf

@@ -1,223 +0,0 @@
-{
-   "accessors" : [
-      {
-         "bufferView" : 0,
-         "byteOffset" : 0,
-         "componentType" : 5123,
-         "count" : 18,
-         "max" : [
-            35
-         ],
-         "min" : [
-            0
-         ],
-         "type" : "SCALAR"
-      },
-      {
-         "bufferView" : 1,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000001
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 2,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 3,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            -0.000000,
-            -0.000000,
-            1.000000
-         ],
-         "min" : [
-            0.000000,
-            -0.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC4"
-      },
-      {
-         "bufferView" : 4,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC2"
-      },
-      {
-         "bufferView" : 5,
-         "byteOffset" : 0,
-         "componentType" : 5123,
-         "count" : 18,
-         "max" : [
-            71
-         ],
-         "min" : [
-            36
-         ],
-         "type" : "SCALAR"
-      }
-   ],
-   "asset" : {
-      "generator" : "VKTS glTF 2.0 exporter",
-      "version" : "2.0"
-   },
-   "bufferViews" : [
-      {
-         "buffer" : 0,
-         "byteLength" : 36,
-         "byteOffset" : 0,
-         "target" : 34963
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 72,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 504,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 576,
-         "byteOffset" : 936,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 288,
-         "byteOffset" : 1512,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 36,
-         "byteOffset" : 36,
-         "target" : 34963
-      }
-   ],
-   "buffers" : [
-      {
-         "byteLength" : 1800,
-         "uri" : "Cube.bin"
-      }
-   ],
-   "images" : [
-      {
-         "uri" : "Cube_BaseColor.png"
-      },
-      {
-         "uri" : "Cube_MetallicRoughness.png"
-      }
-   ],
-   "materials" : [
-      {
-         "name" : "Cube",
-         "pbrMetallicRoughness" : {
-            "baseColorTexture" : {
-               "index" : 0
-            },
-            "metallicRoughnessTexture" : {
-               "index" : 1
-            }
-         }
-      }
-   ],
-   "meshes" : [
-      {
-         "name" : "Cube",
-         "primitives" : [
-            {
-               "attributes" : {
-                  "NORMAL" : 2,
-                  "POSITION" : 1,
-                  "TANGENT" : 3,
-                  "TEXCOORD_0" : 4
-               },
-               "indices" : 0,
-               "material" : 0,
-               "mode" : 4
-            },
-            {
-               "attributes" : {
-                  "NORMAL" : 2,
-                  "POSITION" : 1,
-                  "TANGENT" : 3,
-                  "TEXCOORD_0" : 4
-               },
-               "indices" : 5,
-               "material" : 0,
-               "mode" : 4
-            }
-         ]
-      }
-   ],
-   "nodes" : [
-      {
-         "mesh" : 0,
-         "name" : "Cube"
-      }
-   ],
-   "samplers" : [
-      {}
-   ],
-   "scene" : 0,
-   "scenes" : [
-      {
-         "nodes" : [
-            0
-         ]
-      }
-   ],
-   "textures" : [
-      {
-         "sampler" : 0,
-         "source" : 0
-      },
-      {
-         "sampler" : 0,
-         "source" : 1
-      }
-   ]
-}

benchmark/Makefile

@@ -1,70 +0,0 @@
-# benchmark/Makefile — Build and run tinygltf v3 benchmarks
-#
-# Targets:
-#   make           — build gen_synthetic + bench_v3
-#   make generate  — generate synthetic test scenes
-#   make run       — run benchmarks on all generated scenes
-#   make report    — run benchmarks and produce CSV report
-#   make clean     — remove binaries and generated scenes
-
-CXX       ?= g++
-CXXFLAGS  ?= -O2 -std=c++17 -Wall -Wextra -Wno-unused-function
-CXXFLAGS  += -fno-rtti -fno-exceptions
-INCLUDES  = -I..
-
-BINDIR    = .
-GEN       = $(BINDIR)/gen_synthetic
-BENCH_V3  = $(BINDIR)/bench_v3
-
-# Iteration counts
-ITERATIONS ?= 10
-WARMUP     ?= 2
-PREFIX     ?= synthetic
-
-.PHONY: all generate run report clean
-
-all: $(GEN) $(BENCH_V3)
-
-$(GEN): gen_synthetic.cpp
-	$(CXX) $(CXXFLAGS) -o $@ $<
-
-$(BENCH_V3): bench_v3.cpp ../tiny_gltf_v3.h ../tiny_gltf_v3.c ../tinygltf_json_c.h
-	$(CXX) $(CXXFLAGS) $(INCLUDES) -o $@ $<
-
-# Generate synthetic scenes of varying sizes
-generate: $(GEN)
-	@echo "=== Generating synthetic scenes ==="
-	./$(GEN) --prefix $(PREFIX)
-	@echo ""
-	@echo "Generated files (binary + GLB):"
-	@ls -lh $(PREFIX)_*.gltf $(PREFIX)_*.glb $(PREFIX)_*.bin 2>/dev/null || true
-
-# Run benchmarks on all generated scenes
-run: $(BENCH_V3) generate
-	@echo ""
-	@echo "================================================================="
-	@echo "  tinygltf v3 Benchmark"
-	@echo "================================================================="
-	@echo ""
-	@for f in $(PREFIX)_*.glb $(PREFIX)_*.gltf; do \
-		if [ -f "$$f" ]; then \
-			./$(BENCH_V3) "$$f" --iterations $(ITERATIONS) --warmup $(WARMUP); \
-			echo ""; \
-		fi; \
-	done
-
-# Run benchmarks and produce CSV report
-report: $(BENCH_V3) generate
-	@echo "file,size_bytes,iterations,parse_min_ms,parse_max_ms,parse_avg_ms,parse_median_ms,throughput_mbs,arena_peak_bytes,meshes,nodes,accessors,materials,animations" > benchmark_report.csv
-	@for f in $(PREFIX)_*.glb $(PREFIX)_*.gltf; do \
-		if [ -f "$$f" ]; then \
-			./$(BENCH_V3) "$$f" --iterations $(ITERATIONS) --warmup $(WARMUP) --csv | tail -1 >> benchmark_report.csv; \
-		fi; \
-	done
-	@echo "=== Report written to benchmark_report.csv ==="
-	@cat benchmark_report.csv | column -t -s,
-
-clean:
-	rm -f $(GEN) $(BENCH_V3)
-	rm -f $(PREFIX)_*.gltf $(PREFIX)_*.glb $(PREFIX)_*.bin
-	rm -f benchmark_report.csv

benchmark/bench_v3.cpp

@@ -1,414 +0,0 @@
-/*
- * bench_v3.cpp — Benchmark tinygltf v3 parser: parse speed & memory.
- *
- * Measures:
- *   - File read time
- *   - JSON parse + model build time
- *   - Peak arena memory usage
- *   - Throughput (MB/s)
- *
- * Usage:
- *   bench_v3 <file.gltf|file.glb> [--iterations N] [--warmup N] [--quiet]
- *   bench_v3 --batch <file1> <file2> ... [--iterations N]
- */
-
-#define TINYGLTF3_IMPLEMENTATION
-#define TINYGLTF3_ENABLE_FS
-#include "tiny_gltf_v3.h"
-
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cmath>
-#include <vector>
-#include <string>
-#include <algorithm>
-#include <chrono>
-
-#if defined(__linux__)
-#include <sys/resource.h>
-#endif
-
-/* ------------------------------------------------------------------ */
-/* Timing helpers                                                     */
-/* ------------------------------------------------------------------ */
-
-using Clock = std::chrono::high_resolution_clock;
-using TimePoint = Clock::time_point;
-
-static double elapsed_ms(TimePoint start, TimePoint end) {
-    return std::chrono::duration<double, std::milli>(end - start).count();
-}
-
-/* ------------------------------------------------------------------ */
-/* Memory tracking allocator                                          */
-/* ------------------------------------------------------------------ */
-
-struct MemTracker {
-    size_t current;
-    size_t peak;
-    size_t total_allocs;
-    size_t total_frees;
-};
-
-static void *tracked_alloc(size_t size, void *ud) {
-    MemTracker *mt = (MemTracker *)ud;
-    void *ptr = malloc(size);
-    if (ptr) {
-        mt->current += size;
-        if (mt->current > mt->peak) mt->peak = mt->current;
-        mt->total_allocs++;
-    }
-    return ptr;
-}
-
-static void *tracked_realloc(void *ptr, size_t old_size, size_t new_size, void *ud) {
-    MemTracker *mt = (MemTracker *)ud;
-    void *new_ptr = realloc(ptr, new_size);
-    if (new_ptr) {
-        mt->current -= old_size;
-        mt->current += new_size;
-        if (mt->current > mt->peak) mt->peak = mt->current;
-    }
-    return new_ptr;
-}
-
-static void tracked_free(void *ptr, size_t size, void *ud) {
-    MemTracker *mt = (MemTracker *)ud;
-    if (ptr) {
-        mt->current -= size;
-        mt->total_frees++;
-        free(ptr);
-    }
-}
-
-/* ------------------------------------------------------------------ */
-/* RSS measurement (Linux)                                            */
-/* ------------------------------------------------------------------ */
-
-static size_t get_rss_bytes() {
-#if defined(__linux__)
-    FILE *f = fopen("/proc/self/statm", "r");
-    if (!f) return 0;
-    long pages = 0;
-    if (fscanf(f, "%*s %ld", &pages) != 1) pages = 0;
-    fclose(f);
-    return (size_t)pages * 4096;
-#else
-    return 0;
-#endif
-}
-
-/* ------------------------------------------------------------------ */
-/* Benchmark result                                                   */
-/* ------------------------------------------------------------------ */
-
-struct BenchResult {
-    std::string filename;
-    uint64_t    file_size;
-    int         iterations;
-
-    /* Parse timing (ms) */
-    double parse_min;
-    double parse_max;
-    double parse_avg;
-    double parse_median;
-
-    /* Memory */
-    size_t arena_peak;     /* Peak arena allocation */
-    size_t rss_before;
-    size_t rss_after;
-
-    /* Model stats */
-    uint32_t meshes;
-    uint32_t nodes;
-    uint32_t accessors;
-    uint32_t materials;
-    uint32_t animations;
-    uint32_t buffers;
-    uint32_t buffer_views;
-    uint32_t images;
-    uint32_t textures;
-
-    /* Derived */
-    double throughput_mbs; /* MB/s based on median */
-};
-
-/* ------------------------------------------------------------------ */
-/* Run benchmark for a single file                                    */
-/* ------------------------------------------------------------------ */
-
-static BenchResult bench_file(const char *filename, int iterations, int warmup,
-                               bool quiet, int float32_mode = 0,
-                               int skip_extras_values = 0,
-                               int borrow_input_buffers = 0) {
-    BenchResult r = {};
-    r.filename = filename;
-    r.iterations = iterations;
-
-    /* Read file into memory */
-    FILE *f = fopen(filename, "rb");
-    if (!f) {
-        fprintf(stderr, "ERROR: Cannot open '%s'\n", filename);
-        return r;
-    }
-    fseek(f, 0, SEEK_END);
-    long sz = ftell(f);
-    fseek(f, 0, SEEK_SET);
-    if (sz <= 0) { fclose(f); return r; }
-
-    std::vector<uint8_t> data((size_t)sz);
-    size_t rd = fread(data.data(), 1, (size_t)sz, f);
-    fclose(f);
-    if ((long)rd != sz) { return r; }
-
-    r.file_size = (uint64_t)sz;
-
-    /* Extract base dir */
-    std::string path(filename);
-    std::string base_dir;
-    size_t sep = path.find_last_of("/\\");
-    if (sep != std::string::npos) base_dir = path.substr(0, sep);
-
-    /* Warmup iterations (not measured) */
-    for (int i = 0; i < warmup; ++i) {
-        tg3_model model;
-        tg3_error_stack errors;
-        tg3_error_stack_init(&errors);
-        tg3_parse_auto(&model, &errors, data.data(), data.size(),
-                       base_dir.c_str(), (uint32_t)base_dir.size(), NULL);
-        tg3_model_free(&model);
-        tg3_error_stack_free(&errors);
-    }
-
-    /* Benchmark iterations */
-    std::vector<double> times;
-    times.reserve(iterations);
-
-    MemTracker tracker_best;
-    memset(&tracker_best, 0, sizeof(tracker_best));
-
-    r.rss_before = get_rss_bytes();
-
-    for (int i = 0; i < iterations; ++i) {
-        MemTracker tracker;
-        memset(&tracker, 0, sizeof(tracker));
-
-        tg3_parse_options opts;
-        tg3_parse_options_init(&opts);
-        opts.memory.allocator.alloc = tracked_alloc;
-        opts.memory.allocator.realloc = tracked_realloc;
-        opts.memory.allocator.free = tracked_free;
-        opts.memory.allocator.user_data = &tracker;
-        opts.parse_float32 = float32_mode;
-        opts.skip_extras_values = skip_extras_values;
-        opts.borrow_input_buffers = borrow_input_buffers;
-
-        tg3_model model;
-        tg3_error_stack errors;
-        tg3_error_stack_init(&errors);
-
-        TimePoint t0 = Clock::now();
-
-        tg3_error_code err = tg3_parse_auto(&model, &errors,
-                                             data.data(), data.size(),
-                                             base_dir.c_str(),
-                                             (uint32_t)base_dir.size(),
-                                             &opts);
-
-        TimePoint t1 = Clock::now();
-        double ms = elapsed_ms(t0, t1);
-        times.push_back(ms);
-
-        /* Capture model stats on first successful iteration */
-        if (i == 0 && err == TG3_OK) {
-            r.meshes = model.meshes_count;
-            r.nodes = model.nodes_count;
-            r.accessors = model.accessors_count;
-            r.materials = model.materials_count;
-            r.animations = model.animations_count;
-            r.buffers = model.buffers_count;
-            r.buffer_views = model.buffer_views_count;
-            r.images = model.images_count;
-            r.textures = model.textures_count;
-        }
-
-        if (tracker.peak > tracker_best.peak) {
-            tracker_best = tracker;
-        }
-
-        tg3_model_free(&model);
-        tg3_error_stack_free(&errors);
-
-        if (err != TG3_OK && !quiet) {
-            fprintf(stderr, "  Parse error on iteration %d: code %d\n", i, (int)err);
-        }
-    }
-
-    r.rss_after = get_rss_bytes();
-    r.arena_peak = tracker_best.peak;
-
-    /* Compute stats */
-    std::sort(times.begin(), times.end());
-    r.parse_min = times.front();
-    r.parse_max = times.back();
-    double sum = 0;
-    for (double t : times) sum += t;
-    r.parse_avg = sum / times.size();
-    r.parse_median = times[times.size() / 2];
-
-    /* Throughput: file_size / median_time */
-    if (r.parse_median > 0) {
-        r.throughput_mbs = ((double)r.file_size / (1024.0 * 1024.0)) /
-                           (r.parse_median / 1000.0);
-    }
-
-    return r;
-}
-
-/* ------------------------------------------------------------------ */
-/* Print results                                                      */
-/* ------------------------------------------------------------------ */
-
-static const char *human_bytes(size_t bytes, char *buf, size_t buf_sz) {
-    if (bytes >= 1024ULL * 1024 * 1024)
-        snprintf(buf, buf_sz, "%.2f GB", (double)bytes / (1024.0 * 1024 * 1024));
-    else if (bytes >= 1024 * 1024)
-        snprintf(buf, buf_sz, "%.2f MB", (double)bytes / (1024.0 * 1024));
-    else if (bytes >= 1024)
-        snprintf(buf, buf_sz, "%.2f KB", (double)bytes / 1024.0);
-    else
-        snprintf(buf, buf_sz, "%zu B", bytes);
-    return buf;
-}
-
-static void print_result(const BenchResult &r) {
-    char buf1[64], buf2[64];
-
-    printf("┌─────────────────────────────────────────────────────────────────┐\n");
-    printf("│ %-63s │\n", r.filename.c_str());
-    printf("├─────────────────────────────────────────────────────────────────┤\n");
-    printf("│ File size:      %-47s │\n", human_bytes((size_t)r.file_size, buf1, sizeof(buf1)));
-    printf("│ Iterations:     %-47d │\n", r.iterations);
-    printf("│                                                                 │\n");
-    printf("│ Parse time (ms):                                                │\n");
-    printf("│   min:    %10.3f                                            │\n", r.parse_min);
-    printf("│   max:    %10.3f                                            │\n", r.parse_max);
-    printf("│   avg:    %10.3f                                            │\n", r.parse_avg);
-    printf("│   median: %10.3f                                            │\n", r.parse_median);
-    printf("│                                                                 │\n");
-    printf("│ Throughput:     %-47s │\n",
-           (snprintf(buf1, sizeof(buf1), "%.2f MB/s", r.throughput_mbs), buf1));
-    printf("│ Arena peak:     %-47s │\n", human_bytes(r.arena_peak, buf1, sizeof(buf1)));
-    if (r.rss_before > 0) {
-        printf("│ RSS before:     %-47s │\n", human_bytes(r.rss_before, buf1, sizeof(buf1)));
-        printf("│ RSS after:      %-47s │\n", human_bytes(r.rss_after, buf2, sizeof(buf2)));
-    }
-    printf("│                                                                 │\n");
-    printf("│ Model: %u meshes, %u nodes, %u accessors, %u materials",
-           r.meshes, r.nodes, r.accessors, r.materials);
-    printf("        │\n");
-    printf("│        %u animations, %u buffers, %u images",
-           r.animations, r.buffers, r.images);
-    printf("                       │\n");
-    printf("└─────────────────────────────────────────────────────────────────┘\n");
-}
-
-static void print_csv_header() {
-    printf("file,size_bytes,iterations,parse_min_ms,parse_max_ms,parse_avg_ms,"
-           "parse_median_ms,throughput_mbs,arena_peak_bytes,"
-           "meshes,nodes,accessors,materials,animations\n");
-}
-
-static void print_csv_row(const BenchResult &r) {
-    printf("%s,%lu,%d,%.3f,%.3f,%.3f,%.3f,%.2f,%zu,%u,%u,%u,%u,%u\n",
-           r.filename.c_str(), (unsigned long)r.file_size, r.iterations,
-           r.parse_min, r.parse_max, r.parse_avg, r.parse_median,
-           r.throughput_mbs, r.arena_peak,
-           r.meshes, r.nodes, r.accessors, r.materials, r.animations);
-}
-
-/* ------------------------------------------------------------------ */
-/* Main                                                               */
-/* ------------------------------------------------------------------ */
-
-static void usage() {
-    fprintf(stderr,
-        "Usage:\n"
-        "  bench_v3 <file> [--iterations N] [--warmup N] [--csv] [--quiet]\n"
-        "  bench_v3 --batch <file1> [file2] ... [--iterations N] [--csv]\n"
-        "\n"
-        "Options:\n"
-        "  --iterations N   Number of timed parse iterations (default: 10)\n"
-        "  --warmup N       Number of warmup iterations (default: 2)\n"
-        "  --csv            Output in CSV format\n"
-        "  --quiet          Suppress per-iteration error messages\n"
-        "  --batch          Benchmark multiple files\n"
-        "  --float32        Parse JSON floats as float32 (faster, less precise)\n"
-        "  --skip-extras-values\n"
-        "                   Skip materializing extras/unknown extension values\n"
-        "  --borrow-input-buffers\n"
-        "                   Let GLB buffers reference caller-owned input bytes\n");
-}
-
-int main(int argc, char **argv) {
-    if (argc < 2) { usage(); return 1; }
-
-    int iterations = 10;
-    int warmup = 2;
-    bool csv = false;
-    bool quiet = false;
-    int float32_mode = 0;
-    int skip_extras_values = 0;
-    int borrow_input_buffers = 0;
-    std::vector<std::string> files;
-
-    for (int i = 1; i < argc; ++i) {
-        if (strcmp(argv[i], "--iterations") == 0 && i + 1 < argc) {
-            iterations = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "--warmup") == 0 && i + 1 < argc) {
-            warmup = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "--csv") == 0) {
-            csv = true;
-        } else if (strcmp(argv[i], "--quiet") == 0) {
-            quiet = true;
-        } else if (strcmp(argv[i], "--float32") == 0) {
-            float32_mode = 1;
-        } else if (strcmp(argv[i], "--skip-extras-values") == 0) {
-            skip_extras_values = 1;
-        } else if (strcmp(argv[i], "--borrow-input-buffers") == 0) {
-            borrow_input_buffers = 1;
-        } else if (strcmp(argv[i], "--batch") == 0) {
-            /* batch mode: just collect files */
-        } else if (argv[i][0] != '-') {
-            files.push_back(argv[i]);
-        }
-    }
-
-    if (files.empty()) { usage(); return 1; }
-
-    if (csv) print_csv_header();
-
-    for (const auto &file : files) {
-        if (!csv && !quiet) {
-            printf("Benchmarking: %s (%d iterations, %d warmup%s)\n",
-                   file.c_str(), iterations, warmup,
-                   float32_mode ? ", float32" :
-                   skip_extras_values ? ", skip extras" :
-                   borrow_input_buffers ? ", borrow buffers" : "");
-        }
-
-        BenchResult r = bench_file(file.c_str(), iterations, warmup, quiet,
-                                   float32_mode, skip_extras_values,
-                                   borrow_input_buffers);
-
-        if (csv) {
-            print_csv_row(r);
-        } else {
-            print_result(r);
-            printf("\n");
-        }
-    }
-
-    return 0;
-}

benchmark/gen_synthetic.cpp

@@ -1,740 +0,0 @@
-/*
- * gen_synthetic.cpp — Generate synthetic glTF 2.0 scenes for benchmarking.
- *
- * Produces .gltf (ASCII) and .glb (binary) files with configurable:
- *   - Number of meshes, each with N vertices/triangles
- *   - Number of nodes (flat hierarchy)
- *   - Number of materials
- *   - Number of animations with M keyframes
- *
- * Usage:
- *   gen_synthetic [--meshes N] [--verts-per-mesh N] [--nodes N]
- *                 [--materials N] [--animations N] [--keyframes N]
- *                 [--prefix NAME]
- *
- * Outputs: <prefix>_<label>.gltf and <prefix>_<label>.glb
- */
-
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cmath>
-#include <string>
-#include <vector>
-#include <cstdint>
-
-/* ------------------------------------------------------------------ */
-/* Tiny JSON writer (no dependencies)                                 */
-/* ------------------------------------------------------------------ */
-
-struct JsonWriter {
-    std::string buf;
-    int indent;
-    bool need_comma;
-    std::vector<bool> stack; /* true = array context */
-
-    JsonWriter() : indent(0), need_comma(false) {}
-
-    void comma() {
-        if (need_comma) buf += ",";
-        buf += "\n";
-        for (int i = 0; i < indent; ++i) buf += "  ";
-    }
-
-    void begin_obj() {
-        if (!stack.empty()) comma();
-        buf += "{";
-        indent++;
-        need_comma = false;
-        stack.push_back(false);
-    }
-    void end_obj() {
-        indent--;
-        buf += "\n";
-        for (int i = 0; i < indent; ++i) buf += "  ";
-        buf += "}";
-        stack.pop_back();
-        need_comma = true;
-    }
-
-    void begin_arr() {
-        if (!stack.empty() && !need_comma) { /* first elem */ }
-        buf += "[";
-        indent++;
-        need_comma = false;
-        stack.push_back(true);
-    }
-    void end_arr() {
-        indent--;
-        buf += "\n";
-        for (int i = 0; i < indent; ++i) buf += "  ";
-        buf += "]";
-        stack.pop_back();
-        need_comma = true;
-    }
-
-    void key(const char *k) {
-        comma();
-        buf += "\"";
-        buf += k;
-        buf += "\": ";
-        need_comma = false;
-    }
-
-    void val_str(const char *v) {
-        if (stack.back()) comma();
-        buf += "\"";
-        buf += v;
-        buf += "\"";
-        need_comma = true;
-    }
-    void val_int(int64_t v) {
-        if (stack.back()) comma();
-        buf += std::to_string(v);
-        need_comma = true;
-    }
-    void val_double(double v) {
-        if (stack.back()) comma();
-        char tmp[64];
-        snprintf(tmp, sizeof(tmp), "%.6g", v);
-        buf += tmp;
-        need_comma = true;
-    }
-    void val_bool(bool v) {
-        if (stack.back()) comma();
-        buf += v ? "true" : "false";
-        need_comma = true;
-    }
-
-    void kv_str(const char *k, const char *v) { key(k); val_str(v); need_comma = true; }
-    void kv_int(const char *k, int64_t v) { key(k); val_int(v); need_comma = true; }
-    void kv_double(const char *k, double v) { key(k); val_double(v); need_comma = true; }
-    void kv_bool(const char *k, bool v) { key(k); val_bool(v); need_comma = true; }
-};
-
-/* ------------------------------------------------------------------ */
-/* Binary buffer builder                                              */
-/* ------------------------------------------------------------------ */
-
-struct BinBuffer {
-    std::vector<uint8_t> data;
-
-    size_t offset() const { return data.size(); }
-
-    void push_float(float v) {
-        const uint8_t *p = reinterpret_cast<const uint8_t*>(&v);
-        data.insert(data.end(), p, p + 4);
-    }
-    void push_u16(uint16_t v) {
-        const uint8_t *p = reinterpret_cast<const uint8_t*>(&v);
-        data.insert(data.end(), p, p + 2);
-    }
-    void push_u32(uint32_t v) {
-        const uint8_t *p = reinterpret_cast<const uint8_t*>(&v);
-        data.insert(data.end(), p, p + 4);
-    }
-    void align4() {
-        while (data.size() % 4 != 0) data.push_back(0);
-    }
-};
-
-/* ------------------------------------------------------------------ */
-/* Scene config                                                       */
-/* ------------------------------------------------------------------ */
-
-struct SceneConfig {
-    int num_meshes;
-    int verts_per_mesh;
-    int num_nodes;
-    int num_materials;
-    int num_animations;
-    int keyframes;
-};
-
-/* ------------------------------------------------------------------ */
-/* Generate the scene                                                 */
-/* ------------------------------------------------------------------ */
-
-struct AccessorInfo {
-    int buffer_view;
-    int component_type;
-    int count;
-    const char *type;
-    float min_vals[3];
-    float max_vals[3];
-    int min_max_components; /* 0 = none, 1 = scalar, 3 = vec3 */
-};
-
-static void generate_scene(const SceneConfig &cfg,
-                            std::string &out_json,
-                            std::vector<uint8_t> &out_bin) {
-    BinBuffer bin;
-
-    /* Pre-compute sizes */
-    int tris_per_mesh = cfg.verts_per_mesh / 3;
-    if (tris_per_mesh < 1) tris_per_mesh = 1;
-    int actual_verts = tris_per_mesh * 3;
-
-    /*
-     * For each mesh:
-     *   - positions: actual_verts * 3 floats
-     *   - normals:   actual_verts * 3 floats
-     *   - indices:   tris_per_mesh * 3 uint16 (or uint32 if >65535)
-     *
-     * For each animation:
-     *   - time keys:  keyframes floats
-     *   - translation values: keyframes * 3 floats
-     */
-
-    /* Track buffer views and accessors */
-    std::vector<size_t> bv_offsets;
-    std::vector<size_t> bv_lengths;
-    std::vector<AccessorInfo> accessors;
-    int bv_idx = 0;
-
-    bool use_u32_indices = (actual_verts > 65535);
-
-    /* === Mesh data === */
-    for (int m = 0; m < cfg.num_meshes; ++m) {
-        float mesh_offset_x = (float)m * 5.0f;
-
-        /* Positions */
-        size_t pos_off = bin.offset();
-        float pmin[3] = {1e30f, 1e30f, 1e30f};
-        float pmax[3] = {-1e30f, -1e30f, -1e30f};
-        for (int v = 0; v < actual_verts; ++v) {
-            float angle = (float)v / (float)actual_verts * 6.2831853f;
-            float r = 1.0f + 0.3f * sinf(angle * 5.0f);
-            float x = mesh_offset_x + r * cosf(angle);
-            float y = r * sinf(angle);
-            float z = 0.5f * sinf(angle * 3.0f + (float)m);
-            bin.push_float(x); bin.push_float(y); bin.push_float(z);
-            if (x < pmin[0]) pmin[0] = x;
-            if (x > pmax[0]) pmax[0] = x;
-            if (y < pmin[1]) pmin[1] = y;
-            if (y > pmax[1]) pmax[1] = y;
-            if (z < pmin[2]) pmin[2] = z;
-            if (z > pmax[2]) pmax[2] = z;
-        }
-        size_t pos_len = bin.offset() - pos_off;
-        bin.align4();
-        bv_offsets.push_back(pos_off); bv_lengths.push_back(pos_len);
-        int pos_bv = bv_idx++;
-
-        AccessorInfo pos_acc;
-        pos_acc.buffer_view = pos_bv;
-        pos_acc.component_type = 5126; /* FLOAT */
-        pos_acc.count = actual_verts;
-        pos_acc.type = "VEC3";
-        memcpy(pos_acc.min_vals, pmin, sizeof(pmin));
-        memcpy(pos_acc.max_vals, pmax, sizeof(pmax));
-        pos_acc.min_max_components = 3;
-        accessors.push_back(pos_acc);
-
-        /* Normals */
-        size_t norm_off = bin.offset();
-        for (int v = 0; v < actual_verts; ++v) {
-            float angle = (float)v / (float)actual_verts * 6.2831853f;
-            float nx = cosf(angle), ny = sinf(angle), nz = 0.0f;
-            float len = sqrtf(nx*nx + ny*ny + nz*nz);
-            if (len > 0) { nx /= len; ny /= len; nz /= len; }
-            bin.push_float(nx); bin.push_float(ny); bin.push_float(nz);
-        }
-        size_t norm_len = bin.offset() - norm_off;
-        bin.align4();
-        bv_offsets.push_back(norm_off); bv_lengths.push_back(norm_len);
-        int norm_bv = bv_idx++;
-
-        AccessorInfo norm_acc;
-        norm_acc.buffer_view = norm_bv;
-        norm_acc.component_type = 5126;
-        norm_acc.count = actual_verts;
-        norm_acc.type = "VEC3";
-        norm_acc.min_max_components = 0;
-        accessors.push_back(norm_acc);
-
-        /* Indices */
-        size_t idx_off = bin.offset();
-        for (int t = 0; t < tris_per_mesh; ++t) {
-            if (use_u32_indices) {
-                bin.push_u32((uint32_t)(t * 3));
-                bin.push_u32((uint32_t)(t * 3 + 1));
-                bin.push_u32((uint32_t)(t * 3 + 2));
-            } else {
-                bin.push_u16((uint16_t)(t * 3));
-                bin.push_u16((uint16_t)(t * 3 + 1));
-                bin.push_u16((uint16_t)(t * 3 + 2));
-            }
-        }
-        size_t idx_len = bin.offset() - idx_off;
-        bin.align4();
-        bv_offsets.push_back(idx_off); bv_lengths.push_back(idx_len);
-        int idx_bv = bv_idx++;
-
-        AccessorInfo idx_acc;
-        idx_acc.buffer_view = idx_bv;
-        idx_acc.component_type = use_u32_indices ? 5125 : 5123; /* UINT or USHORT */
-        idx_acc.count = tris_per_mesh * 3;
-        idx_acc.type = "SCALAR";
-        idx_acc.min_max_components = 0;
-        accessors.push_back(idx_acc);
-    }
-
-    /* === Animation data === */
-    int anim_time_accessor_start = (int)accessors.size();
-    for (int a = 0; a < cfg.num_animations; ++a) {
-        /* Time keys */
-        size_t time_off = bin.offset();
-        float tmin = 0.0f, tmax = 0.0f;
-        for (int k = 0; k < cfg.keyframes; ++k) {
-            float t = (float)k / (float)(cfg.keyframes - 1) * 10.0f;
-            bin.push_float(t);
-            if (k == 0) tmin = t;
-            tmax = t;
-        }
-        size_t time_len = bin.offset() - time_off;
-        bin.align4();
-        bv_offsets.push_back(time_off); bv_lengths.push_back(time_len);
-        int time_bv = bv_idx++;
-
-        AccessorInfo time_acc;
-        time_acc.buffer_view = time_bv;
-        time_acc.component_type = 5126;
-        time_acc.count = cfg.keyframes;
-        time_acc.type = "SCALAR";
-        time_acc.min_vals[0] = tmin;
-        time_acc.max_vals[0] = tmax;
-        time_acc.min_max_components = 1;
-        accessors.push_back(time_acc);
-
-        /* Translation values */
-        size_t val_off = bin.offset();
-        for (int k = 0; k < cfg.keyframes; ++k) {
-            float t = (float)k / (float)(cfg.keyframes - 1) * 10.0f;
-            float x = sinf(t * 0.5f + (float)a) * 2.0f;
-            float y = cosf(t * 0.3f) * 1.5f;
-            float z = sinf(t * 0.7f + (float)a * 0.5f);
-            bin.push_float(x); bin.push_float(y); bin.push_float(z);
-        }
-        size_t val_len = bin.offset() - val_off;
-        bin.align4();
-        bv_offsets.push_back(val_off); bv_lengths.push_back(val_len);
-        int val_bv = bv_idx++;
-
-        AccessorInfo val_acc;
-        val_acc.buffer_view = val_bv;
-        val_acc.component_type = 5126;
-        val_acc.count = cfg.keyframes;
-        val_acc.type = "VEC3";
-        val_acc.min_max_components = 0;
-        accessors.push_back(val_acc);
-    }
-
-    size_t total_bin = bin.data.size();
-
-    /* === Build JSON === */
-    JsonWriter w;
-    w.begin_obj();
-
-    /* asset */
-    w.key("asset"); w.begin_obj();
-    w.kv_str("version", "2.0");
-    w.kv_str("generator", "tinygltf_benchmark_gen");
-    w.end_obj();
-
-    /* scene */
-    w.kv_int("scene", 0);
-
-    /* scenes */
-    w.key("scenes"); w.begin_arr();
-    w.begin_obj();
-    w.kv_str("name", "BenchmarkScene");
-    w.key("nodes"); w.begin_arr();
-    for (int n = 0; n < cfg.num_nodes; ++n) w.val_int(n);
-    w.end_arr();
-    w.end_obj();
-    w.end_arr();
-
-    /* nodes */
-    w.key("nodes"); w.begin_arr();
-    for (int n = 0; n < cfg.num_nodes; ++n) {
-        w.begin_obj();
-        w.kv_str("name", ("Node_" + std::to_string(n)).c_str());
-        if (n < cfg.num_meshes) {
-            w.kv_int("mesh", n);
-        }
-        w.key("translation"); w.begin_arr();
-        w.val_double((double)n * 3.0);
-        w.val_double(0.0);
-        w.val_double(0.0);
-        w.end_arr();
-        w.end_obj();
-    }
-    w.end_arr();
-
-    /* meshes */
-    w.key("meshes"); w.begin_arr();
-    for (int m = 0; m < cfg.num_meshes; ++m) {
-        int base_acc = m * 3; /* pos, norm, idx per mesh */
-        w.begin_obj();
-        w.kv_str("name", ("Mesh_" + std::to_string(m)).c_str());
-        w.key("primitives"); w.begin_arr();
-        w.begin_obj();
-        w.key("attributes"); w.begin_obj();
-        w.kv_int("POSITION", base_acc);
-        w.kv_int("NORMAL", base_acc + 1);
-        w.end_obj();
-        w.kv_int("indices", base_acc + 2);
-        w.kv_int("material", m % cfg.num_materials);
-        w.kv_int("mode", 4);
-        w.end_obj();
-        w.end_arr();
-        w.end_obj();
-    }
-    w.end_arr();
-
-    /* materials */
-    w.key("materials"); w.begin_arr();
-    for (int m = 0; m < cfg.num_materials; ++m) {
-        w.begin_obj();
-        w.kv_str("name", ("Material_" + std::to_string(m)).c_str());
-        w.key("pbrMetallicRoughness"); w.begin_obj();
-        w.key("baseColorFactor"); w.begin_arr();
-        float hue = (float)m / (float)cfg.num_materials;
-        w.val_double(0.5 + 0.5 * sin(hue * 6.28));
-        w.val_double(0.5 + 0.5 * sin(hue * 6.28 + 2.09));
-        w.val_double(0.5 + 0.5 * sin(hue * 6.28 + 4.19));
-        w.val_double(1.0);
-        w.end_arr();
-        w.kv_double("metallicFactor", 0.2 + 0.6 * ((double)m / cfg.num_materials));
-        w.kv_double("roughnessFactor", 0.3 + 0.5 * ((double)(cfg.num_materials - m) / cfg.num_materials));
-        w.end_obj();
-        w.end_obj();
-    }
-    w.end_arr();
-
-    /* accessors */
-    w.key("accessors"); w.begin_arr();
-    for (size_t i = 0; i < accessors.size(); ++i) {
-        const AccessorInfo &a = accessors[i];
-        w.begin_obj();
-        w.kv_int("bufferView", a.buffer_view);
-        w.kv_int("componentType", a.component_type);
-        w.kv_int("count", a.count);
-        w.kv_str("type", a.type);
-        if (a.min_max_components == 1) {
-            w.key("min"); w.begin_arr(); w.val_double(a.min_vals[0]); w.end_arr();
-            w.key("max"); w.begin_arr(); w.val_double(a.max_vals[0]); w.end_arr();
-        } else if (a.min_max_components == 3) {
-            w.key("min"); w.begin_arr();
-            w.val_double(a.min_vals[0]); w.val_double(a.min_vals[1]); w.val_double(a.min_vals[2]);
-            w.end_arr();
-            w.key("max"); w.begin_arr();
-            w.val_double(a.max_vals[0]); w.val_double(a.max_vals[1]); w.val_double(a.max_vals[2]);
-            w.end_arr();
-        }
-        w.end_obj();
-    }
-    w.end_arr();
-
-    /* bufferViews */
-    w.key("bufferViews"); w.begin_arr();
-    for (int i = 0; i < bv_idx; ++i) {
-        w.begin_obj();
-        w.kv_int("buffer", 0);
-        w.kv_int("byteOffset", (int64_t)bv_offsets[i]);
-        w.kv_int("byteLength", (int64_t)bv_lengths[i]);
-        w.end_obj();
-    }
-    w.end_arr();
-
-    /* buffers */
-    w.key("buffers"); w.begin_arr();
-    w.begin_obj();
-    w.kv_int("byteLength", (int64_t)total_bin);
-    /* URI will be set by caller for .gltf, omitted for .glb */
-    w.end_obj();
-    w.end_arr();
-
-    /* animations */
-    if (cfg.num_animations > 0) {
-        w.key("animations"); w.begin_arr();
-        for (int a = 0; a < cfg.num_animations; ++a) {
-            int time_acc = anim_time_accessor_start + a * 2;
-            int val_acc = time_acc + 1;
-            /* Target node: cycle through available nodes */
-            int target_node = a % cfg.num_nodes;
-
-            w.begin_obj();
-            w.kv_str("name", ("Anim_" + std::to_string(a)).c_str());
-
-            w.key("channels"); w.begin_arr();
-            w.begin_obj();
-            w.kv_int("sampler", 0);
-            w.key("target"); w.begin_obj();
-            w.kv_int("node", target_node);
-            w.kv_str("path", "translation");
-            w.end_obj();
-            w.end_obj();
-            w.end_arr();
-
-            w.key("samplers"); w.begin_arr();
-            w.begin_obj();
-            w.kv_int("input", time_acc);
-            w.kv_int("output", val_acc);
-            w.kv_str("interpolation", "LINEAR");
-            w.end_obj();
-            w.end_arr();
-
-            w.end_obj();
-        }
-        w.end_arr();
-    }
-
-    w.end_obj();
-
-    out_json = w.buf;
-    out_bin = bin.data;
-}
-
-/* ------------------------------------------------------------------ */
-/* Write .gltf + .bin                                                 */
-/* ------------------------------------------------------------------ */
-
-static void write_gltf(const std::string &prefix, const std::string &label,
-                        const std::string &json_str,
-                        const std::vector<uint8_t> &bin_data) {
-    std::string bin_name = prefix + "_" + label + ".bin";
-    std::string gltf_name = prefix + "_" + label + ".gltf";
-
-    /* Inject "uri" into the buffer object in JSON */
-    std::string json_patched = json_str;
-    /* Find the buffers array and add uri before the closing } of the buffer */
-    size_t pos = json_patched.find("\"byteLength\"");
-    if (pos != std::string::npos) {
-        /* Find the line end after byteLength value */
-        size_t line_end = json_patched.find('\n', pos);
-        if (line_end != std::string::npos) {
-            /* Extract just the filename for uri */
-            std::string bin_filename = prefix + "_" + label + ".bin";
-            std::string uri_line = ",\n      \"uri\": \"" + bin_filename + "\"";
-            json_patched.insert(line_end, uri_line);
-        }
-    }
-
-    /* Write .bin */
-    FILE *f = fopen(bin_name.c_str(), "wb");
-    if (f) {
-        fwrite(bin_data.data(), 1, bin_data.size(), f);
-        fclose(f);
-    }
-
-    /* Write .gltf */
-    f = fopen(gltf_name.c_str(), "w");
-    if (f) {
-        fwrite(json_patched.c_str(), 1, json_patched.size(), f);
-        fclose(f);
-    }
-
-    printf("  Written: %s (%zu bytes JSON) + %s (%zu bytes binary)\n",
-           gltf_name.c_str(), json_patched.size(),
-           bin_name.c_str(), bin_data.size());
-}
-
-/* ------------------------------------------------------------------ */
-/* Write .glb                                                         */
-/* ------------------------------------------------------------------ */
-
-static void write_glb(const std::string &prefix, const std::string &label,
-                       const std::string &json_str,
-                       const std::vector<uint8_t> &bin_data) {
-    std::string glb_name = prefix + "_" + label + ".glb";
-
-    uint32_t json_len = (uint32_t)json_str.size();
-    uint32_t json_padded = (json_len + 3) & ~3u;
-    uint32_t bin_len = (uint32_t)bin_data.size();
-    uint32_t bin_padded = (bin_len + 3) & ~3u;
-
-    uint32_t total = 12 + 8 + json_padded + 8 + bin_padded;
-
-    FILE *f = fopen(glb_name.c_str(), "wb");
-    if (!f) return;
-
-    /* Header */
-    fwrite("glTF", 1, 4, f);
-    uint32_t version = 2;
-    fwrite(&version, 4, 1, f);
-    fwrite(&total, 4, 1, f);
-
-    /* JSON chunk */
-    uint32_t json_type = 0x4E4F534A;
-    fwrite(&json_padded, 4, 1, f);
-    fwrite(&json_type, 4, 1, f);
-    fwrite(json_str.c_str(), 1, json_len, f);
-    for (uint32_t i = json_len; i < json_padded; ++i) {
-        char sp = ' ';
-        fwrite(&sp, 1, 1, f);
-    }
-
-    /* BIN chunk */
-    uint32_t bin_type = 0x004E4942;
-    fwrite(&bin_padded, 4, 1, f);
-    fwrite(&bin_type, 4, 1, f);
-    fwrite(bin_data.data(), 1, bin_len, f);
-    for (uint32_t i = bin_len; i < bin_padded; ++i) {
-        char z = 0;
-        fwrite(&z, 1, 1, f);
-    }
-
-    fclose(f);
-    printf("  Written: %s (%u bytes)\n", glb_name.c_str(), total);
-}
-
-/* ------------------------------------------------------------------ */
-/* Preset configurations                                              */
-/* ------------------------------------------------------------------ */
-
-struct Preset {
-    const char *label;
-    SceneConfig cfg;
-};
-
-static Preset presets[] = {
-    {"tiny",   {1,   100,    2,  1, 0,   0}},
-    {"small",  {5,   1000,  10,  3, 2,  50}},
-    {"medium", {20,  5000,  50, 10, 5, 200}},
-    {"large",  {100, 10000, 200, 20, 10, 500}},
-    {"huge",   {500, 50000, 1000, 50, 50, 1000}},
-};
-
-static const int num_presets = (int)(sizeof(presets) / sizeof(presets[0]));
-
-/* ------------------------------------------------------------------ */
-/* Generate float-heavy scene (~500MB of ASCII float values in JSON)  */
-/* ------------------------------------------------------------------ */
-
-static void generate_float_heavy(const std::string &prefix, size_t target_mb) {
-    std::string gltf_name = prefix + "_float_heavy.gltf";
-    FILE *f = fopen(gltf_name.c_str(), "w");
-    if (!f) {
-        fprintf(stderr, "Cannot open %s\n", gltf_name.c_str());
-        return;
-    }
-
-    /* Write minimal valid glTF with massive extras float array */
-    fprintf(f, "{\n");
-    fprintf(f, "  \"asset\": {\"version\": \"2.0\", \"generator\": \"tinygltf_benchmark_gen\"},\n");
-    fprintf(f, "  \"scene\": 0,\n");
-    fprintf(f, "  \"scenes\": [{\"name\": \"FloatHeavy\", \"nodes\": [0]}],\n");
-    fprintf(f, "  \"nodes\": [{\"name\": \"Root\"}],\n");
-    fprintf(f, "  \"extras\": {\n");
-
-    size_t target_bytes = target_mb * 1024ULL * 1024ULL;
-    size_t total_written = 0;
-    int num_channels = 10;
-    size_t per_channel = target_bytes / (size_t)num_channels;
-
-    for (int ch = 0; ch < num_channels; ++ch) {
-        fprintf(f, "    \"channel_%d\": [\n      ", ch);
-        size_t ch_written = 0;
-        size_t count = 0;
-        uint64_t seed = (uint64_t)ch * 7919ULL + 1;
-        bool first = true;
-
-        while (ch_written < per_channel) {
-            /* Comma before every value except the first */
-            if (!first) {
-                fwrite(",\n      ", 1, 8, f);
-                ch_written += 8;
-            }
-            first = false;
-
-            /* Generate varied float values: mix of magnitudes and precisions */
-            seed = seed * 6364136223846793005ULL + 1442695040888963407ULL;
-            double raw = (double)(int64_t)seed / (double)INT64_MAX;
-
-            double val;
-            int kind = (int)(count % 5);
-            switch (kind) {
-                case 0: val = raw * 1000.0; break;           /* large: -999.xxx */
-                case 1: val = raw * 0.001; break;            /* small: 0.000xxx */
-                case 2: val = raw * 3.14159265358979; break; /* medium: -3.14..3.14 */
-                case 3: val = raw * 1e6; break;              /* very large */
-                case 4: val = raw * 1e-6; break;             /* very small */
-                default: val = raw; break;
-            }
-
-            char buf[64];
-            int len = snprintf(buf, sizeof(buf), "%.8g", val);
-            fwrite(buf, 1, (size_t)len, f);
-            ch_written += (size_t)len;
-            count++;
-        }
-
-        total_written += ch_written;
-
-        if (ch < num_channels - 1) {
-            fprintf(f, "\n    ],\n");
-        } else {
-            fprintf(f, "\n    ]\n");
-        }
-    }
-
-    fprintf(f, "  }\n");
-    fprintf(f, "}\n");
-    fclose(f);
-
-    /* Report actual file size */
-    f = fopen(gltf_name.c_str(), "rb");
-    if (f) {
-        fseek(f, 0, SEEK_END);
-        long sz = ftell(f);
-        fclose(f);
-        printf("  Written: %s (%.1f MB, ~%zu float values across %d channels)\n",
-               gltf_name.c_str(), (double)sz / (1024.0 * 1024.0),
-               total_written / 12, num_channels);
-    }
-}
-
-/* ------------------------------------------------------------------ */
-/* Main                                                               */
-/* ------------------------------------------------------------------ */
-
-int main(int argc, char **argv) {
-    std::string prefix = "synthetic";
-
-    /* Parse args */
-    for (int i = 1; i < argc; ++i) {
-        if (strcmp(argv[i], "--prefix") == 0 && i + 1 < argc) {
-            prefix = argv[++i];
-        }
-    }
-
-    printf("Generating synthetic glTF benchmark scenes...\n\n");
-
-    for (int p = 0; p < num_presets; ++p) {
-        const Preset &pr = presets[p];
-
-        printf("[%s] meshes=%d verts/mesh=%d nodes=%d materials=%d "
-               "animations=%d keyframes=%d\n",
-               pr.label, pr.cfg.num_meshes, pr.cfg.verts_per_mesh,
-               pr.cfg.num_nodes, pr.cfg.num_materials,
-               pr.cfg.num_animations, pr.cfg.keyframes);
-
-        std::string json;
-        std::vector<uint8_t> bin;
-        generate_scene(pr.cfg, json, bin);
-
-        write_gltf(prefix, pr.label, json, bin);
-        write_glb(prefix, pr.label, json, bin);
-        printf("\n");
-    }
-
-    /* Float-heavy scene: ~500MB of ASCII floats in JSON */
-    printf("[float_heavy] ~500MB of ASCII float values in JSON extras\n");
-    generate_float_heavy(prefix, 500);
-    printf("\n");
-
-    printf("Done.\n");
-    return 0;
-}