Support uint

Improve .obj export.
Use clipp to parse cmd options.
Add some handy python scripts.

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +0,0 @@
-blank_issues_enabled: false

.github/ISSUE_TEMPLATE/issue-report.md

@@ -1,30 +0,0 @@
----
-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.

.github/workflows/c-cpp.yml

@@ -1,167 +0,0 @@
-name: C/C++ CI
-
-on: [push, pull_request]
-
-jobs:
-
-  # 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-18.04
-    name: Build with MinGW gcc cross
-
-    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 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-18.04
-    name: Build on cross aarch64
-
-    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-8-aarch64-linux-gnu g++-8-aarch64-linux-gnu
-
-            git clone https://github.com/Tencent/rapidjson
-            aarch64-linux-gnu-g++-8 -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -g -O0 -o loader_example loader_example.cc
-
-  # macOS clang
-  build-macos:
-
-    runs-on: macos-latest
-    name: Build on macOS
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v1
-      - name: Build
-        run: |
-            clang++ -std=c++11 -g -O0 -o loader_example loader_example.cc
-            ./loader_example models/Cube/Cube.gltf
-
-            git clone https://github.com/Tencent/rapidjson
-            clang++ -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -g -O0 -o loader_example loader_example.cc
-

.github/workflows/codeql-analysis.yml

@@ -1,72 +0,0 @@
-# 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

.gitignore

@@ -68,11 +68,4 @@ loader_example
 tests/tester
 tests/tester_noexcept
 tests/issue-97.gltf
-tests/issue-261.gltf
 
-# unignore
-!Makefile
-!examples/build-gltf/Makefile
-!examples/raytrace/cornellbox_suzanne.obj
-!tests/Makefile
-!tools/windows/premake5.exe

CMakeLists.txt

@@ -4,73 +4,32 @@ PROJECT (tinygltf)
 
 SET(CMAKE_CXX_STANDARD 11)
 
-option(TINYGLTF_BUILD_LOADER_EXAMPLE "Build loader_example(load glTF and dump infos)" ON)
-option(TINYGLTF_BUILD_GL_EXAMPLES "Build GL exampels(requires glfw, OpenGL, etc)" OFF)
-option(TINYGLTF_BUILD_VALIDATOR_EXAMPLE "Build validator exampe" OFF)
-option(TINYGLTF_BUILD_BUILDER_EXAMPLE "Build glTF builder example" OFF)
-option(TINYGLTF_HEADER_ONLY "On: header-only mode. Off: create tinygltf library(No TINYGLTF_IMPLEMENTATION required in your project)" OFF)
-option(TINYGLTF_INSTALL "Install tinygltf files during install step. Usually set to OFF if you include tinygltf through add_subdirectory()" ON)
+option(TINYGLTF_BUILD_EXAMPLES "Build examples" ON)
 
-if (TINYGLTF_BUILD_LOADER_EXAMPLE)
+if (TINYGLTF_BUILD_EXAMPLES)
   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)
+endif (TINYGLTF_BUILD_EXAMPLES)
 
 #
-# for add_subdirectory and standalone build
+# TinuGLTF is a header-only library, so no library build. just install header files.
 #
-if (TINYGLTF_HEADER_ONLY)
-  add_library(tinygltf INTERFACE)
-
-  target_include_directories(tinygltf
-          INTERFACE
-          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+INSTALL ( FILES
+  json.hpp
+  stb_image.h
+  stb_image_write.h
+  tiny_gltf.h
+  DESTINATION
+  include
   )
 
-else (TINYGLTF_HEADER_ONLY)
-  add_library(tinygltf)
-  target_sources(tinygltf PRIVATE
-          ${CMAKE_CURRENT_SOURCE_DIR}/tiny_gltf.cc)
-  target_include_directories(tinygltf
-          INTERFACE
-          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-          )
-endif (TINYGLTF_HEADER_ONLY)
-
-if (TINYGLTF_INSTALL)
-
-  # Do not install .lib even if !TINYGLTF_HEADER_ONLY
-
-  INSTALL ( FILES
-    json.hpp
-    stb_image.h
-    stb_image_write.h
-    tiny_gltf.h
-    ${TINYGLTF_EXTRA_SOUECES}
-    DESTINATION
-    include
-    )
-
-  INSTALL ( FILES
-    cmake/TinyGLTFConfig.cmake
-    DESTINATION
-    cmake
-    )
-
-endif(TINYGLTF_INSTALL)
+INSTALL ( FILES
+  cmake/TinyGLTFConfig.cmake
+  DESTINATION
+  cmake
+  )

README.md

@@ -3,37 +3,24 @@
 `TinyGLTF` is a header only C++11 glTF 2.0 https://github.com/KhronosGroup/glTF library.
 
 `TinyGLTF` uses Niels Lohmann's json library(https://github.com/nlohmann/json), so now it requires C++11 compiler.
-(Also, you can use RadpidJSON as an JSON backend)
-If you are looking for old, C++03 version, please use `devel-picojson` branch(but not maintained anymore).
+If you are looking for old, C++03 version, please use `devel-picojson` branch.
 
 ## Status
 
-Currently TinyGLTF is stable and maintainance mode. No drastic changes and feature additions planned.
-
- - 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 support)
  - v2.0.0 release(22 Aug, 2018)!
 
