初始化内容

2026-09-16 14:07:40 +08:00
parent 6934b390bf
commit 4f643c1e7c
18350 changed files with 6088489 additions and 305 deletions
@@ -0,0 +1,7 @@
+---
+BasedOnStyle: Google
+IndentWidth: 2
+TabWidth: 2
+UseTab: Never
+BreakBeforeBraces: Attach
+Standard: Cpp03
@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: syoyo
+#patreon: # Replace with a single Patreon username
+#open_collective: # Replace with a single Open Collective username
+#ko_fi: # Replace with a single Ko-fi username
+#tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+#community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+#liberapay: # Replace with a single Liberapay username
+#issuehunt: # Replace with a single IssueHunt username
+#otechie: # Replace with a single Otechie username
+#lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+#custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
@@ -0,0 +1 @@
+blank_issues_enabled: false
@@ -0,0 +1,30 @@
+---
+name: Issue report
+about: Create a report
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the issue**
+
+A clear and concise description of what the issue is.
+
+**To Reproduce**
+
+- OS
+- Compiler, compiler version, compile options
+- Please attach minimal and reproducible .glTF file if you got an issue related to .glTF data
+
+**Expected behaviour**
+
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+
+If applicable, add screenshots to help explain your problem.
+
+
+**Additional context**
+Add any other context about the problem here.
@@ -0,0 +1,92 @@
+# Copilot Review Instructions for TinyGLTF
+
+This document provides guidelines for reviewing code changes in the TinyGLTF repository.
+
+## Memory Safety
+
+- **Buffer Overflows**: Check for proper bounds checking when accessing arrays, vectors, and buffers. Verify that buffer sizes are validated before read/write operations.
+- **Null Pointer Dereferences**: Ensure all pointers are checked for null before dereferencing, especially when handling optional glTF fields.
+- **Memory Leaks**: Verify proper resource management, including RAII patterns for file handles, image data, and dynamically allocated memory.
+- **Use-After-Free**: Check for proper lifetime management of objects, especially when dealing with callbacks and asynchronous operations.
+
+## Error Handling
+
+- **File I/O**: Verify that all file operations have proper error checking and meaningful error messages.
+- **JSON Parsing**: Ensure JSON parsing errors are caught and reported with helpful context about the location and nature of the error.
+- **Resource Loading**: Check that failures in loading images, buffers, and other resources are properly handled and don't cause crashes.
+- **Error Propagation**: Verify that errors are properly propagated through the call stack with appropriate error messages.
+
+## glTF 2.0 Specification Compliance
+
+- **Required Fields**: Ensure all required glTF fields are validated and present.
+- **Data Types**: Verify that data types match the glTF specification (e.g., component types, accessor types).
+- **Constraints**: Check that glTF constraints are enforced (e.g., valid ranges for enums, buffer stride requirements).
+- **Extensions**: Verify proper handling of glTF extensions and that unknown extensions are handled gracefully.
+- **Validation**: Ensure new features align with the glTF 2.0 specification from the Khronos Group.
+
+## Cross-Platform Compatibility
+
+- **Windows**: Check for proper handling of Windows-specific issues (path separators, line endings, file operations).
+- **Linux**: Verify compatibility with various Linux distributions and compilers (GCC, Clang).
+- **macOS**: Ensure macOS-specific considerations are addressed (case-sensitive filesystems, Clang compatibility).
+- **Mobile Platforms**: Consider Android and iOS compatibility where applicable.
+- **Endianness**: Verify proper handling of byte order when reading binary data.
+- **Compiler Compatibility**: Ensure code compiles with C++11 standard and supported compilers (MSVC, GCC, Clang).
+
+## Edge Cases in glTF Parsing
+
+- **Empty/Minimal Files**: Verify handling of minimal valid glTF files.
+- **Large Files**: Check for proper handling of large glTF files and buffers without memory exhaustion.
+- **Malformed Data**: Ensure graceful handling of malformed or invalid glTF data.
+- **Missing Optional Fields**: Verify correct behavior when optional glTF fields are absent.
+- **Edge Values**: Check handling of boundary values (e.g., maximum buffer sizes, extreme floating-point values).
+- **Base64 Encoding**: Verify proper handling of base64-encoded data URIs and invalid encodings.
+
+## Backwards Compatibility
+
+- **API Changes**: Ensure public API changes maintain backwards compatibility or are properly deprecated.
+- **Breaking Changes**: Flag any breaking changes for major version updates and document migration paths.
+- **Binary Compatibility**: Consider ABI stability for header-only library changes.
+- **Default Behavior**: Verify that default behavior of existing functionality remains unchanged.
+
+## Performance Considerations
+
+- **Parsing Performance**: Check for unnecessary copies, redundant allocations, and inefficient algorithms in parsing logic.
+- **Memory Usage**: Verify efficient memory usage, especially when loading large glTF files.
+- **I/O Operations**: Ensure efficient file reading and minimize unnecessary disk access.
+- **String Operations**: Check for efficient string handling (use of string_view, move semantics).
+- **STL Usage**: Verify appropriate use of STL containers and algorithms.
+
+## Documentation
+
+- **Public API**: Ensure all public functions, classes, and methods have clear documentation comments.
+- **Parameters**: Verify that function parameters are documented, including expected ranges and constraints.
+- **Return Values**: Document return values and possible error conditions.
+- **Examples**: Check that complex features include usage examples.
+- **Changelog**: Verify that significant changes are documented in release notes or changelog.
+
+## Testing
+
+- **Test Coverage**: Ensure new features include appropriate unit tests or integration tests.
+- **Edge Cases**: Verify that tests cover edge cases and error conditions.
+- **Cross-Platform Tests**: Check that tests run on all supported platforms.
+- **Regression Tests**: Ensure bug fixes include regression tests to prevent recurrence.
+- **Sample Files**: Verify that changes are tested with various valid and invalid glTF sample files.
+
+## Code Style Consistency
+
+- **Header-Only Pattern**: Maintain the header-only library structure.
+- **Naming Conventions**: Follow existing naming conventions (CamelCase for types, snake_case for functions where applicable).
+- **Formatting**: Adhere to the existing code formatting style (check `.clang-format` if available).
+- **Include Guards**: Verify proper include guards and header organization.
+- **Namespace Usage**: Ensure proper use of the `tinygltf` namespace.
+- **Comments**: Maintain consistent comment style with existing code.
+- **C++11 Compliance**: Verify that code uses C++11 features appropriately and doesn't require newer standards unless specified.
+
+## Additional Considerations
+
+- **Third-Party Dependencies**: Minimize new dependencies; prefer existing dependencies (json.hpp, stb_image).
+- **Warnings**: Ensure code compiles without warnings on supported compilers.
+- **const Correctness**: Verify proper use of const for parameters and methods.
+- **RAII**: Prefer RAII patterns for resource management over manual cleanup.
+- **noexcept**: Use noexcept appropriately for move constructors and move assignment operators.
@@ -0,0 +1,169 @@
+name: C/C++ CI
+
+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 with MinGW gcc cross
+
+    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 mingw-w64
+            x86_64-w64-mingw32-g++ -std=c++11 -o loader_example loader_example.cc
+
+  # Windows(x64) + Visual Studio 2022 build
+  # Assume windows-latest have VS2022 installed
+  build-windows-msvc:
+
+    runs-on: windows-latest
+    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@v1
+      - name: Configure
+        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 --config Release
+
+
+  build-linux:
+
+    runs-on: ubuntu-latest
+    name: Buld with gcc
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: build
+      run: |
+        g++ -std=c++11 -o loader_example loader_example.cc
+    - name: test
+      run: |
+        ./loader_example models/Cube/Cube.gltf
+
+    - name: tests
+      run: |
+        cd tests
+        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
+
@@ -0,0 +1,330 @@
+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@v4
+
+      - name: Configure
+        run: cmake -B build -DTINYGLTF_BUILD_LOADER_EXAMPLE=ON
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run loader_example
+        run: ./build/loader_example 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@v4
+
+      - 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 -DCMAKE_CXX_COMPILER=clang++-21 -DTINYGLTF_BUILD_LOADER_EXAMPLE=ON
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run loader_example
+        run: |
+          ./build/loader_example 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@v4
+
+      - name: Configure
+        run: cmake -B build -DTINYGLTF_BUILD_LOADER_EXAMPLE=ON
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run loader_example
+        run: ./build/loader_example 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@v4
+
+      - name: Configure
+        run: cmake -B build -DTINYGLTF_BUILD_LOADER_EXAMPLE=ON
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run loader_example
+        run: ./build/loader_example models/Cube/Cube.gltf
+
+      - name: Run tests
+        run: ctest --test-dir build --output-on-failure
+
+  # Windows x64 - MSVC
+  windows-msvc-x64:
+    runs-on: windows-latest
+    name: Windows x64 (MSVC)
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Configure
+        run: |
+          mkdir build
+          cd build
+          cmake -G "Visual Studio 17 2022" -A x64 -DTINYGLTF_BUILD_LOADER_EXAMPLE=On -DTINYGLTF_BUILD_GL_EXAMPLES=Off -DTINYGLTF_BUILD_VALIDATOR_EXAMPLE=Off ..
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Run loader_example
+        run: |
+          .\build\Release\loader_example.exe models\Cube\Cube.gltf
+
+      - name: Run tests
+        run: ctest --test-dir build -C Release --output-on-failure
+
+  # Windows x86 - MSVC
+  windows-msvc-x86:
+    runs-on: windows-latest
+    name: Windows x86 (MSVC)
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Configure
+        run: |
+          mkdir build
+          cd build
+          cmake -G "Visual Studio 17 2022" -A Win32 -DTINYGLTF_BUILD_LOADER_EXAMPLE=On -DTINYGLTF_BUILD_GL_EXAMPLES=Off -DTINYGLTF_BUILD_VALIDATOR_EXAMPLE=Off ..
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Run tests
+        run: ctest --test-dir build -C Release --output-on-failure
+
+  # Windows ARM64 - MSVC (cross-compile)
+  windows-msvc-arm64:
+    runs-on: windows-latest
+    name: Windows ARM64 (MSVC) - Cross-compile
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Configure
+        run: |
+          mkdir build
+          cd build
+          cmake -G "Visual Studio 17 2022" -A ARM64 -DTINYGLTF_BUILD_LOADER_EXAMPLE=On -DTINYGLTF_BUILD_GL_EXAMPLES=Off -DTINYGLTF_BUILD_VALIDATOR_EXAMPLE=Off ..
+
+      - name: Build
+        run: cmake --build build --config Release
+
+  # 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@v4
+
+      - 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
+          cmake --build build
+
+      - name: Run loader_example
+        run: |
+          ./build/loader_example 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@v4
+
+      - name: Install MinGW
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential mingw-w64
+
+      - name: Build
+        run: |
+          x86_64-w64-mingw32-g++ -std=c++11 -o loader_example.exe loader_example.cc
+
+  # Special Configuration: No Exceptions
+  linux-noexception:
+    runs-on: ubuntu-latest
+    name: Linux x64 (GCC) - No Exceptions
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build loader_example
+        run: |
+          g++ -DTINYGLTF_NOEXCEPTION -std=c++11 -o loader_example loader_example.cc
+
+      - name: Run loader_example
+        run: |
+          ./loader_example models/Cube/Cube.gltf
+
+      - name: Build and run unit tests
+        run: |
+          cd tests
+          g++ -DTINYGLTF_NOEXCEPTION -I../ -std=c++11 -g -O0 -o tester_noexcept tester.cc
+          ./tester_noexcept
+
+  # Special Configuration: Header-Only Mode
+  linux-header-only:
+    runs-on: ubuntu-latest
+    name: Linux x64 (GCC) - Header-Only Mode
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build with CMake Header-Only
+        run: |
+          mkdir build
+          cmake -B build -DTINYGLTF_HEADER_ONLY=ON -DTINYGLTF_BUILD_LOADER_EXAMPLE=ON
+          cmake --build build
+
+      - name: Run loader_example
+        run: |
+          ./build/loader_example models/Cube/Cube.gltf
+
+      - name: Run tests
+        run: ctest --test-dir build --output-on-failure
+
+  # Special Configuration: RapidJSON Backend
+  linux-rapidjson:
+    runs-on: ubuntu-latest
+    name: Linux x64 (GCC) - RapidJSON Backend
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Clone RapidJSON
+        run: |
+          git clone https://github.com/Tencent/rapidjson
+
+      - name: Configure
+        run: |
+          cmake -B build -DTINYGLTF_USE_RAPIDJSON=ON -DTINYGLTF_BUILD_LOADER_EXAMPLE=ON -DCMAKE_PREFIX_PATH=$PWD/rapidjson
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run loader_example
+        run: |
+          ./build/loader_example models/Cube/Cube.gltf
+
+      - name: Run tests
+        run: ctest --test-dir build --output-on-failure
+
+  # Special Configuration: AddressSanitizer
+  linux-asan:
+    runs-on: ubuntu-latest
+    name: Linux x64 (Clang) - AddressSanitizer
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build loader_example with ASan
+        run: |
+          clang++ -fsanitize=address -std=c++11 -g -O1 -o loader_example loader_example.cc
+
+      - name: Run loader_example
+        run: |
+          ./loader_example models/Cube/Cube.gltf
+
+      - name: Build and run unit tests with ASan
+        run: |
+          cd tests
+          clang++ -fsanitize=address -I../ -std=c++11 -g -O1 -o tester tester.cc
+          ./tester
+
+  # Special Configuration: UndefinedBehaviorSanitizer
+  linux-ubsan:
+    runs-on: ubuntu-latest
+    name: Linux x64 (Clang) - UndefinedBehaviorSanitizer
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build loader_example with UBSan
+        run: |
+          clang++ -fsanitize=undefined -std=c++11 -g -O1 -o loader_example loader_example.cc
+
+      - name: Run loader_example
+        run: |
+          ./loader_example models/Cube/Cube.gltf
+
+      - name: Build and run unit tests with UBSan
+        run: |
+          cd tests
+          clang++ -fsanitize=undefined -I../ -std=c++11 -g -O1 -o tester tester.cc
+          ./tester
@@ -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
@@ -0,0 +1,45 @@
+name: MSYS2 MinGW-w64 Windows 64bit Build
+
+on:
+  push:
+    branches:
+      - release
+      - devel
+    paths:
+    - 'tiny_gltf.*'
+    - 'CMakeLists.txt'
+    - '.github/workflows/mingw-w64-msys2.yml'
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  mingw-w64-msys2-build:
+    name: MSYS2 MinGW-w64 Windows Build
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install core & build dependencies
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: UCRT64
+          install: base-devel
+          pacboy: >-
+            cc:p cmake:p ninja:p
+          update: true
+          release: false
+
+      - name: Configure
+        run: |
+          cmake \
+            -G"Ninja" \
+            -S . \
+            -B build
+
+      - name: Build
+        run: |
+          cmake --build build
+
@@ -0,0 +1,97 @@
+# CMake
+/build/
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+
+#Files created by the CI scripts (downloading and installing premake)
+premake5
+premake5.tar.gz
+
+#built examples
+/examples/raytrace/bin/
+
+#visual studio files
+*.sln
+*.vcxproj*
+.vs
+
+# default cmake build dir
+build/
+
+#binary directories
+bin/
+obj/
+out/
+
+#runtime gui config
+imgui.ini
+
+#visual stuido code
+.vscode
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+loader_example
+tests/tester
+tests/tester_noexcept
+tests/tester_intensive_customjson
+tests/issue-97.gltf
+tests/issue-261.gltf
+tests/issue-495-external.gltf
+# Test-generated output files (written by tester.cc during test run)
+tests/Cube.gltf
+tests/Cube.bin
+tests/Cube.glb
+tests/Cube_BaseColor.png
+tests/Cube_MetallicRoughness.png
+tests/Cube_with_embedded_images.gltf
+tests/Cube_with_image_files.gltf
+tests/tmp.glb
+tests/ issue-236.gltf
+tests/ issue-236.bin
+tests/ 2x2 image  has multiple      spaces.png
+
+# unignore
+!Makefile
+!examples/build-gltf/Makefile
+!examples/raytrace/cornellbox_suzanne.obj
+!tests/Makefile
+!tools/windows/premake5.exe
@@ -0,0 +1,126 @@
+cmake_minimum_required(VERSION 3.6)
+
+project(tinygltf)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED On)
+set(CMAKE_CXX_EXTENSIONS Off)
+set(CMAKE_EXPORT_COMPILE_COMMANDS 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_BUILD_TESTS "Build unit tests" 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)
+option(TINYGLTF_USE_CUSTOM_JSON "Use the built-in fast JSON parser (tinygltf_json.h) instead of nlohmann/json" OFF)
+
+if (TINYGLTF_BUILD_LOADER_EXAMPLE)
+  add_executable(loader_example
+    loader_example.cc
+    )
+endif (TINYGLTF_BUILD_LOADER_EXAMPLE)
+
+if (TINYGLTF_BUILD_GL_EXAMPLES)
+  add_subdirectory( examples/gltfutil )
+  add_subdirectory( examples/glview )
+endif (TINYGLTF_BUILD_GL_EXAMPLES)
+
+if (TINYGLTF_BUILD_VALIDATOR_EXAMPLE)
+  add_subdirectory( examples/validator )
+endif (TINYGLTF_BUILD_VALIDATOR_EXAMPLE)
+
+if (TINYGLTF_BUILD_BUILDER_EXAMPLE)
+  add_subdirectory ( examples/build-gltf )
+endif (TINYGLTF_BUILD_BUILDER_EXAMPLE)
+
+if (TINYGLTF_BUILD_TESTS)
+  enable_testing()
+  add_executable(tester tests/tester.cc)
+  target_include_directories(tester PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests
+  )
+  add_test(NAME tester COMMAND tester WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+
+  # Build and run tests with the custom JSON backend enabled to catch regressions
+  add_executable(tester_customjson tests/tester.cc)
+  target_include_directories(tester_customjson PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests
+  )
+  target_compile_definitions(tester_customjson PRIVATE TINYGLTF_USE_CUSTOM_JSON)
+  add_test(NAME tester_customjson COMMAND tester_customjson WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+
+  # Intensive parser tests for the custom JSON backend
+  add_executable(tester_intensive_customjson tests/tester_intensive_customjson.cc)
+  target_include_directories(tester_intensive_customjson PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests
+  )
+  target_compile_definitions(tester_intensive_customjson PRIVATE TINYGLTF_USE_CUSTOM_JSON)
+  add_test(NAME tester_intensive_customjson COMMAND tester_intensive_customjson WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+endif (TINYGLTF_BUILD_TESTS)
+
+#
+# for add_subdirectory and standalone build
+#
+if (TINYGLTF_HEADER_ONLY)
+  add_library(tinygltf INTERFACE)
+
+  target_include_directories(tinygltf
+          INTERFACE
+          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  )
+
+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_USE_CUSTOM_JSON)
+  if (TINYGLTF_HEADER_ONLY)
+    target_compile_definitions(tinygltf INTERFACE TINYGLTF_USE_CUSTOM_JSON)
+  else ()
+    target_compile_definitions(tinygltf PUBLIC TINYGLTF_USE_CUSTOM_JSON)
+  endif ()
+endif ()
+
+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_json.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)
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Syoyo Fujita, Aurélien Chatelain and many contributors
+
+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, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.
@@ -0,0 +1,13 @@
+
+# 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
@@ -0,0 +1,312 @@
+# Header only C++ tiny glTF library(loader/saver).
+
+`TinyGLTF` is a header only C++ glTF 2.0 https://github.com/KhronosGroup/glTF library.
+
+## TinyGLTF v3 (new major release)
+
+**`tiny_gltf_v3.h`** is the new major version of TinyGLTF and the recommended API for new projects.
+
+### What's new in v3
+
+v3 is a ground-up rewrite with a C-centric, low-overhead design:
+
+- **Pure C POD structs** — no STL containers in the public API; 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** — backed by `tinygltf_json.h`, a high-performance, locale-independent JSON parser with optional SIMD acceleration (SSE2 / AVX2 / NEON) and a float32 fast-path.
+- **Streaming callbacks** — opt-in streaming parse/write via user-supplied callbacks.
+- **No RTTI, no exceptions required** — suitable for embedded and game-engine use.
+- **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.
+
+### Quick start (v3)
+
+Copy `tiny_gltf_v3.h` and `tinygltf_json.h` to your project. In **one** `.cpp` file:
+
+```cpp
+#define TINYGLTF3_IMPLEMENTATION
+#define TINYGLTF3_ENABLE_FS          // enable file I/O
+#define TINYGLTF3_ENABLE_STB_IMAGE   // enable image decoding
+#include "tiny_gltf_v3.h"
+```
+
+Loading a glTF file:
+
+```c
+tg3_load_options_t opts = tg3_load_options_default();
+tg3_error_stack_t errors = {0};
+tg3_model_t *model = tg3_load_from_file("scene.gltf", &opts, &errors);
+if (!model) {
+    for (int i = 0; i < errors.count; i++)
+        fprintf(stderr, "[%s] %s\n", tg3_severity_str(errors.items[i].severity),
+                errors.items[i].message);
+}
+// ... use model ...
+tg3_model_free(model);
+```
+
+## Status
+
+> ⚠️ **v2 deprecation notice:** `tiny_gltf.h` (v2) remains fully functional and is still supported,
+> but it is now in **maintenance mode only** — no new features will be added.
+> v2 will be **sunset after mid-2026**. New projects should use `tiny_gltf_v3.h`.
+
+Currently TinyGLTF v2 is stable and in 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
+
+![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.
+
+TinyGLTF uses the following third party libraries.
+
+* 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;
+std::string filename = "input.gltf";
+
+bool ret = loader.LoadASCIIFromFile(&model, &err, &warn, filename);
+//bool ret = loader.LoadBinaryFromFile(&model, &err, &warn, filename); // 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: %s\n", filename.c_str());
+}
+```
+
+#### 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.
+
+
+## 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
@@ -0,0 +1,70 @@
+# 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 ../tinygltf_json.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
@@ -0,0 +1,396 @@
+/*
+ * 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) {
+    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;
+
+        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");
+}
+
+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;
+    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], "--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" : "");
+        }
+
+        BenchResult r = bench_file(file.c_str(), iterations, warmup, quiet, float32_mode);
+
+        if (csv) {
+            print_csv_row(r);
+        } else {
+            print_result(r);
+            printf("\n");
+        }
+    }
+
+    return 0;
+}
@@ -0,0 +1,740 @@
+/*
+ * 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;
+}
@@ -0,0 +1,3 @@
+@PACKAGE_INIT@
+
+include(${CMAKE_CURRENT_LIST_DIR}/TinyGLTFTargets.cmake)
@@ -0,0 +1,3 @@
+  cd examples\raytrace
+  ..\..\tools\windows\premake5.exe vs2015
+  msbuild NanoSGSolution.sln /property:Configuration=Release
@@ -0,0 +1,15 @@
+# Python script which generates C++11 code from JSON schema.
+
+## Requirements
+
+* python3
+* jsonref
+
+## Generate
+
+Run `gen.py` by specifing the path to glTF schema directory(from https://github.com/KhronosGroup/glTF.git)
+
+```
+$ python gen.py /path/to/glTF/specification/2.0/schema
+```
+
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys, os
+import subprocess
+import json
+from pprint import pprint
+import jsonref
+
+# glTF 2.0
+schema_files = [
+    "glTF.schema.json"
+]
+
+def main():
+    if len(sys.argv) < 2:
+        print("Requires path to glTF scheme directory.")
+        sys.exit(-1)
+    
+    gltf_schema_dir = sys.argv[1]
+
+    gltf_schema_filepath = os.path.join(gltf_schema_dir, schema_files[0])
+    if not os.path.exists(gltf_schema_filepath):
+        print("File not found: {}".format(gltf_schema_filepath))
+        sys.exit(-1)
+
+    gltf_schema_uri = 'file://{}/'.format(gltf_schema_dir)
+    with open(gltf_schema_filepath) as schema_file:
+        j = jsonref.loads(schema_file.read(), base_uri=gltf_schema_uri, jsonschema=True)
+        pprint(j)
+
+    
+
+main()
@@ -0,0 +1,906 @@
+//
+// TODO(syoyo): Print extensions and extras for each glTF object.
+//
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "tiny_gltf.h"
+
+#include <cstdio>
+#include <fstream>
+#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 "";
+}
+
+static std::string PrintMode(int mode) {
+  if (mode == TINYGLTF_MODE_POINTS) {
+    return "POINTS";
+  } else if (mode == TINYGLTF_MODE_LINE) {
+    return "LINE";
+  } else if (mode == TINYGLTF_MODE_LINE_LOOP) {
+    return "LINE_LOOP";
+  } else if (mode == TINYGLTF_MODE_TRIANGLES) {
+    return "TRIANGLES";
+  } else if (mode == TINYGLTF_MODE_TRIANGLE_FAN) {
+    return "TRIANGLE_FAN";
+  } else if (mode == TINYGLTF_MODE_TRIANGLE_STRIP) {
+    return "TRIANGLE_STRIP";
+  }
+  return "**UNKNOWN**";
+}
+
+static std::string PrintTarget(int target) {
+  if (target == 34962) {
+    return "GL_ARRAY_BUFFER";
+  } else if (target == 34963) {
+    return "GL_ELEMENT_ARRAY_BUFFER";
+  } else {
+    return "**UNKNOWN**";
+  }
+}
+
+static std::string PrintType(int ty) {
+  if (ty == TINYGLTF_TYPE_SCALAR) {
+    return "SCALAR";
+  } else if (ty == TINYGLTF_TYPE_VECTOR) {
+    return "VECTOR";
+  } else if (ty == TINYGLTF_TYPE_VEC2) {
+    return "VEC2";
+  } else if (ty == TINYGLTF_TYPE_VEC3) {
+    return "VEC3";
+  } else if (ty == TINYGLTF_TYPE_VEC4) {
+    return "VEC4";
+  } else if (ty == TINYGLTF_TYPE_MATRIX) {
+    return "MATRIX";
+  } else if (ty == TINYGLTF_TYPE_MAT2) {
+    return "MAT2";
+  } else if (ty == TINYGLTF_TYPE_MAT3) {
+    return "MAT3";
+  } else if (ty == TINYGLTF_TYPE_MAT4) {
+    return "MAT4";
+  }
+  return "**UNKNOWN**";
+}
+
+static std::string PrintComponentType(int ty) {
+  if (ty == TINYGLTF_COMPONENT_TYPE_BYTE) {
+    return "BYTE";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) {
+    return "UNSIGNED_BYTE";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_SHORT) {
+    return "SHORT";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
+    return "UNSIGNED_SHORT";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_INT) {
+    return "INT";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) {
+    return "UNSIGNED_INT";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_FLOAT) {
+    return "FLOAT";
+  } else if (ty == TINYGLTF_COMPONENT_TYPE_DOUBLE) {
+    return "DOUBLE";
+  }
+
+  return "**UNKNOWN**";
+}
+
+#if 0
+static std::string PrintParameterType(int ty) {
+  if (ty == TINYGLTF_PARAMETER_TYPE_BYTE) {
+    return "BYTE";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE) {
+    return "UNSIGNED_BYTE";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_SHORT) {
+    return "SHORT";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT) {
+    return "UNSIGNED_SHORT";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_INT) {
+    return "INT";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT) {
+    return "UNSIGNED_INT";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT) {
+    return "FLOAT";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_VEC2) {
+    return "FLOAT_VEC2";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_VEC3) {
+    return "FLOAT_VEC3";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_VEC4) {
+    return "FLOAT_VEC4";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_INT_VEC2) {
+    return "INT_VEC2";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_INT_VEC3) {
+    return "INT_VEC3";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_INT_VEC4) {
+    return "INT_VEC4";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL) {
+    return "BOOL";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL_VEC2) {
+    return "BOOL_VEC2";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL_VEC3) {
+    return "BOOL_VEC3";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL_VEC4) {
+    return "BOOL_VEC4";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_MAT2) {
+    return "FLOAT_MAT2";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_MAT3) {
+    return "FLOAT_MAT3";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_MAT4) {
+    return "FLOAT_MAT4";
+  } else if (ty == TINYGLTF_PARAMETER_TYPE_SAMPLER_2D) {
+    return "SAMPLER_2D";
+  }
+
+  return "**UNKNOWN**";
+}
+#endif
+
+static std::string PrintWrapMode(int mode) {
+  if (mode == TINYGLTF_TEXTURE_WRAP_REPEAT) {
+    return "REPEAT";
+  } else if (mode == TINYGLTF_TEXTURE_WRAP_CLAMP_TO_EDGE) {
+    return "CLAMP_TO_EDGE";
+  } else if (mode == TINYGLTF_TEXTURE_WRAP_MIRRORED_REPEAT) {
+    return "MIRRORED_REPEAT";
+  }
+
+  return "**UNKNOWN**";
+}
+
+static std::string PrintFilterMode(int mode) {
+  if (mode == TINYGLTF_TEXTURE_FILTER_NEAREST) {
+    return "NEAREST";
+  } else if (mode == TINYGLTF_TEXTURE_FILTER_LINEAR) {
+    return "LINEAR";
+  } else if (mode == TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST) {
+    return "NEAREST_MIPMAP_NEAREST";
+  } else if (mode == TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR) {
+    return "NEAREST_MIPMAP_LINEAR";
+  } else if (mode == TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST) {
+    return "LINEAR_MIPMAP_NEAREST";
+  } else if (mode == TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR) {
+    return "LINEAR_MIPMAP_LINEAR";
+  }
+  return "**UNKNOWN**";
+}
+
+static std::string PrintIntArray(const std::vector<int> &arr) {
+  if (arr.size() == 0) {
+    return "";
+  }
+
+  std::stringstream ss;
+  ss << "[ ";
+  for (size_t i = 0; i < arr.size(); i++) {
+    ss << arr[i];
+    if (i != arr.size() - 1) {
+      ss << ", ";
+    }
+  }
+  ss << " ]";
+
+  return ss.str();
+}
+
+static std::string PrintFloatArray(const std::vector<double> &arr) {
+  if (arr.size() == 0) {
+    return "";
+  }
+
+  std::stringstream ss;
+  ss << "[ ";
+  for (size_t i = 0; i < arr.size(); i++) {
+    ss << arr[i];
+    if (i != arr.size() - 1) {
+      ss << ", ";
+    }
+  }
+  ss << " ]";
+
+  return ss.str();
+}
+
+static std::string Indent(const int indent) {
+  std::string s;
+  for (int i = 0; i < indent; i++) {
+    s += "  ";
+  }
+
+  return s;
+}
+
+static std::string PrintParameterValue(const tinygltf::Parameter &param) {
+  if (!param.number_array.empty()) {
+    return PrintFloatArray(param.number_array);
+  } else {
+    return param.string_value;
+  }
+}
+
+#if 0
+static std::string PrintParameterMap(const tinygltf::ParameterMap &pmap) {
+  std::stringstream ss;
+
+  ss << pmap.size() << std::endl;
+  for (auto &kv : pmap) {
+    ss << kv.first << " : " << PrintParameterValue(kv.second) << std::endl;
+  }
+
+  return ss.str();
+}
+#endif
+
+static std::string PrintValue(const std::string &name,
+                              const tinygltf::Value &value, const int indent,
+                              const bool tag = true) {
+  std::stringstream ss;
+
+  if (value.IsObject()) {
+    const tinygltf::Value::Object &o = value.Get<tinygltf::Value::Object>();
+    tinygltf::Value::Object::const_iterator it(o.begin());
+    tinygltf::Value::Object::const_iterator itEnd(o.end());
+    for (; it != itEnd; it++) {
+      ss << PrintValue(it->first, it->second, indent + 1) << std::endl;
+    }
+  } else if (value.IsString()) {
+    if (tag) {
+      ss << Indent(indent) << name << " : " << value.Get<std::string>();
+    } else {
+      ss << Indent(indent) << value.Get<std::string>() << " ";
+    }
+  } else if (value.IsBool()) {
+    if (tag) {
+      ss << Indent(indent) << name << " : " << value.Get<bool>();
+    } else {
+      ss << Indent(indent) << value.Get<bool>() << " ";
+    }
+  } else if (value.IsNumber()) {
+    if (tag) {
+      ss << Indent(indent) << name << " : " << value.Get<double>();
+    } else {
+      ss << Indent(indent) << value.Get<double>() << " ";
+    }
+  } else if (value.IsInt()) {
+    if (tag) {
+      ss << Indent(indent) << name << " : " << value.Get<int>();
+    } else {
+      ss << Indent(indent) << value.Get<int>() << " ";
+    }
+  } else if (value.IsArray()) {
+    // TODO(syoyo): Better pretty printing of array item
+    ss << Indent(indent) << name << " [ \n";
+    for (size_t i = 0; i < value.Size(); i++) {
+      ss << PrintValue("", value.Get(int(i)), indent + 1, /* tag */ false);
+      if (i != (value.ArrayLen() - 1)) {
+        ss << ", \n";
+      }
+    }
+    ss << "\n" << Indent(indent) << "] ";
+  }
+
+  // @todo { binary }
+
+  return ss.str();
+}
+
+static void DumpNode(const tinygltf::Node &node, int indent) {
+  std::cout << Indent(indent) << "name        : " << node.name << std::endl;
+  std::cout << Indent(indent) << "camera      : " << node.camera << std::endl;
+  std::cout << Indent(indent) << "mesh        : " << node.mesh << std::endl;
+  if (!node.rotation.empty()) {
+    std::cout << Indent(indent)
+              << "rotation    : " << PrintFloatArray(node.rotation)
+              << std::endl;
+  }
+  if (!node.scale.empty()) {
+    std::cout << Indent(indent)
+              << "scale       : " << PrintFloatArray(node.scale) << std::endl;
+  }
+  if (!node.translation.empty()) {
+    std::cout << Indent(indent)
+              << "translation : " << PrintFloatArray(node.translation)
+              << std::endl;
+  }
+
+  if (!node.matrix.empty()) {
+    std::cout << Indent(indent)
+              << "matrix      : " << PrintFloatArray(node.matrix) << std::endl;
+  }
+
+  std::cout << Indent(indent)
+            << "children    : " << PrintIntArray(node.children) << std::endl;
+}
+
+static void DumpStringIntMap(const std::map<std::string, int> &m, int indent) {
+  std::map<std::string, int>::const_iterator it(m.begin());
+  std::map<std::string, int>::const_iterator itEnd(m.end());
+  for (; it != itEnd; it++) {
+    std::cout << Indent(indent) << it->first << ": " << it->second << std::endl;
+  }
+}
+
+static void DumpExtensions(const tinygltf::ExtensionMap &extension,
+                           const int indent) {
+  // TODO(syoyo): pritty print Value
+  for (auto &e : extension) {
+    std::cout << Indent(indent) << e.first << std::endl;
+    std::cout << PrintValue("extensions", e.second, indent + 1) << std::endl;
+  }
+}
+
+static void DumpPrimitive(const tinygltf::Primitive &primitive, int indent) {
+  std::cout << Indent(indent) << "material : " << primitive.material
+            << std::endl;
+  std::cout << Indent(indent) << "indices : " << primitive.indices << std::endl;
+  std::cout << Indent(indent) << "mode     : " << PrintMode(primitive.mode)
+            << "(" << primitive.mode << ")" << std::endl;
+  std::cout << Indent(indent)
+            << "attributes(items=" << primitive.attributes.size() << ")"
+            << std::endl;
+  DumpStringIntMap(primitive.attributes, indent + 1);
+
+  DumpExtensions(primitive.extensions, indent);
+  std::cout << Indent(indent) << "extras :" << std::endl
+            << PrintValue("extras", primitive.extras, indent + 1) << std::endl;
+
+  if (!primitive.extensions_json_string.empty()) {
+    std::cout << Indent(indent + 1) << "extensions(JSON string) = "
+              << primitive.extensions_json_string << "\n";
+  }
+
+  if (!primitive.extras_json_string.empty()) {
+    std::cout << Indent(indent + 1)
+              << "extras(JSON string) = " << primitive.extras_json_string
+              << "\n";
+  }
+}
+
+
+static void DumpTextureInfo(const tinygltf::TextureInfo &texinfo,
+                            const int indent) {
+  std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
+  std::cout << Indent(indent) << "texCoord  : TEXCOORD_" << texinfo.texCoord
+            << "\n";
+  DumpExtensions(texinfo.extensions, indent + 1);
+  std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
+
+  if (!texinfo.extensions_json_string.empty()) {
+    std::cout << Indent(indent)
+              << "extensions(JSON string) = " << texinfo.extensions_json_string
+              << "\n";
+  }
+
+  if (!texinfo.extras_json_string.empty()) {
+    std::cout << Indent(indent)
+              << "extras(JSON string) = " << texinfo.extras_json_string << "\n";
+  }
+}
+
+static void DumpNormalTextureInfo(const tinygltf::NormalTextureInfo &texinfo,
+                                  const int indent) {
+  std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
+  std::cout << Indent(indent) << "texCoord  : TEXCOORD_" << texinfo.texCoord
+            << "\n";
+  std::cout << Indent(indent) << "scale     : " << texinfo.scale << "\n";
+  DumpExtensions(texinfo.extensions, indent + 1);
+  std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
+}
+
+static void DumpOcclusionTextureInfo(
+    const tinygltf::OcclusionTextureInfo &texinfo, const int indent) {
+  std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
+  std::cout << Indent(indent) << "texCoord  : TEXCOORD_" << texinfo.texCoord
+            << "\n";
+  std::cout << Indent(indent) << "strength  : " << texinfo.strength << "\n";
+  DumpExtensions(texinfo.extensions, indent + 1);
+  std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
+}
+
+static void DumpPbrMetallicRoughness(const tinygltf::PbrMetallicRoughness &pbr,
+                                     const int indent) {
+  std::cout << Indent(indent)
+            << "baseColorFactor   : " << PrintFloatArray(pbr.baseColorFactor)
+            << "\n";
+  std::cout << Indent(indent) << "baseColorTexture  :\n";
+  DumpTextureInfo(pbr.baseColorTexture, indent + 1);
+
+  std::cout << Indent(indent) << "metallicFactor    : " << pbr.metallicFactor
+            << "\n";
+  std::cout << Indent(indent) << "roughnessFactor   : " << pbr.roughnessFactor
+            << "\n";
+
+  std::cout << Indent(indent) << "metallicRoughnessTexture  :\n";
+  DumpTextureInfo(pbr.metallicRoughnessTexture, indent + 1);
+  DumpExtensions(pbr.extensions, indent + 1);
+  std::cout << PrintValue("extras", pbr.extras, indent + 1) << "\n";
+}
+
+static void Dump(const tinygltf::Model &model) {
+  std::cout << "=== Dump glTF ===" << std::endl;
+  std::cout << "asset.copyright          : " << model.asset.copyright
+            << std::endl;
+  std::cout << "asset.generator          : " << model.asset.generator
+            << std::endl;
+  std::cout << "asset.version            : " << model.asset.version
+            << std::endl;
+  std::cout << "asset.minVersion         : " << model.asset.minVersion
+            << std::endl;
+  std::cout << std::endl;
+
+  std::cout << "=== Dump scene ===" << std::endl;
+  std::cout << "defaultScene: " << model.defaultScene << std::endl;
+
+  {
+    std::cout << "scenes(items=" << model.scenes.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.scenes.size(); i++) {
+      std::cout << Indent(1) << "scene[" << i
+                << "] name  : " << model.scenes[i].name << std::endl;
+      DumpExtensions(model.scenes[i].extensions, 1);
+    }
+  }
+
+  {
+    std::cout << "meshes(item=" << model.meshes.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.meshes.size(); i++) {
+      std::cout << Indent(1) << "name     : " << model.meshes[i].name
+                << std::endl;
+      std::cout << Indent(1)
+                << "primitives(items=" << model.meshes[i].primitives.size()
+                << "): " << std::endl;
+
+      for (size_t k = 0; k < model.meshes[i].primitives.size(); k++) {
+        DumpPrimitive(model.meshes[i].primitives[k], 2);
+      }
+    }
+  }
+
+  {
+    for (size_t i = 0; i < model.accessors.size(); i++) {
+      const tinygltf::Accessor &accessor = model.accessors[i];
+      std::cout << Indent(1) << "name         : " << accessor.name << std::endl;
+      std::cout << Indent(2) << "bufferView   : " << accessor.bufferView
+                << std::endl;
+      std::cout << Indent(2) << "byteOffset   : " << accessor.byteOffset
+                << std::endl;
+      std::cout << Indent(2) << "componentType: "
+                << PrintComponentType(accessor.componentType) << "("
+                << accessor.componentType << ")" << std::endl;
+      std::cout << Indent(2) << "count        : " << accessor.count
+                << std::endl;
+      std::cout << Indent(2) << "type         : " << PrintType(accessor.type)
+                << std::endl;
+      if (!accessor.minValues.empty()) {
+        std::cout << Indent(2) << "min          : [";
+        for (size_t k = 0; k < accessor.minValues.size(); k++) {
+          std::cout << accessor.minValues[k]
+                    << ((k != accessor.minValues.size() - 1) ? ", " : "");
+        }
+        std::cout << "]" << std::endl;
+      }
+      if (!accessor.maxValues.empty()) {
+        std::cout << Indent(2) << "max          : [";
+        for (size_t k = 0; k < accessor.maxValues.size(); k++) {
+          std::cout << accessor.maxValues[k]
+                    << ((k != accessor.maxValues.size() - 1) ? ", " : "");
+        }
+        std::cout << "]" << std::endl;
+      }
+
+      if (accessor.sparse.isSparse) {
+        std::cout << Indent(2) << "sparse:" << std::endl;
+        std::cout << Indent(3) << "count  : " << accessor.sparse.count
+                  << std::endl;
+        std::cout << Indent(3) << "indices: " << std::endl;
+        std::cout << Indent(4)
+                  << "bufferView   : " << accessor.sparse.indices.bufferView
+                  << std::endl;
+        std::cout << Indent(4)
+                  << "byteOffset   : " << accessor.sparse.indices.byteOffset
+                  << std::endl;
+        std::cout << Indent(4) << "componentType: "
+                  << PrintComponentType(accessor.sparse.indices.componentType)
+                  << "(" << accessor.sparse.indices.componentType << ")"
+                  << std::endl;
+        std::cout << Indent(3) << "values : " << std::endl;
+        std::cout << Indent(4)
+                  << "bufferView   : " << accessor.sparse.values.bufferView
+                  << std::endl;
+        std::cout << Indent(4)
+                  << "byteOffset   : " << accessor.sparse.values.byteOffset
+                  << std::endl;
+      }
+    }
+  }
+
+  {
+    std::cout << "animations(items=" << model.animations.size() << ")"
+              << std::endl;
+    for (size_t i = 0; i < model.animations.size(); i++) {
+      const tinygltf::Animation &animation = model.animations[i];
+      std::cout << Indent(1) << "name         : " << animation.name
+                << std::endl;
+
+      std::cout << Indent(1) << "channels : [ " << std::endl;
+      for (size_t j = 0; j < animation.channels.size(); j++) {
+        std::cout << Indent(2)
+                  << "sampler     : " << animation.channels[j].sampler
+                  << std::endl;
+        std::cout << Indent(2)
+                  << "target.id   : " << animation.channels[j].target_node
+                  << std::endl;
+        std::cout << Indent(2)
+                  << "target.path : " << animation.channels[j].target_path
+                  << std::endl;
+        std::cout << ((i != (animation.channels.size() - 1)) ? "  , " : "");
+      }
+      std::cout << "  ]" << std::endl;
+
+      std::cout << Indent(1) << "samplers(items=" << animation.samplers.size()
+                << ")" << std::endl;
+      for (size_t j = 0; j < animation.samplers.size(); j++) {
+        const tinygltf::AnimationSampler &sampler = animation.samplers[j];
+        std::cout << Indent(2) << "input         : " << sampler.input
+                  << std::endl;
+        std::cout << Indent(2) << "interpolation : " << sampler.interpolation
+                  << std::endl;
+        std::cout << Indent(2) << "output        : " << sampler.output
+                  << std::endl;
+      }
+    }
+  }
+
+  {
+    std::cout << "bufferViews(items=" << model.bufferViews.size() << ")"
+              << std::endl;
+    for (size_t i = 0; i < model.bufferViews.size(); i++) {
+      const tinygltf::BufferView &bufferView = model.bufferViews[i];
+      std::cout << Indent(1) << "name         : " << bufferView.name
+                << std::endl;
+      std::cout << Indent(2) << "buffer       : " << bufferView.buffer
+                << std::endl;
+      std::cout << Indent(2) << "byteLength   : " << bufferView.byteLength
+                << std::endl;
+      std::cout << Indent(2) << "byteOffset   : " << bufferView.byteOffset
+                << std::endl;
+      std::cout << Indent(2) << "byteStride   : " << bufferView.byteStride
+                << std::endl;
+      std::cout << Indent(2)
+                << "target       : " << PrintTarget(bufferView.target)
+                << std::endl;
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(bufferView.extensions, 1);
+      std::cout << PrintValue("extras", bufferView.extras, 2) << std::endl;
+
+      if (!bufferView.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << bufferView.extensions_json_string << "\n";
+      }
+
+      if (!bufferView.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << bufferView.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "buffers(items=" << model.buffers.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.buffers.size(); i++) {
+      const tinygltf::Buffer &buffer = model.buffers[i];
+      std::cout << Indent(1) << "name         : " << buffer.name << std::endl;
+      std::cout << Indent(2) << "byteLength   : " << buffer.data.size()
+                << std::endl;
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(buffer.extensions, 1);
+      std::cout << PrintValue("extras", buffer.extras, 2) << std::endl;
+
+      if (!buffer.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << buffer.extensions_json_string << "\n";
+      }
+
+      if (!buffer.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << buffer.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "materials(items=" << model.materials.size() << ")"
+              << std::endl;
+    for (size_t i = 0; i < model.materials.size(); i++) {
+      const tinygltf::Material &material = model.materials[i];
+      std::cout << Indent(1) << "name                 : " << material.name
+                << std::endl;
+
+      std::cout << Indent(1) << "alphaMode            : " << material.alphaMode
+                << std::endl;
+      std::cout << Indent(1)
+                << "alphaCutoff          : " << material.alphaCutoff
+                << std::endl;
+      std::cout << Indent(1) << "doubleSided          : "
+                << (material.doubleSided ? "true" : "false") << std::endl;
+      std::cout << Indent(1) << "emissiveFactor       : "
+                << PrintFloatArray(material.emissiveFactor) << std::endl;
+
+      std::cout << Indent(1) << "pbrMetallicRoughness :\n";
+      DumpPbrMetallicRoughness(material.pbrMetallicRoughness, 2);
+
+      std::cout << Indent(1) << "normalTexture        :\n";
+      DumpNormalTextureInfo(material.normalTexture, 2);
+
+      std::cout << Indent(1) << "occlusionTexture     :\n";
+      DumpOcclusionTextureInfo(material.occlusionTexture, 2);
+
+      std::cout << Indent(1) << "emissiveTexture      :\n";
+      DumpTextureInfo(material.emissiveTexture, 2);
+
+      std::cout << Indent(1) << "----  legacy material parameter  ----\n";
+      std::cout << Indent(1) << "values(items=" << material.values.size() << ")"
+                << std::endl;
+      tinygltf::ParameterMap::const_iterator p(material.values.begin());
+      tinygltf::ParameterMap::const_iterator pEnd(material.values.end());
+      for (; p != pEnd; p++) {
+        std::cout << Indent(2) << p->first << ": "
+                  << PrintParameterValue(p->second) << std::endl;
+      }
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(material.extensions, 1);
+      std::cout << PrintValue("extras", material.extras, 2) << std::endl;
+
+      if (!material.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << material.extensions_json_string << "\n";
+      }
+
+      if (!material.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << material.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "nodes(items=" << model.nodes.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.nodes.size(); i++) {
+      const tinygltf::Node &node = model.nodes[i];
+      std::cout << Indent(1) << "name         : " << node.name << std::endl;
+
+      DumpNode(node, 2);
+    }
+  }
+
+  {
+    std::cout << "images(items=" << model.images.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.images.size(); i++) {
+      const tinygltf::Image &image = model.images[i];
+      std::cout << Indent(1) << "name         : " << image.name << std::endl;
+
+      std::cout << Indent(2) << "width     : " << image.width << std::endl;
+      std::cout << Indent(2) << "height    : " << image.height << std::endl;
+      std::cout << Indent(2) << "component : " << image.component << std::endl;
+      DumpExtensions(image.extensions, 1);
+      std::cout << PrintValue("extras", image.extras, 2) << std::endl;
+
+      if (!image.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << image.extensions_json_string << "\n";
+      }
+
+      if (!image.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << image.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "textures(items=" << model.textures.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.textures.size(); i++) {
+      const tinygltf::Texture &texture = model.textures[i];
+      std::cout << Indent(1) << "sampler        : " << texture.sampler
+                << std::endl;
+      std::cout << Indent(1) << "source         : " << texture.source
+                << std::endl;
+      DumpExtensions(texture.extensions, 1);
+      std::cout << PrintValue("extras", texture.extras, 2) << std::endl;
+
+      if (!texture.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << texture.extensions_json_string << "\n";
+      }
+
+      if (!texture.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << texture.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "samplers(items=" << model.samplers.size() << ")" << std::endl;
+
+    for (size_t i = 0; i < model.samplers.size(); i++) {
+      const tinygltf::Sampler &sampler = model.samplers[i];
+      std::cout << Indent(1) << "name (id)    : " << sampler.name << std::endl;
+      std::cout << Indent(2)
+                << "minFilter    : " << PrintFilterMode(sampler.minFilter)
+                << std::endl;
+      std::cout << Indent(2)
+                << "magFilter    : " << PrintFilterMode(sampler.magFilter)
+                << std::endl;
+      std::cout << Indent(2)
+                << "wrapS        : " << PrintWrapMode(sampler.wrapS)
+                << std::endl;
+      std::cout << Indent(2)
+                << "wrapT        : " << PrintWrapMode(sampler.wrapT)
+                << std::endl;
+
+      DumpExtensions(sampler.extensions, 1);
+      std::cout << PrintValue("extras", sampler.extras, 2) << std::endl;
+
+      if (!sampler.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << sampler.extensions_json_string << "\n";
+      }
+
+      if (!sampler.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << sampler.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "cameras(items=" << model.cameras.size() << ")" << std::endl;
+
+    for (size_t i = 0; i < model.cameras.size(); i++) {
+      const tinygltf::Camera &camera = model.cameras[i];
+      std::cout << Indent(1) << "name (id)    : " << camera.name << std::endl;
+      std::cout << Indent(1) << "type         : " << camera.type << std::endl;
+
+      if (camera.type.compare("perspective") == 0) {
+        std::cout << Indent(2)
+                  << "aspectRatio   : " << camera.perspective.aspectRatio
+                  << std::endl;
+        std::cout << Indent(2) << "yfov          : " << camera.perspective.yfov
+                  << std::endl;
+        std::cout << Indent(2) << "zfar          : " << camera.perspective.zfar
+                  << std::endl;
+        std::cout << Indent(2) << "znear         : " << camera.perspective.znear
+                  << std::endl;
+      } else if (camera.type.compare("orthographic") == 0) {
+        std::cout << Indent(2) << "xmag          : " << camera.orthographic.xmag
+                  << std::endl;
+        std::cout << Indent(2) << "ymag          : " << camera.orthographic.ymag
+                  << std::endl;
+        std::cout << Indent(2) << "zfar          : " << camera.orthographic.zfar
+                  << std::endl;
+        std::cout << Indent(2)
+                  << "znear         : " << camera.orthographic.znear
+                  << std::endl;
+      }
+
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(camera.extensions, 1);
+      std::cout << PrintValue("extras", camera.extras, 2) << std::endl;
+
+      if (!camera.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << camera.extensions_json_string << "\n";
+      }
+
+      if (!camera.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << camera.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "skins(items=" << model.skins.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.skins.size(); i++) {
+      const tinygltf::Skin &skin = model.skins[i];
+      std::cout << Indent(1) << "name         : " << skin.name << std::endl;
+      std::cout << Indent(2)
+                << "inverseBindMatrices   : " << skin.inverseBindMatrices
+                << std::endl;
+      std::cout << Indent(2) << "skeleton              : " << skin.skeleton
+                << std::endl;
+      std::cout << Indent(2)
+                << "joints                : " << PrintIntArray(skin.joints)
+                << std::endl;
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(skin.extensions, 1);
+      std::cout << PrintValue("extras", skin.extras, 2) << std::endl;
+
+      if (!skin.extensions_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extensions(JSON string) = " << skin.extensions_json_string
+                  << "\n";
+      }
+
+      if (!skin.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << skin.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  // toplevel extensions
+  {
+    std::cout << "extensions(items=" << model.extensions.size() << ")"
+              << std::endl;
+    DumpExtensions(model.extensions, 1);
+  }
+}
+
+int main(int argc, char **argv) {
+  if (argc < 2) {
+    printf("Needs input.gltf\n");
+    exit(1);
+  }
+
+  // Store original JSON string for `extras` and `extensions`
+  bool store_original_json_for_extras_and_extensions = false;
+  if (argc > 2) {
+    store_original_json_for_extras_and_extensions = true;
+  }
+
+  tinygltf::Model model;
+  tinygltf::TinyGLTF gltf_ctx;
+  std::string err;
+  std::string warn;
+  std::string input_filename(argv[1]);
+  std::string ext = GetFilePathExtension(input_filename);
+
+  gltf_ctx.SetStoreOriginalJSONForExtrasAndExtensions(
+      store_original_json_for_extras_and_extensions);
+
+  bool ret = false;
+  if (ext.compare("glb") == 0) {
+    std::cout << "Reading binary glTF" << std::endl;
+    // assume binary glTF.
+    ret = gltf_ctx.LoadBinaryFromFile(&model, &err, &warn,
+                                      input_filename.c_str());
+  } else {
+    std::cout << "Reading ASCII glTF" << std::endl;
+    // assume ascii glTF.
+    ret =
+        gltf_ctx.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 parse glTF\n");
+    return -1;
+  }
+
+  Dump(model);
+
+  return 0;
+}
@@ -0,0 +1,67 @@
+{
+  "scenes": [
+    {
+      "nodes": [0]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "POSITION": 1
+          },
+          "indices": 0
+        }
+      ]
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "simpleTriangle.bin",
+      "byteLength": 44
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 1e300,
+      "target": 34963
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 8,
+      "byteLength": 36,
+      "target": 34962
+    }
+  ],
+  "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, 1, 0],
+      "min": [0, 0, 0]
+    }
+  ],
+  "asset": {
+    "version": "2.0"
+  }
+}
@@ -0,0 +1,53 @@
+{
+  "scenes": [],
+  "nodes": [],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {},
+          "indices": 0
+        }
+      ]
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "simpleTriangle.bin",
+      "byteLength": 44
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 6,
+      "target": 34963
+    },
+    {
+      "buffer": 1,
+      "byteOffset": 0,
+      "byteLength": 6,
+      "target": 34963
+    }
+  ],
+  "images": [
+    {
+      "bufferView": 1,
+      "mimeType": "image/png"
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 0,
+      "componentType": 5123,
+      "count": 3,
+      "type": "SCALAR",
+      "max": [2],
+      "min": [0]
+    }
+  ],
+  "asset": {
+    "version": "2.0"
+  }
+}
@@ -0,0 +1,36 @@
+{
+  "scenes": [],
+  "nodes": [],
+  "buffers": [],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {},
+          "indices": 0
+        }
+      ]
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 6,
+      "target": 34963
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 1,
+      "componentType": 5123,
+      "count": 3,
+      "type": "SCALAR",
+      "max": [2],
+      "min": [0]
+    }
+  ],
+  "asset": {
+    "version": "2.0"
+  }
+}
@@ -0,0 +1,36 @@
+{
+  "scenes": [],
+  "nodes": [],
+  "buffers": [],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {},
+          "indices": 1
+        }
+      ]
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 6,
+      "target": 34963
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 1,
+      "componentType": 5123,
+      "count": 3,
+      "type": "SCALAR",
+      "max": [2],
+      "min": [0]
+    }
+  ],
+  "asset": {
+    "version": "2.0"
+  }
+}
@@ -0,0 +1,224 @@
+{
+  "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
+    }
+  ]
+}
@@ -0,0 +1,6 @@
+Added KHR_texture_transform property to Cube scene.
+
+License: Donated by Norbert Nopper for glTF testing.
+
+https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/2.0/Cube
+
@@ -0,0 +1,193 @@
+{
+   "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
+      }
+   ]
+}
@@ -0,0 +1,4 @@
+License: Donated by Norbert Nopper for glTF testing.
+
+https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/2.0/Cube
+
@@ -0,0 +1,171 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "scene": 0,
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 2,
+            "POSITION": 1,
+            "TEXCOORD_0": 3
+          },
+          "indices": 0,
+          "mode": 4,
+          "material": 0
+        }
+      ]
+    }
+  ],
+  "materials": [
+    {
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 0,
+          "texCoord": 0
+        },
+        "baseColorFactor": [
+          1,
+          1,
+          1,
+          1
+        ],
+        "metallicFactor": 1,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "alphaMode": "OPAQUE"
+    }
+  ],
+  "textures": [
+    {
+      "source": 0,
+      "sampler": 0
+    }
+  ],
+  "samplers": [
+    {
+      "wrapS": 33071,
+      "wrapT": 33071
+    }
+  ],
+  "images": [
+    {
+      "uri": " 2x2 image  has multiple      spaces.png"
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 0,
+      "byteOffset": 0,
+      "componentType": 5121,
+      "count": 36,
+      "normalized": false,
+      "max": [
+        23
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "bufferView": 1,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 2,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1,
+        1
+      ],
+      "min": [
+        -1,
+        -1,
+        -1
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 3,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1
+      ],
+      "min": [
+        0,
+        0
+      ],
+      "type": "VEC2"
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 36
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 36,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 324,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 612,
+      "byteLength": 192
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 804,
+      "uri": "CubeImageUriSpaces.bin"
+    }
+  ]
+}
@@ -0,0 +1,171 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "scene": 0,
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 2,
+            "POSITION": 1,
+            "TEXCOORD_0": 3
+          },
+          "indices": 0,
+          "mode": 4,
+          "material": 0
+        }
+      ]
+    }
+  ],
+  "materials": [
+    {
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 0,
+          "texCoord": 0
+        },
+        "baseColorFactor": [
+          1,
+          1,
+          1,
+          1
+        ],
+        "metallicFactor": 1,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "alphaMode": "OPAQUE"
+    }
+  ],
+  "textures": [
+    {
+      "source": 0,
+      "sampler": 0
+    }
+  ],
+  "samplers": [
+    {
+      "wrapS": 33071,
+      "wrapT": 33071
+    }
+  ],
+  "images": [
+    {
+      "uri": "2x2 image has spaces.png"
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 0,
+      "byteOffset": 0,
+      "componentType": 5121,
+      "count": 36,
+      "normalized": false,
+      "max": [
+        23
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "bufferView": 1,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 2,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1,
+        1
+      ],
+      "min": [
+        -1,
+        -1,
+        -1
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 3,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1
+      ],
+      "min": [
+        0,
+        0
+      ],
+      "type": "VEC2"
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 36
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 36,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 324,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 612,
+      "byteLength": 192
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 804,
+      "uri": "CubeImageUriSpaces.bin"
+    }
+  ]
+}
@@ -0,0 +1,66 @@
+
+{
+  "scenes" : [
+    {
+      "nodes" : [ 0 ]
+    }
+  ],
+  
+  "nodes" : [
+    {
+      "mesh" : 0
+    }
+  ],
+
+  "meshes" : [
+    {
+      "primitives" : [ {
+        "attributes" : {
+          "POSITION" : 0
+        }
+      } ]
+    }
+  ],
+
+  "buffers" : [
+    {
+      "uri" : "data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAA",
+      "byteLength" : 36
+    }
+  ],
+  "bufferViews" : [
+    {
+      "buffer" : 0,
+      "byteOffset" : 0,
+      "byteLength" : 36,
+      "target" : 34962
+    }
+  ],
+  "accessors" : [
+    {
+      "bufferView" : 0,
+      "byteOffset" : 0,
+      "componentType" : 5126,
+      "count" : 3,
+      "type" : "VEC3",
+      "max" : [ 1.0, 1.0, 0.0 ],
+      "min" : [ 0.0, 0.0, 0.0 ]
+    }
+  ],
+  
+  "asset" : {
+    "version" : "2.0"
+  },
+
+  "materials" : [
+    { "name" : "WHITE",
+      "extensions": {
+        "VENDOR_material_some_ext" : { }
+      }
+    }
+  ],
+  
+  "extensionsUsed" : [
+    "VENDOR_material_some_ext"
+  ]
+}
@@ -0,0 +1,376 @@
+{
+  "accessors": [
+    {
+      "bufferView": 0,
+      "componentType": 5126,
+      "count": 8,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 1,
+      "componentType": 5125,
+      "count": 36,
+      "type": "SCALAR"
+    }
+  ],
+  "asset": {
+    "copyright": "NVIDIA Corporation",
+    "generator": "Iray glTF plugin",
+    "version": "2.0"
+  },
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 96,
+      "byteStride": 12
+    },
+    {
+      "buffer": 0,
+      "byteLength": 144,
+      "byteOffset": 96
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 240,
+      "uri": "issue-261.bin"
+    }
+  ],
+  "cameras": [
+    {
+      "extensions": {
+        "NV_Iray": {
+          "mip_burn_highlights": 0.699999988079071,
+          "mip_burn_highlights_per_component": false,
+          "mip_camera_shutter": 4.0,
+          "mip_cm2_factor": 1.0,
+          "mip_crush_blacks": 0.5,
+          "mip_f_number": 1.0,
+          "mip_film_iso": 100.0,
+          "mip_gamma": 2.200000047683716,
+          "mip_saturation": 1.0,
+          "mip_vignetting": 0.00019999999494757503,
+          "mip_whitepoint": [
+            1.0,
+            1.0,
+            1.0,
+            1.0
+          ],
+          "tm_enable_tonemapper": true,
+          "tm_tonemapper": "mia_exposure_photographic"
+        }
+      },
+      "extras": {
+        "resolution": [
+          640,
+          480
+        ]
+      },
+      "name": "default",
+      "perspective": {
+        "aspectRatio": 1.3333333730697632,
+        "yfov": 0.9272952079772949,
+        "zfar": 1000.0,
+        "znear": 0.1
+      },
+      "type": "perspective"
+    }
+  ],
+  "extensions": {
+    "KHR_lights_punctual": {
+      "lights": [
+        {
+          "color": [
+            1.0,
+            1.0,
+            1.0
+          ],
+          "intensity": 1000.0,
+          "name": "light",
+          "type": "point"
+        }
+      ]
+    },
+    "NV_MDL": {
+      "modules": [
+        "mdl::base",
+        "mdl::nvidia::core_definitions",
+        "mdl::state"
+      ],
+      "shaders": [
+        {
+          "definition": "mdl::base::environment_spherical(texture_2d)",
+          "name": "env_shd"
+        },
+        {
+          "arguments": {
+            "base_color": [
+              0.0055217444896698,
+              0.36859095096588135,
+              0.0041161770932376385
+            ],
+            "normal=": 2
+          },
+          "definition": "mdl::nvidia::core_definitions::flex_material",
+          "name": "cube_instance_material"
+        },
+        {
+          "definition": "mdl::state::normal()",
+          "name": "mdl::state::normal_341"
+        },
+        {
+          "arguments": {
+            "base_color": [
+              0.0055217444896698,
+              0.36859095096588135,
+              0.0041161770932376385
+            ],
+            "normal=": 4
+          },
+          "definition": "mdl::nvidia::core_definitions::flex_material",
+          "name": "cube_instance_material"
+        },
+        {
+          "definition": "mdl::state::normal()",
+          "name": "mdl::state::normal_341"
+        }
+      ]
+    }
+  },
+  "extensionsUsed": [
+    "NV_MDL",
+    "NV_Iray",
+    "KHR_lights_punctual"
+  ],
+  "materials": [
+    {
+      "doubleSided": true,
+      "extras": {
+        "mdl_shader": 1
+      },
+      "name": "cube_instance_material",
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.0055217444896698,
+          0.36859095096588135,
+          0.0041161770932376385,
+          1.0
+        ]
+      }
+    }
+  ],
+  "meshes": [
+    {
+      "name": "cube",
+      "primitives": [
+        {
+          "attributes": {
+            "POSITION": 0
+          },
+          "indices": 1,
+          "material": 0,
+          "mode": 4
+        }
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "camera": 0,
+      "extensions": {
+        "NV_Iray": {
+          "iview:fkey": -1,
+          "iview:fov": 53.130104064941406,
+          "iview:interest": [
+            0.1342654824256897,
+            -0.14356137812137604,
+            0.037264324724674225
+          ],
+          "iview:position": [
+            0.9729073643684387,
+            1.2592438459396362,
+            2.4199187755584717
+          ],
+          "iview:roll": 0.0,
+          "iview:up": [
+            0.0,
+            1.0,
+            0.0
+          ]
+        }
+      },
+      "matrix": [
+        0.9432751389105357,
+        -1.1769874756875739e-16,
+        -0.3320120665176343,
+        0.0,
+        -0.16119596696756341,
+        0.8742297945345237,
+        -0.45797175303889276,
+        0.0,
+        0.290254840694694,
+        0.48551237507207207,
+        0.8246392308792816,
+        0.0,
+        0.9729073377709113,
+        1.2592438262175363,
+        2.419918748461627,
+        1.0
+      ],
+      "name": "CamInst"
+    },
+    {
+      "extensions": {
+        "NV_Iray": {
+          "caustic": true,
+          "caustic_cast": true,
+          "caustic_recv": true,
+          "face_back": true,
+          "face_front": true,
+          "finalgather": true,
+          "finalgather_cast": true,
+          "finalgather_recv": true,
+          "globillum": true,
+          "globillum_cast": true,
+          "globillum_recv": true,
+          "material=": 3,
+          "pickable": true,
+          "reflection_cast": true,
+          "reflection_recv": true,
+          "refraction_cast": true,
+          "refraction_recv": true,
+          "shadow_cast": true,
+          "shadow_recv": true,
+          "transparency_cast": true,
+          "transparency_recv": true,
+          "visible": true
+        }
+      },
+      "mesh": 0,
+      "name": "cube_instance"
+    },
+    {
+      "extensions": {
+        "KHR_lights_punctual": {
+          "light": 0
+        },
+        "NV_Iray": {
+          "shadow_cast": true,
+          "visible": false
+        }
+      },
+      "matrix": [
+        0.6988062355563571,
+        -7.76042172309776e-17,
+        -0.7153110128800992,
+        -0.0,
+        -0.4276881690736487,
+        0.8015668284138362,
+        -0.41781987700564616,
+        -0.0,
+        0.57336957992379,
+        0.5979051928078428,
+        0.5601398979107212,
+        0.0,
+        2.3640632834071384,
+        2.465226204472449,
+        2.309515908392224,
+        1.0
+      ],
+      "name": "light_inst"
+    }
+  ],
+  "scene": 0,
+  "scenes": [
+    {
+      "extensions": {
+        "NV_Iray": {
+          "CP_canny_threshold1": 40,
+          "CP_canny_threshold2": 120,
+          "CP_color_quantization": 8,
+          "IVP_color": [
+            1.0,
+            0.0,
+            0.0,
+            1.0
+          ],
+          "TM_drago_bias": 0.8500000238418579,
+          "TM_drago_gamma2": 2.200000047683716,
+          "TM_drago_saturation": 1.0,
+          "TM_durand_contrast": 4.0,
+          "TM_durand_gamma": 2.200000047683716,
+          "TM_durand_saturation": 1.0,
+          "TM_durand_sigma_color": 2.0,
+          "TM_durand_sigma_space": 2.0,
+          "TM_linear_gamma": 2.200000047683716,
+          "TM_reinhard_color_adapt": 0.8999999761581421,
+          "TM_reinhard_gamma": 1.0,
+          "TM_reinhard_intensity": 0.0,
+          "TM_reinhard_light_adapt": 1.0,
+          "TM_reye_Ywhite": 1000000.0,
+          "TM_reye_bsize": 2,
+          "TM_reye_bthres": 3.0,
+          "TM_reye_gamma": 2.200000047683716,
+          "TM_reye_key": 0.5,
+          "TM_reye_saturation": 1.0,
+          "TM_reye_whitebalance": [
+            1.0,
+            0.9965101480484009,
+            0.9805564880371094,
+            0.0
+          ],
+          "environment_dome_depth": 200.0,
+          "environment_dome_height": 200.0,
+          "environment_dome_mode": "infinite",
+          "environment_dome_position": [
+            0.0,
+            0.0,
+            0.0
+          ],
+          "environment_dome_radius": 100.0,
+          "environment_dome_rotation_angle": 0.0,
+          "environment_dome_width": 200.0,
+          "environment_function=": 0,
+          "environment_function_intensity": 1.9900000095367432,
+          "iray_instancing": "off",
+          "iview::inline_color": [
+            1.0,
+            0.0,
+            0.0,
+            1.0
+          ],
+          "iview::inline_width": 1.0,
+          "iview::magnifier_size": 300,
+          "iview::offset": 10.0,
+          "iview::outline_color": [
+            0.0,
+            0.0,
+            0.0,
+            1.0
+          ],
+          "iview::outline_width": 2.0,
+          "iview::overview": true,
+          "iview::zoom_factor": 1.0,
+          "samples": 4.0,
+          "shadow_cast": true,
+          "shadow_recv": true
+        }
+      },
+      "nodes": [
+        0,
+        1,
+        2
+      ]
+    }
+  ]
+}
@@ -0,0 +1,30 @@
+sources = {
+   "loader_example.cc",
+   }
+
+-- premake4.lua
+solution "TinyGLTFSolution"
+   configurations { "Release", "Debug" }
+
+   if (os.is("windows")) then
+      platforms { "x32", "x64" }
+   else
+      platforms { "native", "x32", "x64" }
+   end
+
+   -- A project defines one build target
+   project "tinygltf"
+      kind "ConsoleApp"
+      language "C++"
+      files { sources }
+      flags { "C++11" }
+
+      configuration "Debug"
+         defines { "DEBUG" } -- -DDEBUG
+         flags { "Symbols" }
+         targetname "loader_example_tinygltf_debug"
+
+      configuration "Release"
+         -- defines { "NDEBUG" } -- -NDEBUG
+         flags { "Symbols", "Optimize" }
+         targetname "loader_example_tinygltf"
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+import glob
+import os
+import subprocess
+
+## Simple test runner.
+
+# -- config -----------------------
+
+# Absolute path pointing to your cloned git repo of https://github.com/KhronosGroup/glTF-Sample-Models
+sample_model_dir = "/home/syoyo/work/glTF-Sample-Models"
+base_model_dir = os.path.join(sample_model_dir, "2.0")
+
+# Include `glTF-Draco` when you build `loader_example` with draco support.
+kinds = [ "glTF", "glTF-Binary", "glTF-Embedded", "glTF-MaterialsCommon"]
+# ---------------------------------
+
+failed = []
+success = []
+
+def run(filename):
+
+    print("Testing: " + filename)
+    cmd = ["./loader_example", filename]
+    try:
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        (stdout, stderr) = p.communicate()
+    except:
+        print("Failed to execute: ", cmd)
+        raise
+
+    if p.returncode != 0:
+        failed.append(filename)
+        print(stdout)
+        print(stderr)
+    else:
+        success.append(filename)
+
+
+def test():
+
+    for d in os.listdir(base_model_dir):
+        p = os.path.join(base_model_dir, d)
+        if os.path.isdir(p):
+            for k in kinds:
+                targetDir = os.path.join(p, k)
+                g = glob.glob(targetDir + "/*.gltf") + glob.glob(targetDir + "/*.glb")
+                for gltf in g:
+                    run(gltf)
+
+
+def main():
+
+    test()
+
+    print("Success : {0}".format(len(success)))
+    print("Failed  : {0}".format(len(failed)))
+
+    for fail in failed:
+        print("FAIL: " + fail)
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,7 @@
+# Use this for strict compilation check(will work on clang 3.8+)
+#EXTRA_CXXFLAGS := -fsanitize=address -Wall -Werror -Weverything -Wno-c++11-long-long -DTINYGLTF_APPLY_CLANG_WEVERYTHING
+
+all: ../tiny_gltf.h
+	clang++  -I../ $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o tester tester.cc
+	clang++ -DTINYGLTF_NOEXCEPTION -I../ $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o tester_noexcept tester.cc
+	clang++ -DTINYGLTF_USE_CUSTOM_JSON -I../ $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o tester_intensive_customjson tester_intensive_customjson.cc
@@ -0,0 +1,57 @@
+# Fuzzing test
+
+Do fuzzing test for TinyGLTF API.
+
+## Supported API
+
+* [x] LoadASCIIFromString
+* [ ] LoadBinaryFromMemory
+
+### Custom JSON backend (`tinygltf_json.h`)
+
+* [x] LoadASCIIFromString
+* [x] LoadBinaryFromMemory
+
+## Requirements
+
+* meson
+* clang with fuzzer support(`-fsanitize=fuzzer`. at least clang 8.0 should work)
+
+## Setup
+
+### Ubuntu 18.04
+
+```
+$ sudo apt install clang++-8
+$ sudo apt install libfuzzer-8-dev
+```
+
+Optionally, if you didn't set `update-alternatives` you can set `clang++` to point to `clang++8`
+
+```
+$ sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-8 10
+$ sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-8 10
+```
+
+## How to compile
+
+```
+$ CXX=clang++ CC=clang meson build
+$ cd build
+$ ninja
+```
+
+This builds two fuzzers:
+
+* `fuzz_gltf` – default nlohmann/json backend
+* `fuzz_gltf_customjson` – custom `tinygltf_json.h` backend (tests both ASCII and binary parsing paths)
+
+## How to run
+
+Increase memory limit. e.g. `-rss_limit_mb=50000`
+
+```
+$ ./fuzz_gltf -rss_limit_mb=20000 -jobs 4
+$ ./fuzz_gltf_customjson -rss_limit_mb=20000 -jobs 4
+```
+
@@ -0,0 +1,33 @@
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <iostream>
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define TINYGLTF_IMPLEMENTATION
+#include "tiny_gltf.h"
+
+static void parse_intCoding4(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, size, /* base_dir */"" );
+  (void)ret;
+
+}
+
+extern "C"
+int LLVMFuzzerTestOneInput(std::uint8_t const* data, std::size_t size)
+{
+    parse_intCoding4(data, size);
+    return 0;
+}
+
@@ -0,0 +1,76 @@
+/*
+ * 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;
+}
@@ -0,0 +1,15 @@
+project('fuzz_tinygltf', 'cpp', default_options : ['cpp_std=c++11'])
+
+incdirs = include_directories('../../')
+executable('fuzz_gltf',
+  'fuzz_gltf.cc',
+  include_directories : incdirs,
+  cpp_args : '-fsanitize=address,fuzzer',
+  link_args : '-fsanitize=address,fuzzer' )
+
+executable('fuzz_gltf_customjson',
+  'fuzz_gltf_customjson.cc',
+  include_directories : incdirs,
+  cpp_args : ['-fsanitize=address,fuzzer', '-DTINYGLTF_USE_CUSTOM_JSON'],
+  link_args : '-fsanitize=address,fuzzer' )
+
@@ -0,0 +1 @@
+{"images":[{"uri":"%!QAAAQAAA5"}],"asset":{"version":""}}
@@ -0,0 +1,67 @@
+# tests/v3/fuzzer/Makefile — Build libFuzzer harness for tinygltf v3
+#
+# Requires: clang++ with libFuzzer support
+#
+# Targets:
+#   make             — build fuzzer with ASan + UBSan
+#   make run         — run fuzzer with default settings
+#   make seed        — generate seed corpus from test models
+#   make clean       — remove binaries and corpus
+
+CXX       = clang++
+CXXFLAGS  = -g -O1 -std=c++17 -fno-rtti -fno-exceptions
+SANITIZE  = -fsanitize=fuzzer,address,undefined
+INCLUDES  = -I../../..
+
+FUZZER    = fuzz_gltf_v3
+CORPUS    = corpus
+ARTIFACTS = artifacts
+
+# Fuzzer runtime options
+MAX_LEN   ?= 65536
+JOBS      ?= $(shell nproc 2>/dev/null || echo 4)
+MAX_TIME  ?= 0
+
+.PHONY: all run seed clean
+
+all: $(FUZZER)
+
+$(FUZZER): fuzz_gltf_v3.cc ../../../tiny_gltf_v3.h ../../../tinygltf_json.h
+	$(CXX) $(CXXFLAGS) $(SANITIZE) $(INCLUDES) -o $@ $<
+
+run: $(FUZZER) | $(CORPUS) $(ARTIFACTS)
+	./$(FUZZER) $(CORPUS) \
+		-artifact_prefix=$(ARTIFACTS)/ \
+		-max_len=$(MAX_LEN) \
+		-jobs=$(JOBS) \
+		-workers=$(JOBS) \
+		$(if $(filter-out 0,$(MAX_TIME)),-max_total_time=$(MAX_TIME))
+
+# Generate seed corpus from existing test models
+seed: | $(CORPUS)
+	@echo "Seeding corpus from test models..."
+	@for f in ../../../models/Cube/Cube.gltf \
+	          ../../../models/Cube/Cube.glb; do \
+		if [ -f "$$f" ]; then \
+			cp "$$f" $(CORPUS)/; \
+			echo "  Added: $$f"; \
+		fi; \
+	done
+	@# Add a minimal valid glTF JSON
+	@echo '{"asset":{"version":"2.0"},"scene":0,"scenes":[{"nodes":[0]}],"nodes":[{"name":"n"}]}' > $(CORPUS)/minimal.gltf
+	@# Add a minimal valid GLB (header + empty JSON chunk)
+	@printf 'glTF\x02\x00\x00\x00\x1c\x00\x00\x00\x04\x00\x00\x00JSON{}  ' > $(CORPUS)/minimal.glb
+	@# Add edge cases
+	@echo '{}' > $(CORPUS)/empty_object.gltf
+	@echo '{"asset":{"version":"2.0"}}' > $(CORPUS)/asset_only.gltf
+	@echo "Corpus: $$(ls $(CORPUS) | wc -l) files"
+
+$(CORPUS):
+	mkdir -p $(CORPUS)
+
+$(ARTIFACTS):
+	mkdir -p $(ARTIFACTS)
+
+clean:
+	rm -f $(FUZZER)
+	rm -rf $(CORPUS) $(ARTIFACTS)
@@ -0,0 +1,110 @@
+/*
+ * fuzz_gltf_v3.cc — libFuzzer harness for tinygltf v3 parser.
+ *
+ * Fuzz targets:
+ *   - Auto-detect (GLB or JSON) parse from arbitrary bytes
+ *   - Exercises JSON parser, GLB header parsing, arena allocator,
+ *     error stack, and all glTF entity parsing paths.
+ *
+ * Build (clang with libFuzzer):
+ *   clang++ -g -O1 -fsanitize=fuzzer,address,undefined \
+ *       -std=c++17 -fno-rtti -fno-exceptions \
+ *       -I../../.. -o fuzz_gltf_v3 fuzz_gltf_v3.cc
+ *
+ * Run:
+ *   ./fuzz_gltf_v3 corpus/ -max_len=65536
+ *
+ * Seed corpus: place valid .gltf and .glb files in corpus/
+ */
+
+#define TINYGLTF3_IMPLEMENTATION
+#include "tiny_gltf_v3.h"
+
+#include <cstdint>
+#include <cstddef>
+
+/* Memory budget to prevent OOM during fuzzing */
+static const uint64_t FUZZ_MEMORY_BUDGET = 64ULL * 1024 * 1024; /* 64 MB */
+
+static void fuzz_parse_auto(const uint8_t *data, size_t size) {
+    tg3_model model;
+    tg3_error_stack errors;
+    tg3_error_stack_init(&errors);
+
+    tg3_parse_options opts;
+    tg3_parse_options_init(&opts);
+    opts.memory.memory_budget = FUZZ_MEMORY_BUDGET;
+
+    tg3_parse_auto(&model, &errors, data, (uint64_t)size,
+                   "", 0, &opts);
+
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+}
+
+static void fuzz_parse_json(const uint8_t *data, size_t size) {
+    tg3_model model;
+    tg3_error_stack errors;
+    tg3_error_stack_init(&errors);
+
+    tg3_parse_options opts;
+    tg3_parse_options_init(&opts);
+    opts.memory.memory_budget = FUZZ_MEMORY_BUDGET;
+
+    tg3_parse(&model, &errors, data, (uint64_t)size,
+              "", 0, &opts);
+
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+}
+
+static void fuzz_parse_glb(const uint8_t *data, size_t size) {
+    tg3_model model;
+    tg3_error_stack errors;
+    tg3_error_stack_init(&errors);
+
+    tg3_parse_options opts;
+    tg3_parse_options_init(&opts);
+    opts.memory.memory_budget = FUZZ_MEMORY_BUDGET;
+
+    tg3_parse_glb(&model, &errors, data, (uint64_t)size,
+                  "", 0, &opts);
+
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+}
+
+static void fuzz_parse_float32(const uint8_t *data, size_t size) {
+    tg3_model model;
+    tg3_error_stack errors;
+    tg3_error_stack_init(&errors);
+
+    tg3_parse_options opts;
+    tg3_parse_options_init(&opts);
+    opts.memory.memory_budget = FUZZ_MEMORY_BUDGET;
+    opts.parse_float32 = 1;
+
+    tg3_parse_auto(&model, &errors, data, (uint64_t)size,
+                   "", 0, &opts);
+
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    if (size == 0) return 0;
+
+    /* Use first byte to select parse path, rest is the payload */
+    uint8_t selector = data[0] % 4;
+    const uint8_t *payload = data + 1;
+    size_t payload_size = size - 1;
+
+    switch (selector) {
+    case 0: fuzz_parse_auto(payload, payload_size);    break;
+    case 1: fuzz_parse_json(payload, payload_size);    break;
+    case 2: fuzz_parse_glb(payload, payload_size);     break;
+    case 3: fuzz_parse_float32(payload, payload_size); break;
+    }
+
+    return 0;
+}
@@ -0,0 +1,4 @@
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "tiny_gltf.h"
@@ -0,0 +1 @@
+.\\tools\\windows\\premake5.exe vs2015
@@ -0,0 +1,11 @@
+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++
+CXXFLAGS=-fno-rtti -fno-exceptions -g -Os
+
+all:
+	$(CXX) ../loader_example.cc $(CXXFLAGS) -I../
@@ -0,0 +1,31 @@
+Experimental WASI/WASM build
+
+## Build
+
+Download wasi-sdk https://github.com/WebAssembly/wasi-sdk
+
+Compile tinygltf without C++ exceptions and threads. See `Makefile` for details
+(NOTE: TinyGLTF itself does not use RTTI and threading feature(C++ threads, posix, win32 thread))
+
+## Build examples and Run
+
+Build `loader_example.cc`
+
+```
+$ /path/to/wasi-sdk-16.0/bin/clang++ ../loader_example.cc -fno-rtti -fno-exceptions -g -Os -I../ -o loader_example.wasi
+```
+
+Tested with wasmtime.  https://github.com/bytecodealliance/wasmtime
+
+
+Set a folder containing .gltf file to `--dir`
+
+```
+$ wasmtime --dir=../models loader_example.wasi ../models/Cube/Cube.gltf
+```
+
+## Emscripen
+
+T.B.W. ...
+
+EoL.
				`@@ -0,0 +1 @@`
				`{"images":[{"uri":"%!QAAAQAAA5"}],"asset":{"version":""}}`