-### Branches
-
-* `sajson` : Use sajson to parse JSON. Parsing only but faster compile time(2x reduction compared to json.hpp and RapidJson), but not well maintained.
-
 ## Builds
 
 [![Build Status](https://travis-ci.org/syoyo/tinygltf.svg?branch=devel)](https://travis-ci.org/syoyo/tinygltf)
 
 [![Build status](https://ci.appveyor.com/api/projects/status/warngenu9wjjhlm8?svg=true)](https://ci.appveyor.com/project/syoyo/tinygltf)
 
-![C/C++ CI](https://github.com/syoyo/tinygltf/workflows/C/C++%20CI/badge.svg)
-
 ## Features
 
-Probably mostly feature-complete. Last missing feature is Draco encoding: https://github.com/syoyo/tinygltf/issues/207
-
 * Written in portable C++. C++-11 with STL dependency only.
   * [x] macOS + clang(LLVM)
   * [x] iOS + clang
@@ -84,7 +71,7 @@ In extension(`ExtensionMap`), JSON number value is parsed as int or float(number
 * [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.
+* [mesh-conv](examples/mesh-conv) : Convert glTF mesh to wavefront .obj, wavefront .obj to glTF mesh.
 
 ## Projects using TinyGLTF
 
@@ -97,14 +84,11 @@ In extension(`ExtensionMap`), JSON number value is parsed as int or float(number
 * [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 proessional development of its developer
-* [Open3D](http://www.open3d.org/) - A Modern Library for 3D Data Processing
 * Your projects here! (Please send PR)
 
 ## TODOs
 
-* [ ] Robust URI decoding/encoding. https://github.com/syoyo/tinygltf/issues/369
+* [ ] Write C++ code generator which emits C++ code from JSON schema for robust parsing.
 * [ ] Mesh Compression/decompression(Open3DGC, etc)
   * [x] Load Draco compressed mesh
   * [ ] Save Draco compressed mesh
@@ -115,10 +99,6 @@ In extension(`ExtensionMap`), JSON number value is parsed as int or float(number
 * [ ] 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.
@@ -169,10 +149,6 @@ if (!ret) {
 }
 ```
 
-#### 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.
@@ -182,26 +158,11 @@ if (!ret) {
 * `TINYGLTF_ANDROID_LOAD_FROM_ASSETS`: Load all files from packaged app assets instead of the regular file system. **Note:** You must pass a valid asset manager from your android app to `tinygltf::asset_manager` beforehand.
 * `TINYGLTF_ENABLE_DRACO`: Enable Draco compression. User must provide include path and link correspnding libraries in your project file.
 * `TINYGLTF_NO_INCLUDE_JSON `: Disable including `json.hpp` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
-* `TINYGLTF_NO_INCLUDE_RAPIDJSON `: Disable including RapidJson's header files from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
 * `TINYGLTF_NO_INCLUDE_STB_IMAGE `: Disable including `stb_image.h` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
 * `TINYGLTF_NO_INCLUDE_STB_IMAGE_WRITE `: Disable including `stb_image_write.h` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
-* `TINYGLTF_USE_RAPIDJSON` : Use RapidJSON as a JSON parser/serializer. RapidJSON files are not included in TinyGLTF repo. Please set an include path to RapidJSON if you enable this feature.
+* `TINYGLTF_USE_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 featrure.
 * `TINYGLTF_USE_CPP14` : Use C++14 feature(requires C++14 compiler). This may give better performance than C++11.
 
-## CMake options
-
-You can add tinygltf using `add_subdirectory` feature.
-If you add tinygltf to your project using `add_subdirectory`, it would be better to set `TINYGLTF_HEADER_ONLY` on(just add an include path to tinygltf) and `TINYGLTF_INSTALL` off(Which does not install tinygltf files).
-
-```
-// Your project's CMakeLists.txt
-...
-
-set(TINYGLTF_HEADER_ONLY ON CACHE INTERNAL "" FORCE)
-set(TINYGLTF_INSTALL OFF CACHE INTERNAL "" FORCE)
-add_subdirectory(/path/to/tinygltf)
-```
-
 
 ### Saving gltTF 2.0 model
 
@@ -256,3 +217,7 @@ We may be better to introduce bounded memory size checking when parsing glTF dat
 * 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
+
+### Used in examples
+
+* clipp: MIT License. https://github.com/muellan/clipp

examples/basic/.gitignore

@@ -1,6 +1,5 @@
 .vs
 Debug
-Release
 x64
 packages
 

examples/basic/README.md

@@ -19,7 +19,3 @@ $ make
 Plese use solution file located at `basic` folder.
 
 
-## Limitation
-
-There are so many limitations in this example(e.g. no PBR shader. the shader only shows texture of textures[0] if available).
-

examples/basic/basic/basic.vcxproj

@@ -22,32 +22,32 @@
     <VCProjectVersion>15.0</VCProjectVersion>
     <ProjectGuid>{0589AC44-0CF3-40D8-8D89-68393CFD40F3}</ProjectGuid>
     <RootNamespace>basic</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.17134.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>

examples/basic/main.cpp

@@ -39,8 +39,8 @@ bool loadModel(tinygltf::Model &model, const char *filename) {
   return res;
 }
 
-void bindMesh(std::map<int, GLuint>& vbos,
-              tinygltf::Model &model, tinygltf::Mesh &mesh) {
+std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
+                               tinygltf::Model &model, tinygltf::Mesh &mesh) {
   for (size_t i = 0; i < model.bufferViews.size(); ++i) {
     const tinygltf::BufferView &bufferView = model.bufferViews[i];
     if (bufferView.target == 0) {  // TODO impl drawarrays
@@ -100,66 +100,56 @@ void bindMesh(std::map<int, GLuint>& vbos,
         std::cout << "vaa missing: " << attrib.first << std::endl;
     }
 
-    if (model.textures.size() > 0) {
-      // fixme: Use material's baseColor
-      tinygltf::Texture &tex = model.textures[0];
+    GLuint texid;
+    glGenTextures(1, &texid);
 
-      if (tex.source > -1) {
+    tinygltf::Texture &tex = model.textures[0];
+    tinygltf::Image &image = model.images[tex.source];
 
-        GLuint texid;
-        glGenTextures(1, &texid);
+    glBindTexture(GL_TEXTURE_2D, texid);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
-        tinygltf::Image &image = model.images[tex.source];
+    GLenum format = GL_RGBA;
 
-        glBindTexture(GL_TEXTURE_2D, texid);
-        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
-        GLenum format = GL_RGBA;
-
-        if (image.component == 1) {
-          format = GL_RED;
-        } else if (image.component == 2) {
-          format = GL_RG;
-        } else if (image.component == 3) {
-          format = GL_RGB;
-        } else {
-          // ???
-        }
-
-        GLenum type = GL_UNSIGNED_BYTE;
-        if (image.bits == 8) {
-          // ok
-        } else if (image.bits == 16) {
-          type = GL_UNSIGNED_SHORT;
-        } else {
-          // ???
-        }
-
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
-                     format, type, &image.image.at(0));
-      }
+    if (image.component == 1) {
+      format = GL_RED;
+    } else if (image.component == 2) {
+      format = GL_RG;
+    } else if (image.component == 3) {
+      format = GL_RGB;
+    } else {
+      // ???
     }
+
+    GLenum type = GL_UNSIGNED_BYTE;
+    if (image.bits == 8) {
+      // ok
+    } else if (image.bits == 16) {
+      type = GL_UNSIGNED_SHORT;
+    } else {
+      // ???
+    }
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
+                 format, type, &image.image.at(0));
   }
+
+  return vbos;
 }
 
 // bind models
-void bindModelNodes(std::map<int, GLuint>& vbos, tinygltf::Model &model,
+void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model,
                     tinygltf::Node &node) {
-  if ((node.mesh >= 0) && (node.mesh < model.meshes.size())) {
-    bindMesh(vbos, model, model.meshes[node.mesh]);
-  }
-
+  bindMesh(vbos, model, model.meshes[node.mesh]);
   for (size_t i = 0; i < node.children.size(); i++) {
-    assert((node.children[i] >= 0) && (node.children[i] < model.nodes.size()));
     bindModelNodes(vbos, model, model.nodes[node.children[i]]);
   }
 }
-
-std::pair<GLuint, std::map<int, GLuint>> bindModel(tinygltf::Model &model) {
+GLuint bindModel(tinygltf::Model &model) {
   std::map<int, GLuint> vbos;
   GLuint vao;
   glGenVertexArrays(1, &vao);
@@ -167,34 +157,23 @@ std::pair<GLuint, std::map<int, GLuint>> bindModel(tinygltf::Model &model) {
 
   const tinygltf::Scene &scene = model.scenes[model.defaultScene];
   for (size_t i = 0; i < scene.nodes.size(); ++i) {
-    assert((scene.nodes[i] >= 0) && (scene.nodes[i] < model.nodes.size()));
     bindModelNodes(vbos, model, model.nodes[scene.nodes[i]]);
   }
 
   glBindVertexArray(0);
-  // cleanup vbos but do not delete index buffers yet
-  for (auto it = vbos.cbegin(); it != vbos.cend();) {
-    tinygltf::BufferView bufferView = model.bufferViews[it->first];
-    if (bufferView.target != GL_ELEMENT_ARRAY_BUFFER) {
-      glDeleteBuffers(1, &vbos[it->first]);
-      vbos.erase(it++);
-    }
-    else {
-      ++it;
-    }
+  // cleanup vbos
+  for (size_t i = 0; i < vbos.size(); ++i) {
+    glDeleteBuffers(1, &vbos[i]);
   }
 
-  return {vao, vbos};
+  return vao;
 }
 
-void drawMesh(const std::map<int, GLuint>& vbos,
-              tinygltf::Model &model, tinygltf::Mesh &mesh) {
+void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
   for (size_t i = 0; i < mesh.primitives.size(); ++i) {
     tinygltf::Primitive primitive = mesh.primitives[i];
     tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
 
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos.at(indexAccessor.bufferView));
-
     glDrawElements(primitive.mode, indexAccessor.count,
                    indexAccessor.componentType,
                    BUFFER_OFFSET(indexAccessor.byteOffset));
@@ -202,22 +181,18 @@ void drawMesh(const std::map<int, GLuint>& vbos,
 }
 
 // recursively draw node and children nodes of model
-void drawModelNodes(const std::pair<GLuint, std::map<int, GLuint>>& vaoAndEbos,
-                    tinygltf::Model &model, tinygltf::Node &node) {
-  if ((node.mesh >= 0) && (node.mesh < model.meshes.size())) {
-    drawMesh(vaoAndEbos.second, model, model.meshes[node.mesh]);
-  }
+void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) {
+  drawMesh(model, model.meshes[node.mesh]);
   for (size_t i = 0; i < node.children.size(); i++) {
-    drawModelNodes(vaoAndEbos, model, model.nodes[node.children[i]]);
+    drawModelNodes(model, model.nodes[node.children[i]]);
   }
 }
-void drawModel(const std::pair<GLuint, std::map<int, GLuint>>& vaoAndEbos,
-               tinygltf::Model &model) {
-  glBindVertexArray(vaoAndEbos.first);
+void drawModel(GLuint vao, tinygltf::Model &model) {
+  glBindVertexArray(vao);
 
   const tinygltf::Scene &scene = model.scenes[model.defaultScene];
   for (size_t i = 0; i < scene.nodes.size(); ++i) {
-    drawModelNodes(vaoAndEbos, model, model.nodes[scene.nodes[i]]);
+    drawModelNodes(model, model.nodes[scene.nodes[i]]);
   }
 
   glBindVertexArray(0);
@@ -293,7 +268,7 @@ void displayLoop(Window &window, const std::string &filename) {
   tinygltf::Model model;
   if (!loadModel(model, filename.c_str())) return;
 
-  std::pair<GLuint, std::map<int, GLuint>> vaoAndEbos = bindModel(model);
+  GLuint vao = bindModel(model);
   // dbgModel(model); return;
 
   // Model matrix : an identity matrix (model will be at the origin)
@@ -328,12 +303,10 @@ void displayLoop(Window &window, const std::string &filename) {
     glUniform3fv(sun_position_u, 1, &sun_position[0]);
     glUniform3fv(sun_color_u, 1, &sun_color[0]);
 
-    drawModel(vaoAndEbos, model);
+    drawModel(vao, model);
     glfwSwapBuffers(window.window);
     glfwPollEvents();
   }
-
-  glDeleteVertexArrays(1, &vaoAndEbos.first);
 }
 
 static void error_callback(int error, const char *description) {
@@ -342,7 +315,7 @@ static void error_callback(int error, const char *description) {
 }
 
 int main(int argc, char **argv) {
-  std::string filename = "../../../models/Cube/Cube.gltf";
+  std::string filename = "../../models/Cube/Cube.gltf";
 
   if (argc > 1) {
     filename = argv[1];
@@ -354,12 +327,9 @@ int main(int argc, char **argv) {
 
   // Force create OpenGL 3.3
   // NOTE(syoyo): Linux + NVIDIA driver segfaults for some reason? commenting out glfwWindowHint will work.
-  // Note (PE): On laptops with intel hd graphics card you can overcome the segfault by enabling experimental, see below (tested on lenovo thinkpad)
   glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
   glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
   glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-  glewExperimental = GL_TRUE;
-
 #ifdef __APPLE__
   glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
 #endif

examples/build-gltf/Makefile

@@ -1,2 +0,0 @@
-all:
-	$(CXX) -o create_triangle_gltf -I../../ create_triangle_gltf.cpp

examples/build-gltf/create_triangle_gltf.cpp

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

examples/common/clipp.LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 André Müller; foss@andremueller-online.de
+
+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.

examples/dxview/CMakeLists.txt

@@ -1,36 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-project(dxview)
-
-find_package(glfw3 CONFIG REQUIRED)
-find_package(spdlog CONFIG REQUIRED)
-
-add_executable(dxview
-    src/Viewer.h
-    src/Viewer.cc
-    src/dxview.cc
-)
-
-target_include_directories(dxview
-PRIVATE
-    ../../
-)
-
-target_compile_definitions(dxview
-PRIVATE
-    DXVIEW_SWAP_CHAIN_BUFFER_COUNT=3
-    DXVIEW_RES_DIR=L"${PROJECT_SOURCE_DIR}/res"
-)
-
-target_link_libraries(dxview
-PRIVATE
-    dxgi
-    d3dcompiler
-    d3d12
-    glfw
-    spdlog::spdlog
-)
-
-set_target_properties(dxview
-PROPERTIES
-    CXX_STANDARD 17
-)

examples/dxview/README.md

@@ -1,37 +0,0 @@
-# DirectX glTF Viewer
-
-## Overview
-
-This project was motivated by a lack of sample code demonstrating the graphics API agnostic nature of the glTF specification. The sample code is written using modern C++ and DirectX 12 for the client application.
-
-## Features
-
-* [x] DirectX 12
-* [ ] Loader
-* [ ] Animation
-* [ ] Morph Target
-* [ ] Physical Base Rendering
-* [ ] Environment Map
-
-## Dependencies
-
-* [CMake](https://github.com/Kitware/CMake)
-* [Vcpkg](https://github.com/Microsoft/vcpkg)
-* [GLFW](https://github.com/glfw/glfw)
-* [spdlog](https://github.com/gabime/spdlog)
-
-## Building
-
-### Install dependencies
-
-```
-vcpkg install glfw3:x64-windows
-vcpkg install spdlog:x64-windows
-```
-
-### Generate Project Files
-
-```
-mkdir build
-cmake . -B build -DCMAKE_TOOLCHAIN_FILE=${VCPKG_DIR}/script/buildsystem/vcpkg.cmake
-```

examples/dxview/res/gray.hlsl

@@ -1,3 +0,0 @@
-float4 main() : SV_Target {
-    return float4(0.5, 0.5, 0.5, 1.0);
-}

examples/dxview/res/lighting.hlsl

@@ -1,52 +0,0 @@
-struct RS2PS {
-    float4 position : SV_POSITION;
-
-#ifdef HAS_TEXCOORD_0
-    float2 texcoord_0: TEXCOORD_0;
-#endif
-};
-
-struct TextureInfo {
-    uint textureIndex;
-    uint samplerIndex;
-};
-
-struct PBRMetallicRoughness {
-    float4 baseColorFactor;
-    TextureInfo baseColorTexture;
-    float metallicFactor;
-    float roughnessFactor;
-    TextureInfo metallicRoughnessTexture;
-};
-
-cbuffer Material : register(b2) {
-    PBRMetallicRoughness pbrMetallicRoughness;
-};
-
-Texture2D textures[5] : register(t0);
-SamplerState samplerState[5] : register(s0);
-
-float4 getBaseColor(float2 uv) {
-    float4 baseColor = pbrMetallicRoughness.baseColorFactor;
-
-#ifdef HAS_TEXCOORD_0
-    TextureInfo baseColorTexture = pbrMetallicRoughness.baseColorTexture;
-    if (baseColorTexture.textureIndex >= 0) {
-        baseColor *= textures[baseColorTexture.textureIndex].Sample(samplerState[baseColorTexture.samplerIndex], uv);
-    }
-#endif
-
-    return baseColor;
-}
-
-float4 main(RS2PS input) : SV_Target {
-    float2 uv = float2(0.0, 0.0);
-
-#ifdef HAS_TEXCOORD_0
-    uv = input.texcoord_0;
-#endif
-
-    float4 color = getBaseColor(uv);
-
-    return color;
-}

examples/dxview/res/primitive.hlsl

@@ -1,46 +0,0 @@
-struct IA2VS {
-    float3 position  : POSITION;
-
-#ifdef HAS_NORMAL
-    float3 normal : NORMAL;
-#endif
-
-#ifdef HAS_TANGENT
-    float4 tangent : TANGENT;
-#endif
-
-#ifdef HAS_TEXCOORD_0
-    float2 texcoord_0: TEXCOORD_0;
-#endif
-};
-
-struct VS2RS {
-    float4 position : SV_POSITION;
-
-#ifdef HAS_TEXCOORD_0
-    float2 texcoord_0: TEXCOORD_0;
-#endif
-};
-
-cbuffer Camera : register(b0) {
-    float4x4 V;
-    float4x4 P;
-    float4x4 VP;
-};
-
-cbuffer Node : register(b1) {
-    float4x4 M;
-};
-
-VS2RS main(IA2VS input) {
-    VS2RS output;
-    output.position = mul(float4(input.position, 1.0), M);
-    output.position = mul(output.position, V);
-    output.position = mul(output.position, P);
-
-#ifdef HAS_TEXCOORD_0
-    output.texcoord_0 = input.texcoord_0;
-#endif
-
-    return output;
-}

examples/dxview/src/Viewer.h

@@ -1,130 +0,0 @@
-#ifndef DXVIEW_VIEWER_GUARD
-#define DXVIEW_VIEWER_GUARD
-
-#include <DirectXMath.h>
-#include <d3d12.h>
-#include <dxgi1_6.h>
-#include <tiny_gltf.h>
-#include <wrl.h>
-
-#include <filesystem>
-#include <map>
-#include <string>
-#include <vector>
-
-using Microsoft::WRL::ComPtr;
-
-enum RenderPassType { RENDER_PASS_TYPE_PRESENT = 0, RENDER_PASS_TYPE_COUNT };
-
-struct RenderTarget {
-  ComPtr<ID3D12Resource> pTexture;
-  D3D12_CPU_DESCRIPTOR_HANDLE viewDescriptor;
-};
-
-struct TextureInfo {
-  int32_t textureIndex;
-  int32_t samplerIndex;
-};
-
-struct PBRMetallicRoughness {
-  DirectX::XMFLOAT4 baseColorFactor;
-  TextureInfo baseColorTexture;
-  float metallicFactor;
-  float roughnessFactor;
-  TextureInfo metallicRoughnessTexture;
-};
-
-struct Material {
-  std::string name;
-  D3D12_BLEND_DESC blendDesc;
-  D3D12_RASTERIZER_DESC rasterizerDesc;
-  ComPtr<ID3D12Resource> pBuffer;
-  void* pBufferData;
-  ComPtr<ID3D12DescriptorHeap> pSRVDescriptorHeap;
-  ComPtr<ID3D12DescriptorHeap> pSamplerDescriptorHeap;
-};
-
-struct Attribute {
-  std::string name;
-  DXGI_FORMAT format;
-  D3D12_VERTEX_BUFFER_VIEW vertexBufferView;
-};
-
-struct Primitive {
-  std::vector<Attribute> attributes;
-  uint32_t vertexCount;
-  D3D12_PRIMITIVE_TOPOLOGY primitiveTopology;
-  D3D12_INDEX_BUFFER_VIEW indexBufferView;
-  uint32_t indexCount;
-  Material* pMaterial;
-  ComPtr<ID3D12RootSignature> pRootSignature;
-  ComPtr<ID3D12PipelineState> pPipelineState;
-};
-
-struct Mesh {
-  std::string name;
-  std::vector<Primitive> primitives;
-};
-
-struct Node {
-  DirectX::XMFLOAT4X4 M;
-};
-
-struct Camera {
-  DirectX::XMFLOAT4X4 V;
-  DirectX::XMFLOAT4X4 P;
-  DirectX::XMFLOAT4X4 VP;
-};
-
-class Viewer {
- public:
-  Viewer(HWND window, tinygltf::Model* pModel);
-
-  void update(double deltaTime);
-  void render(double deltaTime);
-
- private:
-  void initDirectX(HWND window);
-  void buildRenderTargets();
-  void buildResources();
-  void buildBuffers(std::vector<ComPtr<ID3D12Resource> >* pStagingResources);
-  void buildImages(std::vector<ComPtr<ID3D12Resource> >* pStagingResources);
-  void buildSamplerDescs();
-  void buildMaterials();
-  void buildMeshes();
-  void buildNodes();
-
-  void drawNode(uint64_t nodeIndex);
-
- private:
-  tinygltf::Model* pModel_;
-  ComPtr<IDXGIFactory1> pFactory_;
-  ComPtr<IDXGIAdapter1> pAdapter_;
-  ComPtr<ID3D12Device> pDevice_;
-  ComPtr<ID3D12CommandQueue> pDirectCommandQueue_;
-  UINT64 directFenceValue_;
-  ComPtr<ID3D12Fence> pDirectFence_;
-  ComPtr<ID3D12CommandQueue> pCopyCommandQueue_;
-  UINT64 copyFenceValue_;
-  ComPtr<ID3D12Fence> pCopyFence_;
-  ComPtr<IDXGISwapChain3> pSwapChain_;
-  ComPtr<ID3D12Resource> pSwapChainBuffers_[DXVIEW_SWAP_CHAIN_BUFFER_COUNT];
-  ComPtr<ID3D12CommandAllocator>
-      pDirectCommandAllocators_[DXVIEW_SWAP_CHAIN_BUFFER_COUNT];
-  ComPtr<ID3D12GraphicsCommandList> pDirectCommandList_;
-  ComPtr<ID3D12CommandAllocator> pCopyCommandAllocator_;
-  ComPtr<ID3D12GraphicsCommandList> pCopyCommandList_;
-  UINT descriptorIncrementSize_[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES];
-  ComPtr<ID3D12DescriptorHeap>
-      pRTVDescriptorHeaps_[DXVIEW_SWAP_CHAIN_BUFFER_COUNT];
-  std::vector<RenderTarget> renderTargets_[DXVIEW_SWAP_CHAIN_BUFFER_COUNT];
-  std::vector<ComPtr<ID3D12Resource> > pBuffers_;
-  std::vector<ComPtr<ID3D12Resource> > pTextures_;
-  std::vector<D3D12_SAMPLER_DESC> samplerDescs_;
-  std::vector<Material> materials_;
-  std::vector<Mesh> meshes_;
-  std::vector<ComPtr<ID3D12Resource> > pNodeBuffers_;
-  ComPtr<ID3D12Resource> pCameraBuffer_;
-};
-
-#endif

examples/dxview/src/dxview.cc

@@ -1,90 +0,0 @@
-#define GLFW_EXPOSE_NATIVE_WIN32
-#define TINYGLTF_IMPLEMENTATION
-#define STBI_MSC_SECURE_CRT
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-
-#include <GLFW/glfw3.h>
-#include <GLFW/glfw3native.h>
-#include <spdlog/spdlog.h>
-#include <tiny_gltf.h>
-
-#undef GLFW_EXPOSE_NATIVE_WIN32
-#undef TINYGLTF_IMPLEMENTATION
-#undef STBI_MSC_SECURE_CRT
-#undef STB_IMAGE_IMPLEMENTATION
-#undef STB_IMAGE_WRITE_IMPLEMENTATION
-
-#include <iostream>
-#include <string>
-
-#include "Viewer.h"
-
-static void onError(int error, const char* message) {
-  spdlog::error("[{}] {}", error, message);
-}
-
-static void onRender(Viewer* pViewer, double deltaTime) {
-  pViewer->update(deltaTime);
-  pViewer->render(deltaTime);
-}
-
-int main(int argc, char* argv[]) {
-  tinygltf::TinyGLTF context;
-
-  tinygltf::Model model;
-  std::string error;
-  std::string warning;
-  if (!context.LoadASCIIFromFile(&model, &error, &warning, argv[1])) {
-    if (!error.empty()) {
-      spdlog::error("{}", error);
-    }
-
-    if (!warning.empty()) {
-      spdlog::warn("{}", warning);
-    }
-
-    exit(EXIT_FAILURE);
-  }
-
-  GLFWwindow* pWindow;
-
-  glfwSetErrorCallback(onError);
-
-  if (!glfwInit()) {
-    spdlog::error("Fail to initialize GLFW!!!");
-    exit(EXIT_FAILURE);
-  }
-
-  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
-  glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
-
-  pWindow = glfwCreateWindow(512, 512, "dxview", nullptr, nullptr);
-  if (!pWindow) {
-    spdlog::error("Fail to create GLFWwindow!!!");
-    glfwTerminate();
-    exit(EXIT_FAILURE);
-  }
-
-  auto pViewer = std::make_unique<Viewer>(glfwGetWin32Window(pWindow), &model);
-  if (!pViewer) {
-    spdlog::error("Fail to create Viewer");
-    glfwDestroyWindow(pWindow);
-    glfwTerminate();
-    exit(EXIT_FAILURE);
-  }
-
-  auto prevTimeStamp = glfwGetTime();
-  while (!glfwWindowShouldClose(pWindow)) {
-    auto currTimeStamp = glfwGetTime();
-
-    onRender(pViewer.get(), currTimeStamp - prevTimeStamp);
-    prevTimeStamp = currTimeStamp;
-
-    glfwPollEvents();
-  }
-
-  glfwDestroyWindow(pWindow);
-  glfwTerminate();
-  exit(EXIT_SUCCESS);
-}

examples/glview/CMakeLists.txt

@@ -29,7 +29,7 @@ if (DEFINED DRACO_DIR)
     # TODO(syoyo): better CMake script for draco
     add_definitions(-DTINYGLTF_ENABLE_DRACO)
     include_directories(${DRACO_DIR}/include)
-
+  
     link_directories(${DRACO_DIR}/lib)
     set(DRACO_LIBRARY draco)
   endif ()
@@ -49,9 +49,9 @@ add_executable(glview
   )
 
 target_link_libraries ( glview
-  ${DRACO_LIBRARY}
+  ${DRACO_LIBRARY} 
   ${GLFW3_UNIX_LINK_LIBRARIES}
-  ${GLEW_LIBRARIES}
+  ${GLEW_LIBRARY}
   ${GLFW3_glfw_LIBRARY}
   ${OPENGL_gl_LIBRARY}
   ${OPENGL_glu_LIBRARY}

examples/glview/glview.cc

@@ -771,30 +771,6 @@ static void DrawCurves(tinygltf::Scene &scene, const tinygltf::Mesh &mesh) {
 }
 #endif
 
-static void QuatToAngleAxis(const std::vector<double> quaternion,
-			    double &outAngleDegrees,
-			    double *axis) {
-  double qx = quaternion[0];
-  double qy = quaternion[1];
-  double qz = quaternion[2];
-  double qw = quaternion[3];
-  
-  double angleRadians = 2 * acos(qw);
-  if (angleRadians == 0.0) {
-    outAngleDegrees = 0.0;
-    axis[0] = 0.0;
-    axis[1] = 0.0;
-    axis[2] = 1.0;
-    return;
-  }
-
-  double denom = sqrt(1-qw*qw);
-  outAngleDegrees = angleRadians * 180.0 / M_PI;
-  axis[0] = qx / denom;
-  axis[1] = qy / denom;
-  axis[2] = qz / denom;
-}
-
 // Hierarchically draw nodes
 static void DrawNode(tinygltf::Model &model, const tinygltf::Node &node) {
   // Apply xform
@@ -805,22 +781,18 @@ static void DrawNode(tinygltf::Model &model, const tinygltf::Node &node) {
     glMultMatrixd(node.matrix.data());
   } else {
     // Assume Trans x Rotate x Scale order
+    if (node.scale.size() == 3) {
+      glScaled(node.scale[0], node.scale[1], node.scale[2]);
+    }
+
+    if (node.rotation.size() == 4) {
+      glRotated(node.rotation[0], node.rotation[1], node.rotation[2],
+                node.rotation[3]);
+    }
+
     if (node.translation.size() == 3) {
       glTranslated(node.translation[0], node.translation[1],
                    node.translation[2]);
-    }    
-
-    if (node.rotation.size() == 4) {
-      double angleDegrees;
-      double axis[3];
-
-      QuatToAngleAxis(node.rotation, angleDegrees, axis);
-      
-      glRotated(angleDegrees, axis[0], axis[1], axis[2]);
-    }
-
-    if (node.scale.size() == 3) {
-      glScaled(node.scale[0], node.scale[1], node.scale[2]);
     }
   }
 

examples/mesh-conv/Makefile

@@ -0,0 +1,5 @@
+#EXTRA_CXXFLAGS := -fsanitize=address -fno-omit-frame-pointer -Wall -Werror -Weverything -Wno-c++11-long-long -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-padded
+EXTRA_CXXFLAGS :=
+
+all:
+	clang++ -std=c++11 -g -O1 -I../../ -I../common $(EXTRA_CXXFLAGS) -o mesh-conv mesh-conv.cc mesh-util.cc tinygltf_impl.cc

examples/mesh-conv/Makefile.meson

@@ -0,0 +1,5 @@
+all:
+	ninja
+
+clean:
+	ninja -t clean

examples/mesh-conv/README.md

@@ -0,0 +1,58 @@
+# Mesh modify experiment
+
+Sometimes we want to tweak mesh attributes(e.g. vertex position, uv coord, etc).
+glTF itself does not allow ASCII representation of such data so we need to write a converter.
+
+This example show how to
+
+- Export mesh data from .bin to .obj
+- Import mesh data to .bin(update corresponding buffer data) from .obj
+
+## Features
+
+* Support skin weights(`JOINTS_N`, `WEIGHTS_N`)
+
+## Supported attributes
+
+* [x] POSITION
+* [x] NORMAL
+* [x] TANGENT
+* [ ] COLOR  (vertex color)
+* [x] TEXCOORD_N
+  * Only single texcoord(uv set) is supported
+  * Specify `--uvset 1` to specify which UV to use.
+* [x] WEIGHTS_N, JOINTS_N
+
+## Usage
+
+### Wavefront .obj to glTF
+
+```
+$ mesh-modify --op=obj2gltf input.obj
+```
+
+All shapes in .obj are concatenated and create single glTF mesh.
+(tinyobjloader's skin weight extension `vw` supported)
+
+#### Limitation
+
+Buffer is stored as external file(`.bin`)
+
+### glTF to Wavefront .obj
+
+```
+$ mesh-modify --op=gltf2obj input.gltf
+```
+
+.obj will be created for each glTF Mesh.
+(Skin weight data is exported to .obj using tinyobjloader's skin weight extension `vw`)
+
+#### Limitation
+
+Buffer is stored as external file(`.bin`)
+
+## TODO
+
+* [ ] obj2gltf: Assign glTF material from .mtl
+* [ ] modify/patch mesh geometry in glTF
+  * By using JSON Patch or JSON Merge feature

examples/mesh-conv/bootstrap-meson.sh

@@ -0,0 +1,3 @@
+rm -rf build
+CXX=clang++ CC=clang meson build -Db_sanitize=address -Db_lundef=false --buildtype=debug
+cp Makefile.meson build/Makefile

examples/mesh-conv/mesh-conv.cc

@@ -0,0 +1,798 @@
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <string>
+#include <vector>
+
+#if !defined(__ANDROID__) && !defined(_WIN32)
+#include <wordexp.h>
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Weverything"
+#endif
+
+#include "../../json.hpp"
+#include "../common/clipp.h"
+
+using json = nlohmann::json;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef _WIN32
+#include "../../tiny_gltf.h"
+#else
+#include "tiny_gltf.h"
+#endif
+
+#include "mesh-util.hh"
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace {
+
+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
+// TODO(syoyo): Support sparse accessor(sparse vertex attribute).
+// TODO(syoyo): Support more data type
+struct VertexAttrib {
+  std::string name;
+
+  // Value are converted to float type.
+  std::vector<float> data;
+
+  // Corresponding info in binary data
+  int data_type;       // e.g. TINYGLTF_TYPE_VEC2
+  int component_type;  // storage type. e.g.
+                       // TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT
+  uint64_t buffer_offset{0};
+  size_t buffer_length{0};
+};
+
+struct MeshPrim {
+  std::string name;
+  int32_t id{-1};
+
+  int mode{TINYGLTF_MODE_TRIANGLES};
+
+  VertexAttrib position;                  // vec3
+  VertexAttrib normal;                    // vec3
+  VertexAttrib tangent;                   // vec4
+  VertexAttrib color;                     // vec3 or vec4
+  std::map<int, VertexAttrib> texcoords;  // <slot, attrib>  vec2
+  std::map<int, VertexAttrib> weights;    // <slot, attrib>
+  std::map<int, VertexAttrib>
+      joints;  // <slot, attrib> store data as float type
+
+  int indices_type{-1}; // storage type(componentType) of `indices`.
+  std::vector<uint32_t> indices; // vertex indices
+};
+#endif
+
+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 size_t ComponentTypeByteSize(int type) {
+  switch (type) {
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
+    case TINYGLTF_COMPONENT_TYPE_BYTE:
+      return sizeof(char);
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
+    case TINYGLTF_COMPONENT_TYPE_SHORT:
+      return sizeof(short);
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
+    case TINYGLTF_COMPONENT_TYPE_INT:
+      return sizeof(int);
+    case TINYGLTF_COMPONENT_TYPE_FLOAT:
+      return sizeof(float);
+    case TINYGLTF_COMPONENT_TYPE_DOUBLE:
+      return sizeof(double);
+    default:
+      return 0;
+  }
+}
+
+std::vector<uint8_t> LoadBin(const std::string &filename) {
+  std::vector<uint8_t> data;
+
+  std::ifstream is(filename, std::ios::binary | std::ios::in | std::ios::ate);
+
+  if (is.is_open()) {
+    size_t size = size_t(is.tellg());
+    is.seekg(0, std::ios::beg);
+    if (size < 4) {
+      std::cerr << "File size is zero or too short: " << size << "\n";
+      return data;
+    }
+
+    data.resize(size);
+    is.read(reinterpret_cast<char *>(data.data()), std::streamsize(size));
+  }
+
+  return data;
+}
+
+// TODO(syoyo): Use C++17 like filesystem library
+
+bool FileExists(const std::string &abs_filename) {
+  bool ret;
+#ifdef _WIN32
+  // TODO(syoyo): Support utf8 filepath
+  FILE *fp = nullptr;
+  errno_t err = fopen_s(&fp, abs_filename.c_str(), "rb");
+  if (err != 0) {
+    return false;
+  }
+#else
+  FILE *fp = fopen(abs_filename.c_str(), "rb");
+#endif
+  if (fp) {
+    ret = true;
+    fclose(fp);
+  } else {
+    ret = false;
+  }
+
+  return ret;
+}
+
+static std::string JoinPath(const std::string &path0,
+                            const std::string &path1) {
+  if (path0.empty()) {
+    return path1;
+  } else {
+    // check '/'
+    char lastChar = *path0.rbegin();
+    if (lastChar != '/') {
+      return path0 + std::string("/") + path1;
+    } else {
+      return path0 + path1;
+    }
+  }
+}
+
+std::string ExpandFilePath(const std::string &filepath) {
+#ifdef _WIN32
+  DWORD len = ExpandEnvironmentStringsA(filepath.c_str(), NULL, 0);
+  char *str = new char[len];
+  ExpandEnvironmentStringsA(filepath.c_str(), str, len);
+
+  std::string s(str);
+
+  delete[] str;
+
+  return s;
+#else
+
+#if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) || \
+    defined(__ANDROID__) || defined(__EMSCRIPTEN__)
+  // no expansion
+  std::string s = filepath;
+#else
+  std::string s;
+  wordexp_t p;
+
+  if (filepath.empty()) {
+    return "";
+  }
+
+  // Quote the string to keep any spaces in filepath intact.
+  std::string quoted_path = "\"" + filepath + "\"";
+  // char** w;
+  int ret = wordexp(quoted_path.c_str(), &p, 0);
+  if (ret) {
+    // err
+    s = filepath;
+    return s;
+  }
+
+  // Use first element only.
+  if (p.we_wordv) {
+    s = std::string(p.we_wordv[0]);
+    wordfree(&p);
+  } else {
+    s = filepath;
+  }
+
+#endif
+
+  return s;
+#endif
+}
+
+static std::string FindFile(const std::vector<std::string> &paths,
+                            const std::string &filepath) {
+  for (size_t i = 0; i < paths.size(); i++) {
+    std::string absPath = ExpandFilePath(JoinPath(paths[i], filepath));
+    if (FileExists(absPath)) {
+      return absPath;
+    }
+  }
+
+  return std::string();
+}
+
+static std::string GetBaseDir(const std::string &filepath) {
+  if (filepath.find_last_of("/\\") != std::string::npos)
+    return filepath.substr(0, filepath.find_last_of("/\\"));
+  return "";
+}
+
+static int GetSlotId(const std::string &name) {
+  if (name.rfind("TEXCOORD_", 0) == 0) {
+    int id = 0;
+    sscanf(name.c_str(), "TEXCOORD_%d", &id);
+    return id;
+  } else if (name.rfind("WEIGHTS_", 0) == 0) {
+    int id = 0;
+    sscanf(name.c_str(), "WEIGHTS_%d", &id);
+    return id;
+  } else if (name.rfind("JOINTS_", 0) == 0) {
+    int id = 0;
+    sscanf(name.c_str(), "JOINTS_%d", &id);
+    return id;
+  }
+
+  return -1;
+}
+
+static bool IsAttributeSupported(const std::string &name) {
+  constexpr int max_slots = 8;
+
+  if (name.compare("POSITION") == 0) {
+    return true;
+  }
+
+  if (name.compare("NORMAL") == 0) {
+    return true;
+  }
+
+  if (name.compare("TANGENT") == 0) {
+    return true;
+  }
+
+  for (int i = 0; i < max_slots; i++) {
+    std::string n = "TEXCOORD_" + std::to_string(i);
+    if (n.compare(name) == 0) {
+      return true;
+    }
+  }
+
+  for (int i = 0; i < max_slots; i++) {
+    std::string n = "WEIGHTS_" + std::to_string(i);
+    if (n.compare(name) == 0) {
+      return true;
+    }
+  }
+
+  for (int i = 0; i < max_slots; i++) {
+    std::string n = "JOINTS_" + std::to_string(i);
+    if (n.compare(name) == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static float Unpack(const unsigned char *ptr, int type) {
+  if (type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) {
+    unsigned char data = *ptr;
+    return float(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_BYTE) {
+    char data = static_cast<char>(*ptr);
+    return float(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
+    uint16_t data = *reinterpret_cast<const uint16_t *>(ptr);
+    return float(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_SHORT) {
+    int16_t data = *reinterpret_cast<const int16_t *>(ptr);
+    return float(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_FLOAT) {
+    float data = *reinterpret_cast<const float *>(ptr);
+    return data;
+  } else {
+    std::cerr << "???: Unsupported type: " << PrintComponentType(type) << "\n";
+    return 0.0f;
+  }
+}
+
+static uint32_t UnpackIndex(const unsigned char *ptr, int type) {
+  if (type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) {
+    unsigned char data = *ptr;
+    return uint32_t(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_BYTE) {
+    char data = static_cast<char>(*ptr);
+    return uint32_t(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
+    uint16_t data = *reinterpret_cast<const uint16_t *>(ptr);
+    return uint32_t(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_SHORT) {
+    int16_t data = *reinterpret_cast<const int16_t *>(ptr);
+    return uint32_t(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_INT) {
+    // TODO(syoyo): Check overflow(2G+ index)
+    int32_t data = *reinterpret_cast<const int32_t *>(ptr);
+    return uint32_t(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) {
+    uint32_t data = *reinterpret_cast<const uint32_t *>(ptr);
+    return uint32_t(data);
+  } else if (type == TINYGLTF_COMPONENT_TYPE_SHORT) {
+    uint32_t data = *reinterpret_cast<const uint32_t *>(ptr);
+    return data;
+  } else {
+    std::cerr << "???: Unsupported type: " << PrintComponentType(type) << "\n";
+    return static_cast<uint32_t>(-1);
+  }
+}
+
+static bool DumpMesh(const tinygltf::Model &model, const tinygltf::Mesh &mesh,
+                     bool verbose, example::MeshPrim *out) {
+  out->prims.clear();
+
+  for (size_t i = 0; i < mesh.primitives.size(); i++) {
+    const tinygltf::Primitive &primitive = mesh.primitives[i];
+
+    if (primitive.indices < 0) {
+      std::cerr << "Primitive indices must be provided\n";
+      return false;
+    }
+
+    example::PrimSet out_prim;
+
+    // indices.
+    {
+      const tinygltf::Accessor &indexAccessor =
+          model.accessors[size_t(primitive.indices)];
+
+      size_t num_elements = indexAccessor.count;
+      std::cout << "index.elements = " << num_elements << "\n";
+
+      size_t byte_stride = ComponentTypeByteSize(indexAccessor.componentType);
+
+      const tinygltf::BufferView &indexBufferView =
+          model.bufferViews[size_t(indexAccessor.bufferView)];
+
+      // should be 34963(ELEMENT_ARRAY_BUFFER)
+      std::cout << "index.target = " << PrintTarget(indexBufferView.target)
+                << "\n";
+      if (indexBufferView.target != TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER) {
+        std::cerr << "indexBufferView.target must be ELEMENT_ARRAY_BUFFER\n";
+        return false;
+      }
+
+      const tinygltf::Buffer &indexBuffer =
+          model.buffers[size_t(indexBufferView.buffer)];
+
+      std::vector<uint32_t> indices;
+
+      for (size_t k = 0; k < num_elements; k++) {
+        // TODO(syoyo): out-of-bounds check.
+        const unsigned char *ptr = indexBuffer.data.data() +
+                                   indexBufferView.byteOffset +
+                                   (k * byte_stride) + indexAccessor.byteOffset;
+
+        uint32_t idx = UnpackIndex(ptr, indexAccessor.componentType);
+
+        if (verbose) {
+          std::cout << "vertex_index[" << k << "] = " << idx << "\n";
+        }
+
+        indices.push_back(idx);
+      }
+
+      out_prim.indices = indices;
+      out_prim.indices_type = indexAccessor.componentType;
+    }
+
+    // attributes
+    {
+      std::map<std::string, int>::const_iterator it(
+          primitive.attributes.begin());
+      std::map<std::string, int>::const_iterator itEnd(
+          primitive.attributes.end());
+
+      for (; it != itEnd; it++) {
+        // it->first would be "POSITION", "NORMAL", "TEXCOORD_0", ...
+        if (!IsAttributeSupported(it->first)) {
+          std::cout << "Unsupported attribute: " << it->first << "\n";
+          continue;
+        }
+
+        if (size_t(it->second) >= model.accessors.size()) {
+          std::cerr << "Invalid accessor id: " << it->second << "\n";
+          return false;
+        }
+
+        const tinygltf::Accessor &accessor =
+            model.accessors[size_t(it->second)];
+
+        size_t elem_size = 1;
+        if (accessor.type == TINYGLTF_TYPE_SCALAR) {
+          elem_size = 1;
+        } else if (accessor.type == TINYGLTF_TYPE_VEC2) {
+          elem_size = 2;
+        } else if (accessor.type == TINYGLTF_TYPE_VEC3) {
+          elem_size = 3;
+        } else if (accessor.type == TINYGLTF_TYPE_VEC4) {
+          elem_size = 4;
+        } else {
+          std::cerr << "Invalid or unsupported accessor type: "
+                    << PrintType(accessor.type) << "\n";
+          return false;
+        }
+
+        std::cout << PrintComponentType(accessor.componentType) << "\n";
+
+        size_t byte_stride = ComponentTypeByteSize(accessor.componentType);
+
+        std::cout << "attribute: " << it->first << "\n";
+        // if (gGLProgramState.attribs[it->first] >= 0) {
+        // Compute byteStride from Accessor + BufferView combination.
+        int byteStride =
+            accessor.ByteStride(model.bufferViews[size_t(accessor.bufferView)]);
+        assert(byteStride != -1);
+
+        std::cout << "byteOffset: " << accessor.byteOffset << "\n";
+
+        const tinygltf::BufferView &bufferView =
+            model.bufferViews[size_t(accessor.bufferView)];
+        const tinygltf::Buffer &buffer =
+            model.buffers[size_t(bufferView.buffer)];
+
+        size_t num_elems = accessor.count * elem_size;
+
+        example::VertexAttrib attrib;
+        for (size_t k = 0; k < num_elems; k++) {
+          // TODO(syoyo): out-of-bounds check.
+          const unsigned char *ptr = buffer.data.data() +
+                                     bufferView.byteOffset + (k * byte_stride) +
+                                     accessor.byteOffset;
+          float value = Unpack(ptr, accessor.componentType);
+          if (verbose) {
+            std::cout << "[" << k << "] value = " << value << "\n";
+          }
+          attrib.data.push_back(value);
+        }
+        attrib.component_type = accessor.componentType;
+        attrib.data_type = accessor.type;
+        attrib.name = it->first;
+
+        if (attrib.name.compare("POSITION") == 0) {
+          out_prim.position = attrib;
+        } else if (attrib.name.compare("NORMAL") == 0) {
+          out_prim.normal = attrib;
+        } else if (attrib.name.compare("TANGENT") == 0) {
+          out_prim.tangent = attrib;
+        } else if (attrib.name.rfind("TEXCOORD_", 0) == 0) {
+          int id = GetSlotId(attrib.name);
+          std::cout << "texcoord[" << id << "]\n";
+          out_prim.texcoords[id] = attrib;
+        } else if (attrib.name.rfind("JOINTS_", 0) == 0) {
+          int id = GetSlotId(attrib.name);
+          std::cout << "joints[" << id << "]\n";
+          out_prim.joints[id] = attrib;
+        } else if (attrib.name.rfind("WEIGHTS_", 0) == 0) {
+          int id = GetSlotId(attrib.name);
+          std::cout << "weights[" << id << "]\n";
+          out_prim.weights[id] = attrib;
+        } else {
+          std::cerr << "???: attrib.name = " << attrib.name << "\n";
+          return false;
+        }
+      }
+    }
+
+    const tinygltf::Accessor &indexAccessor =
+        model.accessors[size_t(primitive.indices)];
+    (void)indexAccessor;
+    PrintMode(primitive.mode);
+    if (primitive.mode != TINYGLTF_MODE_TRIANGLES) {
+      std::cerr << "Supported Primitive mode is TRIANGLES only at the moment\n";
+      return false;
+    }
+
+    out_prim.mode = primitive.mode;
+
+    out->prims.push_back(out_prim);
+  }
+
+  out->name = mesh.name;
+
+  return true;
+}
+
+static bool ExtractMesh(const std::string &asset_path, tinygltf::Model &model,
+                        bool verbose, std::vector<example::MeshPrim> *outs) {
+  // Get .bin data
+  {
+    if (model.buffers.size() != 1) {
+      std::cerr << "Single element of `buffers` is supported at the moment.\n";
+      return false;
+    }
+
+    const tinygltf::Buffer &buffer = model.buffers[0];
+    if (buffer.uri.empty()) {
+      std::cerr << "buffer.uri must be a filepath.\n";
+      return false;
+    }
+
+    if (buffer.data.size() < 4) {
+      std::cerr << "Invalid buffer.byteLength.\n";
+      return false;
+    }
+
+    std::vector<std::string> search_paths;
+    search_paths.push_back(asset_path);
+
+    std::string abs_filepath = FindFile(search_paths, buffer.uri);
+    std::vector<uint8_t> bin = LoadBin(abs_filepath);
+    if (bin.size() != buffer.data.size()) {
+      std::cerr << "Byte size mismatch. Failed to load file: " << buffer.uri
+                << "\n";
+      std::cerr << "  Searched absolute file path: " << abs_filepath << "\n";
+      std::cerr << "  .bin size = " << bin.size()
+                << ", size in 'buffer.uri' = " << buffer.data.size() << "\n";
+      return false;
+    }
+  }
+
+  for (const auto &mesh : model.meshes) {
+    std::cout << "mesh.name: " << mesh.name << "\n";
+
+    example::MeshPrim output;
+    bool ret = DumpMesh(model, mesh, verbose, &output);
+    if (!ret) {
+      return false;
+    }
+
+    outs->push_back(output);
+  }
+
+  return true;
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  std::string op;
+  std::string input_filename;
+  std::string output_filename = "output.gltf";
+  int uvset = 0;
+  bool verbose = false;
+  bool export_skinweight = true;
+  bool no_flip_texcoord_y = false;
+
+  auto cli =
+      (clipp::required("-i", "--input") &
+           clipp::value("input filename", input_filename),
+       clipp::option("-o", "--outout") &
+           clipp::value("Output filename(obj2fltf)", output_filename),
+       clipp::option("-v", "--verbose").set(verbose).doc("Verbose output"),
+       clipp::option("--export_skinweight") &
+           clipp::value("Export skin weights(gltf2obj). default true.",
+                        export_skinweight),
+       clipp::option("--uvset").set(uvset).doc("UV set(TEXCOORD_N) to use"),
+       clipp::option("--op") &
+           clipp::value("operation mode(`gltf2obj`, `obj2gltf`", op),
+       clipp::option("--no-flip-texcoord-y")
+           .set(no_flip_texcoord_y)
+           .doc("Do not flip texcoord Y"));
+
+  if (!clipp::parse(argc, argv, cli)) {
+    std::cout << clipp::make_man_page(cli, argv[0]);
+    return EXIT_FAILURE;
+  }
+
+  if (op == "gltf2obj") {
+    tinygltf::Model model;
+    tinygltf::TinyGLTF loader;
+    std::string err;
+    std::string warn;
+
+    std::string ext = GetFilePathExtension(input_filename);
+
+    {
+      bool ret = false;
+      if (ext.compare("glb") == 0) {
+        // assume binary glTF.
+        ret = loader.LoadBinaryFromFile(&model, &err, &warn,
+                                        input_filename.c_str());
+      } else {
+        // assume ascii glTF.
+        ret = loader.LoadASCIIFromFile(&model, &err, &warn,
+                                       input_filename.c_str());
+      }
+
+      if (!warn.empty()) {
+        printf("Warn: %s\n", warn.c_str());
+      }
+
+      if (!err.empty()) {
+        printf("ERR: %s\n", err.c_str());
+      }
+      if (!ret) {
+        printf("Failed to load .glTF : %s\n", argv[1]);
+        exit(-1);
+      }
+    }
+
+#if 0
+    json j;
+    {
+      std::ifstream i(input_filename);
+      i >> j;
+    }
+    std::cout << "j = " << j << "\n";
+
+    json j_patch = R"([
+      { "op": "add", "path": "/buffers/-", "value": {
+              "name": "plane/data",
+              "byteLength": 480,
+              "uri": "plane1.bin"
+          } }
+    ])"_json;
+
+    // a JSON value
+    json j_original = R"({
+      "baz": ["one", "two", "three"],
+      "foo": "bar"
+  })"_json;
+
+    //json j_patch = R"([
+    //  { "op": "remove", "path": "/buffers" }
+    //])"_json;
+
+    std::cout << "patch = " << j_patch.dump(2) << "\n";
+
+  json j_ret = j.patch(j_patch);
+  std::cout << "patched = " << j_ret.dump(2) << "\n";
+#endif
+
+    std::string basedir = GetBaseDir(input_filename);
+    std::vector<example::MeshPrim> meshes;
+    bool ret = ExtractMesh(basedir, model, verbose, &meshes);
+
+    size_t n = 0;
+    for (const auto &mesh : meshes) {
+      // Assume no duplicated name in .glTF data
+      std::string basename;
+      if (mesh.name.empty()) {
+        basename = "untitled-" + std::to_string(n);
+      } else {
+        basename = mesh.name;
+      }
+
+
+      for (size_t primid = 0; primid < mesh.prims.size(); primid++) {
+        example::ObjExportOption options;
+        options.primid = int(primid);
+        options.export_skinweights = export_skinweight;
+        options.uvset = uvset;
+        options.flip_texcoord_y = !no_flip_texcoord_y;
+
+        bool ok = example::SaveAsObjMesh(basename, mesh, options);
+        if (!ok) {
+          std::cout << "Failed to export mesh[" << mesh.name << "].primitives["
+                    << primid << "]\n";
+          // may ok;
+        }
+      }
+      n++;
+    }
+
+    return ret ? EXIT_SUCCESS : EXIT_FAILURE;
+  } else if (op == "obj2gltf") {
+    // Require facevarying layout?
+    // facevarying representation is required if a vertex can have multiple
+    // normal/uv value. drawback of facevarying is mesh data increases. false =
+    // try to keep shared vertex representation as much as possible. true =
+    // reorder vertex data and re-assign vertex indices for facevarying data
+    // layout.
+    bool facevarying = false;
+
+    example::MeshPrim mesh;
+    bool ok = example::LoadObjMesh(input_filename, facevarying, &mesh);
+    if (!ok) {
+      return EXIT_FAILURE;
+    }
+
+    if (verbose) {
+      PrintMeshPrim(mesh);
+    }
+
+    ok = example::SaveAsGLTFMesh(output_filename, mesh);
+    if (!ok) {
+      std::cerr << "Failed to save mesh as glTF\n";
+      return EXIT_FAILURE;
+    }
+    std::cout << "Write glTF: " << output_filename << "\n";
+    return EXIT_SUCCESS;
+  } else {
+    std::cerr << "Unknown operation: " << op << "\n";
+    return EXIT_FAILURE;
+  }
+}

examples/mesh-conv/mesh-util.hh

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <vector>
+#include <map>
+
+namespace example {
+
+// TODO(syoyo): Support sparse accessor(sparse vertex attribute).
+// TODO(syoyo): Support more data type
+struct VertexAttrib {
+  std::string name;
+
+  // Value are converted to float type.
+  std::vector<float> data;
+
+  // Corresponding info in binary data
+  int data_type;       // e.g. TINYGLTF_TYPE_VEC2
+  int component_type;  // storage type. e.g.
+                       // TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT
+  uint64_t buffer_offset{0};
+  size_t buffer_length{0};
+
+  // Optional.
+  std::vector<double> minValues;
+  std::vector<double> maxValues;
+
+  size_t numElements() const;
+
+};
+
+struct PrimSet {
+
+  int mode; // e.g. TRIANGLES
+
+  VertexAttrib position;                  // vec3
+  VertexAttrib normal;                    // vec3
+  VertexAttrib tangent;                   // vec4
+  VertexAttrib color;                     // vec3 or vec4
+  std::map<int, VertexAttrib> texcoords;  // <slot, attrib>  vec2
+  std::map<int, VertexAttrib> weights;    // <slot, attrib>  vec4
+  std::map<int, VertexAttrib>
+      joints;  // <slot, attrib> store data as float type
+
+
+  // min/max of index value. -1 = undef
+  int indices_min{-1};
+  int indices_max{-1};
+  int indices_type{-1}; // storage type(componentType) of `indices`.
+  std::vector<uint32_t> indices; // vertex indices
+
+};
+
+struct MeshPrim {
+  std::string name;
+  int32_t id{-1};
+
+  std::vector<PrimSet> prims;
+
+};
+
+struct ObjExportOption
+{
+  bool export_skinweights{true};
+  int primid{0}; /// Primitive id to export(default 0).
+  int uvset{0}; /// Tex coord ID to export(default 0).
+  bool flip_texcoord_y{true}; /// Flip texture coordinate V?(default true).
+};
+
+///
+/// Save MeshPrim as wavefront .obj
+///
+/// @param[in] basename Base filename. ".obj" will be appended.
+/// @param[in] mesh MeshPrim.
+/// @param[in] option Export options
+///
+bool SaveAsObjMesh(const std::string &basename, const MeshPrim &mesh, const ObjExportOption &option);
+
+//
+/// Save MeshPrim as glTF mesh
+///
+bool SaveAsGLTFMesh(const std::string &filename, const MeshPrim &mesh);
+
+///
+/// Loads .obj and convert to MeshPrim
+///
+/// @param[in] facevarying Construct mesh with facevarying vertex layout(default false)
+///
+bool LoadObjMesh(const std::string &filename, bool facevarying, MeshPrim *mesh);
+
+///
+/// Print MeshPrim datra
+///
+void PrintMeshPrim(const MeshPrim &mesh);
+
+} // namespace example

examples/mesh-conv/meson.build

@@ -0,0 +1,7 @@
+project('mesh-conv', 'cpp', default_options : ['cpp_std=c++11'])
+
+thread_dep = dependency('threads')
+
+incdir = include_directories(['../../', '../common'])
+
+executable('mesh-conv', ['mesh-conv.cc', 'mesh-util.cc', 'tinygltf_impl.cc'], include_directories : incdir, dependencies : thread_dep)

examples/mesh-conv/sandbox/README.md

@@ -0,0 +1,27 @@
+# concat_mesh.py
+
+Append(merge) mesh of glTF A to glTF B.
+
+`meshes`, `accessors`, `bufferViews`, `materials` of glTF A is appended to glTF B(index to accessor, bufferViews, etc will be recomputed).
+
+`skin`, `nodes`, etc are not appended(to be merged).
+
+## Usage
+
+concatenate sourceN.gltf to target.gltf and save it to merged.gltf
+
+```
+$ python concat_mesh.py source0.gltf <source1.gltf source2.gltf ...> target.gltf merged.gltf
+```
+
+## TODO
+
+* [x] Support multiple glTFs to merge(concat)
+* [ ] Support merging skin
+* [ ] Support merging different node hierarchies
+* [x] Support `images`, `textures`, `materials`, `samplers`
+* [ ] Support other glTF info
+
+# replace_attrib.py
+
+Replace the accessor id of specified attribute.

examples/mesh-conv/sandbox/concat_mesh.py

@@ -0,0 +1,272 @@
+# concat mesh to glTF
+# support multiple source glTF to me concatenated to target.gltf
+
+# TODO: skins, nodes, scenes
+
+import json
+import sys, os
+
+g_prefix = "added/"
+
+def adjustMaterialTextureIndex(mat, texture_index_offset):
+    # Args: mat(dict)
+    # texture_index_offset(int) Index offset
+
+    if "normalTexture" in mat:
+        if "index" in mat["normalTexture"]:
+            mat["normalTexture"]["index"] += texture_index_offset
+
+    if "occlusionTexture" in mat:
+        if "index" in mat["occlusionTexture"]:
+            mat["occlusionTexture"]["index"] += texture_index_offset
+
+    if "emissiveTexture" in mat:
+        if "index" in mat["emissiveTexture"]:
+            mat["emissiveTexture"]["index"] += texture_index_offset
+
+    if "pbrMetallicRoughness" in mat:
+        if "baseColorTexture" in mat["pbrMetallicRoughness"]:
+            if "index" in mat["pbrMetallicRoughness"]["baseColorTexture"]:
+                mat["pbrMetallicRoughness"]["baseColorTexture"]["index"] += texture_index_offset
+
+        if "metallicRoughnessTexture" in mat["pbrMetallicRoughness"]:
+            if "index" in mat["pbrMetallicRoughness"]["metallicRoughnessTexture"]:
+                mat["pbrMetallicRoughness"]["metallicRoughnessTexture"]["index"] += texture_index_offset
+
+    return mat
+
+
+def concat(source, target, offsets, prefix, extraInfo):
+    # Args:
+    # source: dict(modified), target: dict(modified),
+    # offsets: dict(modified). contains offset table.
+    # prefix: str
+    # extraInfo: dict(inout)
+
+    num_source_meshes = len(source["meshes"])
+    num_source_buffers = len(source["buffers"])
+    num_source_bufferViews = len(source["bufferViews"])
+    num_source_accessors = len(source["accessors"])
+    num_source_materials = len(source["materials"]) if "materials" in source else 0
+    num_source_samplers = len(source["samplers"]) if "samplers" in source else 0
+    num_source_images = len(source["images"]) if "images" in source else 0
+    num_source_textures = len(source["textures"]) if "textures" in source else 0
+    print("src =====")
+    print("num_src_meshes: ", num_source_meshes)
+    print("num_src_buffers: ", num_source_buffers)
+    print("num_src_bufferViews: ", num_source_bufferViews)
+    print("num_src_accessors: ", num_source_accessors)
+    print("num_src_materials: ", num_source_materials)
+    print("num_src_textures: ", num_source_textures)
+    print("num_src_images: ", num_source_images)
+    print("num_src_samplers: ", num_source_samplers)
+
+
+    #
+    # Modify name and adjust index offset
+    #
+    for i in range(len(source["buffers"])):
+        if "name" in source["buffers"][i]:
+            source["buffers"][i]["name"] = prefix + source["buffers"][i]["name"]
+
+    for i in range(len(source["bufferViews"])):
+        if "name" in source["bufferViews"][i]:
+            source["bufferViews"][i]["name"] = prefix + source["bufferViews"][i]["name"]
+
+        source["bufferViews"][i]["buffer"] += offsets["buffers"]
+
+    for i in range(len(source["accessors"])):
+        if "name" in source["accessors"][i]:
+            source["accessors"][i]["name"] = prefix + source["accessors"][i]["name"]
+
+        source["accessors"][i]["bufferView"] += offsets["bufferViews"]
+
+    for i in range(len(source["meshes"])):
+        mesh = source["meshes"][i]
+
+        if "name" in mesh:
+            source["meshes"][i]["name"] = prefix + source["meshes"][i]["name"]
+
+        for primid in range(len(mesh["primitives"])):
+            for attrib in mesh["primitives"][primid]["attributes"]:
+                #print(source["meshes"][i]["primitives"][primid]["attributes"][attrib])
+                source["meshes"][i]["primitives"][primid]["attributes"][attrib] += offsets["accessors"]
+
+
+            source["meshes"][i]["primitives"][primid]["indices"] += offsets["accessors"]
+            if "material" in source["meshes"][i]["primitives"][primid]:
+                source["meshes"][i]["primitives"][primid]["material"] += offsets["materials"]
+
+
+    if "materials" in source:
+        for i in range(len(source["materials"])):
+            if "name" in source["materials"][i]:
+                source["materials"][i]["name"] = prefix + source["materials"][i]["name"]
+            source["materials"][i] = adjustMaterialTextureIndex(source["materials"][i], offsets["textures"])
+
+    if "images" in source:
+        for i in range(len(source["images"])):
+            if "name" in source["images"][i]:
+                source["images"][i]["name"] = prefix + source["images"][i]["name"]
+
+    if "samplers" in source:
+        for i in range(len(source["samplers"])):
+            if "name" in source["samplers"][i]:
+                source["samplers"][i]["name"] = prefix + source["samplers"][i]["name"]
+
+    if "textures" in source:
+        for i in range(len(source["textures"])):
+            if "name" in source["textures"][i]:
+                source["textures"][i]["name"] = prefix + source["textures"][i]["name"]
+            source["textures"][i]["sampler"] += offsets["samplers"]
+            source["textures"][i]["source"] += offsets["images"]
+
+    #
+    # Append mesh info
+    #
+    target["buffers"] += source["buffers"]
+    target["bufferViews"] += source["bufferViews"]
+    target["meshes"] += source["meshes"]
+    target["accessors"] += source["accessors"]
+    if "materials" in source:
+        if "materials" in target:
+            target["materials"] += source["materials"]
+        else:
+            target["materials"] = source["materials"]
+    if "images" in source:
+        if "images" in target:
+            target["images"] += source["images"]
+        else:
+            target["images"] = source["images"]
+    if "textures" in source:
+        if "textures" in target:
+            target["textures"] += source["textures"]
+        else:
+            target["textures"] = source["textures"]
+    if "samplers" in source:
+        if "samplers" in target:
+            target["samplers"] += source["samplers"]
+        else:
+            target["samplers"] = source["samplers"]
+
+    # assume `prefix` is unique
+    extraInfo["num_{}_meshes".format(prefix)] = num_source_meshes
+    extraInfo["num_{}_buffers".format(prefix)] = num_source_buffers
+    extraInfo["num_{}_bufferViews".format(prefix)] = num_source_bufferViews
+    extraInfo["num_{}_accessors".format(prefix)] = num_source_accessors
+    extraInfo["num_{}_materials".format(prefix)] = num_source_materials
+    extraInfo["num_{}_images".format(prefix)] = num_source_images
+    extraInfo["num_{}_samplers".format(prefix)] = num_source_samplers
+    extraInfo["num_{}_textures".format(prefix)] = num_source_textures
+
+    # update offsets
+    offsets["meshes"] += num_source_meshes
+    offsets["buffers"] += num_source_buffers
+    offsets["bufferViews"] += num_source_bufferViews
+    offsets["accessors"] += num_source_accessors
+    offsets["materials"] += num_source_materials
+    offsets["textures"] += num_source_textures
+    offsets["images"] += num_source_images
+    offsets["samplers"] += num_source_samplers
+
+
+def main():
+    if len(sys.argv) < 4:
+        print("Needs source0.gltf <source1.gltf, ...> target.gltf output.gltf")
+        sys.exit(-1)
+
+    num_args = len(sys.argv)
+    print("num_args = ", num_args)
+
+    source_filenames = []
+
+    num_srcs = num_args - 3
+
+    for i in range(num_srcs):
+        source_filenames.append(sys.argv[1+i])
+        print("source[{}] = {}".format(i, sys.argv[1+i]))
+
+    target_filename = sys.argv[num_args - 2]
+    output_filename = sys.argv[num_args - 1]
+    print("target = ", target_filename)
+    print("output = ", output_filename)
+
+    sources = []
+    for i in range(num_srcs):
+        sources.append(json.loads(open(source_filenames[i]).read()))
+    target = json.loads(open(target_filename).read())
+
+    num_target_meshes = len(target["meshes"])
+    num_target_buffers = len(target["buffers"])
+    num_target_bufferViews = len(target["bufferViews"])
+    num_target_accessors = len(target["accessors"])
+    num_target_materials = 0
+    if "materials" in target:
+        num_target_materials = len(target["materials"])
+
+    num_target_images = 0
+    if "images" in target:
+        num_target_images = len(target["images"])
+
+    num_target_samplers = 0
+    if "samplers" in target:
+        num_target_samplers = len(target["samplers"])
+
+    num_target_textures = 0
+    if "textures" in target:
+        num_target_textures = len(target["textures"])
+
+    print("num_target_meshes: ", num_target_meshes)
+    print("num_target_buffers: ", num_target_buffers)
+    print("num_target_bufferViews: ", num_target_bufferViews)
+    print("num_target_accessors: ", num_target_accessors)
+    print("num_target_materials: ", num_target_materials)
+    print("num_target_textures: ", num_target_textures)
+    print("num_target_images: ", num_target_images)
+    print("num_target_samplers: ", num_target_samplers)
+
+    #
+    # add some info to asset.extras
+    #
+    extraInfo = {}
+    extraInfo["num_target_meshes"] = num_target_meshes
+    extraInfo["num_target_buffers"] = num_target_buffers
+    extraInfo["num_target_bufferViews"] = num_target_bufferViews
+    extraInfo["num_target_accessors"] = num_target_accessors
+    extraInfo["num_target_materials"] = num_target_materials
+    extraInfo["num_target_textures"] = num_target_textures
+    extraInfo["num_target_images"] = num_target_images
+    extraInfo["num_target_samplers"] = num_target_samplers
+
+    offsets = {}
+    offsets["meshes"] = num_target_meshes
+    offsets["buffers"] = num_target_buffers
+    offsets["bufferViews"] = num_target_bufferViews
+    offsets["accessors"] = num_target_accessors
+    offsets["materials"] = num_target_materials
+    offsets["textures"] = num_target_textures
+    offsets["samplers"] = num_target_samplers
+    offsets["images"] = num_target_images
+
+    for i in range(num_srcs):
+        source = sources[i]
+
+        prefix = g_prefix + "{}/".format(source_filenames[i])
+        concat(source, target, offsets, prefix, extraInfo)
+
+    extraInfo["num_total_meshes"] = offsets["meshes"]
+    extraInfo["num_total_buffers"] = offsets["buffers"]
+    extraInfo["num_total_bufferViews"] = offsets["bufferViews"]
+    extraInfo["num_total_accessors"] = offsets["accessors"]
+    extraInfo["num_total_materials"] = offsets["materials"]
+    extraInfo["num_total_textures"] = offsets["textures"]
+    extraInfo["num_total_images"] = offsets["images"]
+    extraInfo["num_total_samplers"] = offsets["samplers"]
+
+    target["asset"]["extras"] = extraInfo
+
+    with open(output_filename, "w") as f:
+        f.write(json.dumps(target, indent=2))
+
+    print("Merged glTF was exported to : ", output_filename)
+main()

examples/mesh-conv/sandbox/replace_attrib.py

@@ -0,0 +1,107 @@
+# Replace accessor id of attributes for speicified mesh
+# Usually called after concat_mesh.py
+# Example usecase is to replace UV coordinate of a mesh.
+
+import json
+import sys, os
+
+replace_indices = False
+attrib_names = ["TEXCOORD_0"]
+
+def check_accessor(src, target):
+    if src["componentType"] != target["componentType"]:
+        print("componentType mismatch!")
+        return False
+
+    if src["count"] != target["count"]:
+        print("`count` mismatch!")
+        return False
+
+    if src["type"] != target["type"]:
+        print("`type` mismatch!")
+        return False
+
+    return True
+
+def main():
+    if len(sys.argv) < 5:
+        print("Needs input.gltf output.gltf source_mesh_name target_mesh_name <source_primid> <target_primid>")
+        sys.exit(-1)
+
+    input_filename = sys.argv[1]
+    output_filename = sys.argv[2]
+    source_mesh_name = sys.argv[3]
+    target_mesh_name = sys.argv[4]
+
+    source_primid = 0
+    target_primid = 0
+
+    if len(sys.argv) > 5:
+        source_primid = int(sys.argv[5])
+
+    if len(sys.argv) > 6:
+        target_primid = int(sys.argv[6])
+
+    gltf = json.loads(open(input_filename).read())
+
+    source_mesh_id = -1
+    target_mesh_id = -1
+
+    for i in range(len(gltf["meshes"])):
+        mesh = gltf["meshes"][i]
+        print("mesh[{}].name = {}".format(i, mesh["name"]))
+
+        if target_mesh_name == mesh["name"]:
+            target_mesh_id = i
+
+        if source_mesh_name == mesh["name"]:
+            source_mesh_id = i
+
+    if source_mesh_id == -1:
+        print("source mesh with name [{}] not found.".format(source_mesh_name))
+        sys.exit(-1)
+
+    if target_mesh_id == -1:
+        print("target mesh with name [{}] not found.".format(target_mesh_name))
+        sys.exit(-1)
+
+    print("target: name = {}, id = {}".format(target_mesh_name, target_mesh_id))
+    print("source: name = {}, id = {}".format(source_mesh_name, source_mesh_id))
+
+    source_mesh = gltf["meshes"][source_mesh_id]
+    target_mesh = gltf["meshes"][target_mesh_id]
+
+
+    source_prim = source_mesh["primitives"][source_primid]
+    target_prim = target_mesh["primitives"][target_primid]
+
+    if replace_indices:
+        target_indices_id = target_prim["indices"]
+        src_indices_id = source_prim["indices"]
+
+        print("Replace vertex indices from {} to {}".format(target_indices_id, src_indices_id))
+        gltf["meshes"][target_mesh_id]["primitives"][target_primid]["indices"] = gltf["meshes"][source_mesh_id]["primitives"][source_primid]["indices"]
+
+
+    for attrib in target_prim["attributes"]:
+        print("attrib ", attrib)
+        if attrib in attrib_names:
+            if attrib in source_prim["attributes"]:
+                target_accessor_id = target_prim["attributes"][attrib]
+                src_accessor_id = source_prim["attributes"][attrib]
+
+                if check_accessor(gltf["accessors"][src_accessor_id], gltf["accessors"][target_accessor_id]):
+                    gltf["meshes"][target_mesh_id]["primitives"][target_primid]["attributes"][attrib] = src_accessor_id
+                    print("Replaced accessor id for attrib {} from {} to {}".format(attrib, target_accessor_id, src_accessor_id))
+                else:
+                    print("Accessor type/format is not identical. Skip replace")
+                    print("  attrib {}".format(attrib))
+
+            else:
+                print("attribute[{}] not found in source primitive: mesh[{}].primitives[{}]".format(attrib, source_mesh_name, source_primid))
+
+    with open(output_filename, "w") as f:
+        f.write(json.dumps(gltf, indent=2))
+
+    print("Merged glTF was exported to : ", output_filename)
+main()

examples/mesh-conv/tinygltf_impl.cc

@@ -1,4 +1,9 @@
 #define TINYGLTF_IMPLEMENTATION
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+#ifdef _WIN32
+#include "../../tiny_gltf.h"
+#else
 #include "tiny_gltf.h"
+#endif

examples/raytrace/obj-loader.cc

@@ -150,6 +150,7 @@ bool LoadObj(const std::string &filename, float scale,
   tinyobj::attrib_t attrib;
   std::vector<tinyobj::shape_t> shapes;
   std::vector<tinyobj::material_t> materials;
+  std::string warn;
   std::string err;
 
   std::string basedir = GetBaseDir(filename) + "/";
@@ -158,12 +159,16 @@ bool LoadObj(const std::string &filename, float scale,
   // auto t_start = std::chrono::system_clock::now();
 
   bool ret =
-      tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename.c_str(),
+      tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, filename.c_str(),
                        basepath, /* triangulate */ true);
 
   // auto t_end = std::chrono::system_clock::now();
   // std::chrono::duration<double, std::milli> ms = t_end - t_start;
 
+  if (!warn.empty()) {
+    std::cout << warn << std::endl;
+  }
+
   if (!err.empty()) {
     std::cerr << err << std::endl;
   }

loader_example.cc

@@ -524,7 +524,7 @@ static void Dump(const tinygltf::Model &model) {
                 << std::endl;
 
       std::cout << Indent(1) << "channels : [ " << std::endl;
-      for (size_t j = 0; j < animation.channels.size(); j++) {
+      for (size_t j = 0; i < animation.channels.size(); i++) {
         std::cout << Indent(2)
                   << "sampler     : " << animation.channels[j].sampler
                   << std::endl;

models/Extensions-overwrite-issue261/issue-261.gltf

@@ -1,376 +0,0 @@
-{
-  "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
-      ]
-    }
-  ]
-}

tests/tester.cc

@@ -3,9 +3,6 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "tiny_gltf.h"
 
-// Nlohmann json(include ../json.hpp)
-#include "json.hpp"
-
 #define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
 #include "catch.hpp"
 
@@ -96,59 +93,6 @@ TEST_CASE("extension-with-empty-object", "[issue-97]") {
 
 }
 
-TEST_CASE("extension-overwrite", "[issue-261]") {
-
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  bool ret = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/Extensions-overwrite-issue261/issue-261.gltf");
-  if (!err.empty()) {
-    std::cerr << err << std::endl;
-  }
-  REQUIRE(true == ret);
-
-  REQUIRE(model.extensionsUsed.size() == 3);
-  {
-    bool has_ext_lights = false;
-    has_ext_lights |= (model.extensionsUsed[0].compare("KHR_lights_punctual") == 0);
-    has_ext_lights |= (model.extensionsUsed[1].compare("KHR_lights_punctual") == 0);
-    has_ext_lights |= (model.extensionsUsed[2].compare("KHR_lights_punctual") == 0);
-
-    REQUIRE(true == has_ext_lights);
-  }
-
-  {
-    REQUIRE(model.extensions.size() == 2);
-    REQUIRE(model.extensions.count("NV_MDL"));
-    REQUIRE(model.extensions.count("KHR_lights_punctual"));
-  }
-
-  // TODO(syoyo): create temp directory.
-  {
-    ret = ctx.WriteGltfSceneToFile(&model, "issue-261.gltf", true, true);
-    REQUIRE(true == ret);
-
-    tinygltf::Model m;
-
-    // read back serialized glTF
-    bool ret = ctx.LoadASCIIFromFile(&m, &err, &warn, "issue-261.gltf");
-    if (!err.empty()) {
-      std::cerr << err << std::endl;
-    }
-    REQUIRE(true == ret);
-
-    REQUIRE(m.extensionsUsed.size() == 3);
-
-    REQUIRE(m.extensions.size() == 2);
-    REQUIRE(m.extensions.count("NV_MDL"));
-    REQUIRE(m.extensions.count("KHR_lights_punctual"));
-
-  }
-
-}
-
 TEST_CASE("invalid-primitive-indices", "[bounds-checking]") {
   tinygltf::Model model;
   tinygltf::TinyGLTF ctx;
@@ -415,128 +359,3 @@ TEST_CASE("image-uri-spaces", "[issue-236]") {
   REQUIRE(true == ret);
 }
 
-TEST_CASE("serialize-empty-material", "[issue-294]") {
-
-  tinygltf::Model m;
-
-  tinygltf::Material mat;
-  mat.pbrMetallicRoughness.baseColorFactor = {1.0f, 1.0f, 1.0f, 1.0f}; // default baseColorFactor
-  m.materials.push_back(mat);
-
-  std::stringstream os;
-
-  tinygltf::TinyGLTF ctx;
-  ctx.WriteGltfSceneToStream(&m, os, false, false);
-
-  // use nlohmann json
-  nlohmann::json j = nlohmann::json::parse(os.str());
-
-  REQUIRE(1 == j["materials"].size());
-  REQUIRE(j["materials"][0].is_object());
-
-}
-
-TEST_CASE("empty-skeleton-id", "[issue-321]") {
-
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  bool ret = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/regression/unassigned-skeleton.gltf");
-  if (!err.empty()) {
-    std::cerr << err << std::endl;
-  }
-  REQUIRE(true == ret);
-
-  REQUIRE(model.skins.size() == 1);
-  REQUIRE(model.skins[0].skeleton == -1); // unassigned
-
-  std::stringstream os;
-
-  ctx.WriteGltfSceneToStream(&model, os, false, false);
-
-  // use nlohmann json
-  nlohmann::json j = nlohmann::json::parse(os.str());
-
-  // Ensure `skeleton` property is not written to .gltf(was serialized as -1)
-  REQUIRE(1 == j["skins"].size());
-  REQUIRE(j["skins"][0].is_object());
-  REQUIRE(j["skins"][0].count("skeleton") == 0);
-
-}
-
-#ifndef TINYGLTF_NO_FS
-TEST_CASE("expandpath-utf-8", "[pr-226]") {
-
-  std::string s1 = "\xe5\xaf\xb9"; // utf-8 string
-
-  std::string ret = tinygltf::ExpandFilePath(s1, /* userdata */nullptr);
-
-  // expected: E5 AF B9
-  REQUIRE(3 == ret.size());
-
-  REQUIRE(0xe5 == static_cast<uint8_t>(ret[0]));
-  REQUIRE(0xaf == static_cast<uint8_t>(ret[1]));
-  REQUIRE(0xb9 == static_cast<uint8_t>(ret[2]));
-
-}
-#endif
-
-TEST_CASE("empty-bin-buffer", "[issue-382]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  tinygltf::Model model_empty;
-  std::stringstream stream;
-  bool ret = ctx.WriteGltfSceneToStream(&model_empty, stream, false, true);
-  REQUIRE(ret == true);
-  std::string str = stream.str();
-  const unsigned char* bytes = (unsigned char*)str.data();
-  ret = ctx.LoadBinaryFromMemory(&model, &err, &warn, bytes, str.size());
-  if (!err.empty()) {
-    std::cerr << err << std::endl;
-  }
-  REQUIRE(true == ret);
-
-  err.clear();
-  warn.clear();
-
-  tinygltf::Model model_empty_buffer;
-  model_empty_buffer.buffers.push_back(tinygltf::Buffer());
-  stream = std::stringstream();
-  ret = ctx.WriteGltfSceneToStream(&model_empty_buffer, stream, false, true);
-  REQUIRE(ret == true);
-  str = stream.str();
-  bytes = (unsigned char*)str.data();
-  ret = ctx.LoadBinaryFromMemory(&model, &err, &warn, bytes, str.size());
-  if (err.empty()) {
-    std::cerr << "there should have been an error reported" << std::endl;
-  }
-  REQUIRE(false == ret);
-
-  err.clear();
-  warn.clear();
-
-  tinygltf::Model model_single_byte_buffer;
-  tinygltf::Buffer buffer;
-  buffer.data.push_back(0);
-  model_single_byte_buffer.buffers.push_back(buffer);
-  stream = std::stringstream();
-  ret = ctx.WriteGltfSceneToStream(&model_single_byte_buffer, stream, false, true);
-  REQUIRE(ret == true);
-  str = stream.str();
-  {
-    std::ofstream ofs("tmp.glb");
-    ofs.write(str.data(), str.size());
-  }
-
-  bytes = (unsigned char*)str.data();
-  ret = ctx.LoadBinaryFromMemory(&model_single_byte_buffer, &err, &warn, bytes, str.size());
-  if (!err.empty()) {
-    std::cerr << err << std::endl;
-  }
-  REQUIRE(true == ret);
-}