GLB: Fix interger-overflow when calculating JSON Chunk size.

GLB: Check BIN Chunk size.
GLB: Chenk byte alignment of each chunk.

.github/workflows/c-cpp.yml

@@ -47,7 +47,8 @@ jobs:
             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 2019 build
+  # Windows(x64) + Visual Studio 2022 build
+  # Assume windows-latest have VS2022 installed
   build-windows-msvc:
 
     runs-on: windows-latest
@@ -62,7 +63,8 @@ jobs:
         run: |
           mkdir build
           cd build
-          cmake -G "Visual Studio 16 2019" -DTINYGLTF_BUILD_LOADER_EXAMPLE=On -DTINYGLTF_BUILD_GL_EXAMPLES=Off -DTINYGLTF_BUILD_VALIDATOR_EXAMPLE=On ..
+          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

CMakeLists.txt

@@ -4,9 +4,12 @@ PROJECT (tinygltf)
 
 SET(CMAKE_CXX_STANDARD 11)
 
-option(TINYGLTF_BUILD_LOADER_EXAMPLE "Build loader_example" ON)
+option(TINYGLTF_BUILD_LOADER_EXAMPLE "Build loader_example(load glTF and dump infos)" ON)
 option(TINYGLTF_BUILD_GL_EXAMPLES "Build GL exampels(requires glfw, OpenGL, etc)" OFF)
 option(TINYGLTF_BUILD_VALIDATOR_EXAMPLE "Build validator exampe" OFF)
+option(TINYGLTF_BUILD_BUILDER_EXAMPLE "Build glTF builder example" OFF)
+option(TINYGLTF_HEADER_ONLY "On: header-only mode. Off: create tinygltf library(No TINYGLTF_IMPLEMENTATION required in your project)" OFF)
+option(TINYGLTF_INSTALL "Install tinygltf files during install step. Usually set to OFF if you include tinygltf through add_subdirectory()" ON)
 
 if (TINYGLTF_BUILD_LOADER_EXAMPLE)
   ADD_EXECUTABLE ( loader_example
@@ -22,20 +25,52 @@ 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)
+
 #
-# TinuGLTF is a header-only library, so no library build. just install header files.
+# for add_subdirectory and standalone build
 #
-INSTALL ( FILES
-  json.hpp
-  stb_image.h
-  stb_image_write.h
-  tiny_gltf.h
-  DESTINATION
-  include
+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
-  cmake/TinyGLTFConfig.cmake
-  DESTINATION
-  cmake
-  )
+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)

README.md

@@ -3,10 +3,15 @@
 `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).
 
 ## 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)
@@ -15,7 +20,7 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch(bu
 
 ### Branches
 
-* `sajson` : Use sajson to parse JSON. Parsing only but faster compile time(2x reduction compared to json.hpp and RapidJson)
+* `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
 
@@ -27,6 +32,8 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch(bu
 
 ## 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
@@ -77,6 +84,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.
 
 ## Projects using TinyGLTF
 
@@ -90,11 +98,13 @@ In extension(`ExtensionMap`), JSON number value is parsed as int or float(number
 * [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
 
-* [ ] Write C++ code generator which emits C++ code from JSON schema for robust parsing.
+* [ ] Robust URI decoding/encoding. https://github.com/syoyo/tinygltf/issues/369
 * [ ] Mesh Compression/decompression(Open3DGC, etc)
   * [x] Load Draco compressed mesh
   * [ ] Save Draco compressed mesh
@@ -105,6 +115,10 @@ 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.
@@ -168,11 +182,26 @@ 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 featrure.
+* `TINYGLTF_USE_RAPIDJSON` : Use RapidJSON as a JSON parser/serializer. RapidJSON files are not included in TinyGLTF repo. Please set an include path to RapidJSON if you enable this feature.
 * `TINYGLTF_USE_CPP14` : Use C++14 feature(requires C++14 compiler). This may give better performance than C++11.
 
+## CMake options
+
+You can add tinygltf using `add_subdirectory` feature.
+If you add tinygltf to your project using `add_subdirectory`, it would be better to set `TINYGLTF_HEADER_ONLY` on(just add an include path to tinygltf) and `TINYGLTF_INSTALL` off(Which does not install tinygltf files).
+
+```
+// Your project's CMakeLists.txt
+...
+
+set(TINYGLTF_HEADER_ONLY ON CACHE INTERNAL "" FORCE)
+set(TINYGLTF_INSTALL OFF CACHE INTERNAL "" FORCE)
+add_subdirectory(/path/to/tinygltf)
+```
+
 
 ### Saving gltTF 2.0 model
 

examples/basic/main.cpp

@@ -39,8 +39,8 @@ bool loadModel(tinygltf::Model &model, const char *filename) {
   return res;
 }
 
-std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
-                               tinygltf::Model &model, tinygltf::Mesh &mesh) {
+void 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
@@ -144,12 +144,10 @@ std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
       }
     }
   }
-
-  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]);
@@ -160,7 +158,8 @@ void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model,
     bindModelNodes(vbos, model, model.nodes[node.children[i]]);
   }
 }
-GLuint bindModel(tinygltf::Model &model) {
+
+std::pair<GLuint, std::map<int, GLuint>> bindModel(tinygltf::Model &model) {
   std::map<int, GLuint> vbos;
   GLuint vao;
   glGenVertexArrays(1, &vao);
@@ -173,19 +172,29 @@ GLuint bindModel(tinygltf::Model &model) {
   }
 
   glBindVertexArray(0);
-  // cleanup vbos
-  for (size_t i = 0; i < vbos.size(); ++i) {
-    glDeleteBuffers(1, &vbos[i]);
+  // 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;
+    }
   }
 
-  return vao;
+  return {vao, vbos};
 }
 
-void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
+void drawMesh(const std::map<int, GLuint>& vbos,
+              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));
@@ -193,20 +202,22 @@ void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
 }
 
 // recursively draw node and children nodes of model
-void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) {
+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(model, model.meshes[node.mesh]);
+    drawMesh(vaoAndEbos.second, model, model.meshes[node.mesh]);
   }
   for (size_t i = 0; i < node.children.size(); i++) {
-    drawModelNodes(model, model.nodes[node.children[i]]);
+    drawModelNodes(vaoAndEbos, model, model.nodes[node.children[i]]);
   }
 }
-void drawModel(GLuint vao, tinygltf::Model &model) {
-  glBindVertexArray(vao);
+void drawModel(const std::pair<GLuint, std::map<int, GLuint>>& vaoAndEbos,
+               tinygltf::Model &model) {
+  glBindVertexArray(vaoAndEbos.first);
 
   const tinygltf::Scene &scene = model.scenes[model.defaultScene];
   for (size_t i = 0; i < scene.nodes.size(); ++i) {
-    drawModelNodes(model, model.nodes[scene.nodes[i]]);
+    drawModelNodes(vaoAndEbos, model, model.nodes[scene.nodes[i]]);
   }
 
   glBindVertexArray(0);
@@ -282,7 +293,7 @@ void displayLoop(Window &window, const std::string &filename) {
   tinygltf::Model model;
   if (!loadModel(model, filename.c_str())) return;
 
-  GLuint vao = bindModel(model);
+  std::pair<GLuint, std::map<int, GLuint>> vaoAndEbos = bindModel(model);
   // dbgModel(model); return;
 
   // Model matrix : an identity matrix (model will be at the origin)
@@ -317,10 +328,12 @@ 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(vao, model);
+    drawModel(vaoAndEbos, model);
     glfwSwapBuffers(window.window);
     glfwPollEvents();
   }
+
+  glDeleteVertexArrays(1, &vaoAndEbos.first);
 }
 
 static void error_callback(int error, const char *description) {

examples/build-gltf/Makefile

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

examples/build-gltf/create_triangle_gltf.cpp

@@ -0,0 +1,121 @@
+// 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/dxview/src/Viewer.cc

@@ -610,7 +610,7 @@ void Viewer::buildSamplerDescs() {
 
     samplerDesc.AddressU = toTextureAddressMode(glTFSampler.wrapS);
     samplerDesc.AddressV = toTextureAddressMode(glTFSampler.wrapT);
-    samplerDesc.AddressW = toTextureAddressMode(glTFSampler.wrapR);
+    samplerDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
     samplerDesc.MaxLOD = 256;
 
     samplerDescs_.push_back(samplerDesc);
@@ -1289,4 +1289,4 @@ void Viewer::drawNode(uint64_t nodeIndex) {
   for (auto childNodeIndex : glTFNode.children) {
     drawNode(childNodeIndex);
   }
-}
+}

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_LIBRARY}
+  ${GLEW_LIBRARIES}
   ${GLFW3_glfw_LIBRARY}
   ${OPENGL_gl_LIBRARY}
   ${OPENGL_glu_LIBRARY}

examples/glview/glview.cc

@@ -771,6 +771,30 @@ 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
@@ -781,18 +805,22 @@ 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]);
     }
   }
 

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; i < animation.channels.size(); i++) {
+      for (size_t j = 0; j < animation.channels.size(); j++) {
         std::cout << Indent(2)
                   << "sampler     : " << animation.channels[j].sampler
                   << std::endl;

tests/tester.cc

@@ -432,11 +432,40 @@ TEST_CASE("serialize-empty-material", "[issue-294]") {
   nlohmann::json j = nlohmann::json::parse(os.str());
 
   REQUIRE(1 == j["materials"].size());
-  REQUIRE(j["asset"].is_null());
   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]") {
 

tiny_gltf.cc

@@ -0,0 +1,4 @@
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "tiny_gltf.h"

tiny_gltf.h

@@ -4,7 +4,7 @@
 //
 // The MIT License (MIT)
 //
-// Copyright (c) 2015 - 2020 Syoyo Fujita, Aurélien Chatelain and many
+// Copyright (c) 2015 - Present Syoyo Fujita, Aurélien Chatelain and many
 // contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,8 +26,11 @@
 // THE SOFTWARE.
 
 // Version:
+//  - v2.6.0 Support serializing sparse accessor(Thanks to @fynv).
+//           Disable expanding file path for security(no use of awkward `wordexp` anymore).
 //  - v2.5.0 Add SetPreserveImageChannels() option to load image data as is.
-//  - v2.4.3 Fix null object output when when material has all default parameters.
+//  - v2.4.3 Fix null object output when when material has all default
+//  parameters.
 //  - v2.4.2 Decode percent-encoded URI.
 //  - v2.4.1 Fix some glTF object class does not have `extensions` and/or
 //  `extras` property.
@@ -107,7 +110,11 @@ namespace tinygltf {
 #define TINYGLTF_COMPONENT_TYPE_INT (5124)
 #define TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT (5125)
 #define TINYGLTF_COMPONENT_TYPE_FLOAT (5126)
-#define TINYGLTF_COMPONENT_TYPE_DOUBLE (5130)
+#define TINYGLTF_COMPONENT_TYPE_DOUBLE \
+  (5130)  // OpenGL double type. Note that some of glTF 2.0 validator does not
+          // support double type even the schema seems allow any value of
+          // integer:
+          // https://github.com/KhronosGroup/glTF/blob/b9884a2fd45130b4d673dd6c8a706ee21ee5c5f7/specification/2.0/schema/accessor.schema.json#L22
 
 #define TINYGLTF_TEXTURE_FILTER_NEAREST (9728)
 #define TINYGLTF_TEXTURE_FILTER_LINEAR (9729)
@@ -190,14 +197,14 @@ AAssetManager *asset_manager = nullptr;
 #endif
 
 typedef enum {
-  NULL_TYPE = 0,
-  REAL_TYPE = 1,
-  INT_TYPE = 2,
-  BOOL_TYPE = 3,
-  STRING_TYPE = 4,
-  ARRAY_TYPE = 5,
-  BINARY_TYPE = 6,
-  OBJECT_TYPE = 7
+  NULL_TYPE,
+  REAL_TYPE,
+  INT_TYPE,
+  BOOL_TYPE,
+  STRING_TYPE,
+  ARRAY_TYPE,
+  BINARY_TYPE,
+  OBJECT_TYPE
 } Type;
 
 static inline int32_t GetComponentSizeInBytes(uint32_t componentType) {
@@ -252,7 +259,6 @@ bool DecodeDataURI(std::vector<unsigned char> *out, std::string &mime_type,
 #ifdef __clang__
 #pragma clang diagnostic push
 // Suppress warning for : static Value null_value
-// https://stackoverflow.com/questions/15708411/how-to-deal-with-global-constructor-warning-in-clang
 #pragma clang diagnostic ignored "-Wexit-time-destructors"
 #pragma clang diagnostic ignored "-Wpadded"
 #endif
@@ -297,7 +303,7 @@ class Value {
 
   DEFAULT_METHODS(Value)
 
-  char Type() const { return static_cast<const char>(type_); }
+  char Type() const { return static_cast<char>(type_); }
 
   bool IsBool() const { return (type_ == BOOL_TYPE); }
 
@@ -603,7 +609,7 @@ struct Sampler {
   // `magFilter`. Set -1 in TinyGLTF(issue #186)
   int minFilter =
       -1;  // optional. -1 = no filter defined. ["NEAREST", "LINEAR",
-           // "NEAREST_MIPMAP_LINEAR", "LINEAR_MIPMAP_NEAREST",
+           // "NEAREST_MIPMAP_NEAREST", "LINEAR_MIPMAP_NEAREST",
            // "NEAREST_MIPMAP_LINEAR", "LINEAR_MIPMAP_LINEAR"]
   int magFilter =
       -1;  // optional. -1 = no filter defined. ["NEAREST", "LINEAR"]
@@ -613,7 +619,8 @@ struct Sampler {
   int wrapT =
       TINYGLTF_TEXTURE_WRAP_REPEAT;  // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT",
                                      // "REPEAT"], default "REPEAT"
-  int wrapR = TINYGLTF_TEXTURE_WRAP_REPEAT;  // TinyGLTF extension
+  // int wrapR = TINYGLTF_TEXTURE_WRAP_REPEAT;  // TinyGLTF extension. currently
+  // not used.
 
   Value extras;
   ExtensionMap extensions;
@@ -626,8 +633,7 @@ struct Sampler {
       : minFilter(-1),
         magFilter(-1),
         wrapS(TINYGLTF_TEXTURE_WRAP_REPEAT),
-        wrapT(TINYGLTF_TEXTURE_WRAP_REPEAT),
-        wrapR(TINYGLTF_TEXTURE_WRAP_REPEAT) {}
+        wrapT(TINYGLTF_TEXTURE_WRAP_REPEAT) {}
   DEFAULT_METHODS(Sampler)
   bool operator==(const Sampler &) const;
 };
@@ -850,8 +856,10 @@ struct Accessor {
   std::string extras_json_string;
   std::string extensions_json_string;
 
-  std::vector<double> minValues;  // optional
-  std::vector<double> maxValues;  // optional
+  std::vector<double>
+      minValues;  // optional. integer value is promoted to double
+  std::vector<double>
+      maxValues;  // optional. integer value is promoted to double
 
   struct {
     int count;
@@ -1069,7 +1077,7 @@ struct Buffer {
 };
 
 struct Asset {
-  std::string version;  // required
+  std::string version = "2.0";  // required
   std::string generator;
   std::string minVersion;
   std::string copyright;
@@ -1191,7 +1199,8 @@ enum SectionCheck {
 ///
 typedef bool (*LoadImageDataFunction)(Image *, const int, std::string *,
                                       std::string *, int, int,
-                                      const unsigned char *, int, void *user_pointer);
+                                      const unsigned char *, int,
+                                      void *user_pointer);
 
 ///
 /// WriteImageDataFunction type. Signature for custom image writing callbacks.
@@ -1256,7 +1265,7 @@ bool FileExists(const std::string &abs_filename, void *);
 
 ///
 /// Expand file path(e.g. `~` to home directory on posix, `%APPDATA%` to
-/// `C:\Users\tinygltf\AppData`)
+/// `C:\\Users\\tinygltf\\AppData`)
 ///
 /// @param[in] filepath File path string. Assume UTF-8
 /// @param[in] userdata User data. Set to `nullptr` if you don't need it.
@@ -1300,8 +1309,10 @@ class TinyGLTF {
   ///
   /// Loads glTF ASCII asset from string(memory).
   /// `length` = strlen(str);
-  /// Set warning message to `warn` for example it fails to load asserts.
-  /// Returns false and set error string to `err` if there's an error.
+  /// `base_dir` is a search path of glTF asset(e.g. images). Path Must be an
+  /// expanded path (e.g. no tilde(`~`), no environment variables). Set warning
+  /// message to `warn` for example it fails to load asserts. Returns false and
+  /// set error string to `err` if there's an error.
   ///
   bool LoadASCIIFromString(Model *model, std::string *err, std::string *warn,
                            const char *str, const unsigned int length,
@@ -1320,6 +1331,8 @@ class TinyGLTF {
   ///
   /// Loads glTF binary asset from memory.
   /// `length` = strlen(str);
+  /// `base_dir` is a search path of glTF asset(e.g. images). Path Must be an
+  /// expanded path (e.g. no tilde(`~`), no environment variables).
   /// Set warning message to `warn` for example it fails to load asserts.
   /// Returns false and set error string to `err` if there's an error.
   ///
@@ -1398,9 +1411,7 @@ class TinyGLTF {
     preserve_image_channels_ = onoff;
   }
 
-  bool GetPreserveImageChannels() const {
-    return preserve_image_channels_;
-  }
+  bool GetPreserveImageChannels() const { return preserve_image_channels_; }
 
  private:
   ///
@@ -1421,7 +1432,12 @@ class TinyGLTF {
 
   bool store_original_json_for_extras_and_extensions_ = false;
 
-  bool preserve_image_channels_ = false; /// Default false(expand channels to RGBA) for backward compatibility.
+  bool preserve_image_channels_ = false;  /// Default false(expand channels to
+                                          /// RGBA) for backward compatibility.
+
+  // Warning & error messages
+  std::string warn_;
+  std::string err_;
 
   FsCallbacks fs = {
 #ifndef TINYGLTF_NO_FS
@@ -1536,6 +1552,7 @@ class TinyGLTF {
 #ifndef TINYGLTF_USE_RAPIDJSON
 #include "json.hpp"
 #else
+#ifndef TINYGLTF_NO_INCLUDE_RAPIDJSON
 #include "document.h"
 #include "prettywriter.h"
 #include "rapidjson.h"
@@ -1543,6 +1560,7 @@ class TinyGLTF {
 #include "writer.h"
 #endif
 #endif
+#endif
 
 #ifdef TINYGLTF_ENABLE_DRACO
 #include "draco/compression/decode.h"
@@ -1601,11 +1619,11 @@ class TinyGLTF {
 
 #endif
 
-#elif !defined(__ANDROID__)
-#include <wordexp.h>
+#elif !defined(__ANDROID__) && !defined(__OpenBSD__)
+//#include <wordexp.h>
 #endif
 
-#if defined(__sparcv9)
+#if defined(__sparcv9) || defined(__powerpc__)
 // Big endian
 #else
 #if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
@@ -1708,14 +1726,14 @@ namespace tinygltf {
 ///
 /// Internal LoadImageDataOption struct.
 /// This struct is passed through `user_pointer` in LoadImageData.
-/// The struct is not passed when the user supply their own LoadImageData callbacks.
+/// The struct is not passed when the user supply their own LoadImageData
+/// callbacks.
 ///
-struct LoadImageDataOption
-{
-  // true: preserve image channels(e.g. load as RGB image if the image has RGB channels)
-  // default `false`(channels are expanded to RGBA for backward compatiblity).
+struct LoadImageDataOption {
+  // true: preserve image channels(e.g. load as RGB image if the image has RGB
+  // channels) default `false`(channels are expanded to RGBA for backward
+  // compatiblity).
   bool preserve_channels{false};
-
 };
 
 // Equals function for Value, for recursivity
@@ -1930,8 +1948,9 @@ bool Sampler::operator==(const Sampler &other) const {
   return this->extensions == other.extensions && this->extras == other.extras &&
          this->magFilter == other.magFilter &&
          this->minFilter == other.minFilter && this->name == other.name &&
-         this->wrapR == other.wrapR && this->wrapS == other.wrapS &&
-         this->wrapT == other.wrapT;
+         this->wrapS == other.wrapS && this->wrapT == other.wrapT;
+
+  // this->wrapR == other.wrapR
 }
 bool Scene::operator==(const Scene &other) const {
   return this->extensions == other.extensions && this->extras == other.extras &&
@@ -2035,9 +2054,10 @@ static std::string GetBaseDir(const std::string &filepath) {
   return "";
 }
 
-// https://stackoverflow.com/questions/8520560/get-a-file-name-from-a-path
 static std::string GetBaseFilename(const std::string &filepath) {
-  return filepath.substr(filepath.find_last_of("/\\") + 1);
+  auto idx = filepath.find_last_of("/\\");
+  if (idx != std::string::npos) return filepath.substr(idx + 1);
+  return filepath;
 }
 
 std::string base64_encode(unsigned char const *, unsigned int len);
@@ -2183,47 +2203,35 @@ std::string base64_decode(std::string const &encoded_string) {
 // TODO(syoyo): Use uriparser https://uriparser.github.io/ for stricter Uri
 // decoding?
 //
-// https://stackoverflow.com/questions/18307429/encode-decode-url-in-c
+// Uri Decoding from DLIB
 // http://dlib.net/dlib/server/server_http.cpp.html
-
-// --- dlib beign ------------------------------------------------------------
+// --- dlib begin ------------------------------------------------------------
 // Copyright (C) 2003  Davis E. King (davis@dlib.net)
-// License: Boost Software License   See LICENSE.txt for the full license.
+// License: Boost Software License
+// Boost Software License - Version 1.0 - August 17th, 2003
 
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
 namespace dlib {
 
-#if 0
-        inline unsigned char to_hex( unsigned char x )
-        {
-            return x + (x > 9 ? ('A'-10) : '0');
-        }
-
-        const std::string urlencode( const std::string& s )
-        {
-            std::ostringstream os;
-
-            for ( std::string::const_iterator ci = s.begin(); ci != s.end(); ++ci )
-            {
-                if ( (*ci >= 'a' && *ci <= 'z') ||
-                     (*ci >= 'A' && *ci <= 'Z') ||
-                     (*ci >= '0' && *ci <= '9') )
-                { // allowed
-                    os << *ci;
-                }
-                else if ( *ci == ' ')
-                {
-                    os << '+';
-                }
-                else
-                {
-                    os << '%' << to_hex(static_cast<unsigned char>(*ci >> 4)) << to_hex(static_cast<unsigned char>(*ci % 16));
-                }
-            }
-
-            return os.str();
-        }
-#endif
-
 inline unsigned char from_hex(unsigned char ch) {
   if (ch <= '9' && ch >= '0')
     ch -= '0';
@@ -2363,8 +2371,8 @@ bool LoadImageData(Image *image, const int image_idx, std::string *err,
   unsigned char *data = nullptr;
 
   // preserve_channels true: Use channels stored in the image file.
-  // false: force 32-bit textures for common Vulkan compatibility. It appears that
-  // some GPU drivers do not support 24-bit images for Vulkan
+  // false: force 32-bit textures for common Vulkan compatibility. It appears
+  // that some GPU drivers do not support 24-bit images for Vulkan
   req_comp = option.preserve_channels ? 0 : 4;
   int bits = 8;
   int pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE;
@@ -2610,6 +2618,18 @@ bool FileExists(const std::string &abs_filename, void *) {
 }
 
 std::string ExpandFilePath(const std::string &filepath, void *) {
+  // https://github.com/syoyo/tinygltf/issues/368
+  //
+  // No file path expansion in built-in FS function anymore, since glTF URI
+  // should not contain tilde('~') and environment variables, and for security
+  // reason(`wordexp`).
+  //
+  // Users need to supply `base_dir`(in `LoadASCIIFromString`,
+  // `LoadBinaryFromMemory`) in expanded absolute path.
+
+  return filepath;
+
+#if 0
 #ifdef _WIN32
   // Assume input `filepath` is encoded in UTF-8
   std::wstring wfilepath = UTF8ToWchar(filepath);
@@ -2624,7 +2644,7 @@ std::string ExpandFilePath(const std::string &filepath, void *) {
 #else
 
 #if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) || \
-    defined(__ANDROID__) || defined(__EMSCRIPTEN__)
+    defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__OpenBSD__)
   // no expansion
   std::string s = filepath;
 #else
@@ -2657,6 +2677,7 @@ std::string ExpandFilePath(const std::string &filepath, void *) {
 
   return s;
 #endif
+#endif
 }
 
 bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err,
@@ -3097,11 +3118,17 @@ std::string JsonToString(const json &o, int spacing = -1) {
   StringBuffer buffer;
   if (spacing == -1) {
     Writer<StringBuffer> writer(buffer);
-    o.Accept(writer);
+    // TODO: Better error handling.
+    // https://github.com/syoyo/tinygltf/issues/332
+    if (!o.Accept(writer)) {
+      return "tiny_gltf::JsonToString() failed rapidjson conversion";
+    }
   } else {
     PrettyWriter<StringBuffer> writer(buffer);
     writer.SetIndent(' ', uint32_t(spacing));
-    o.Accept(writer);
+    if (!o.Accept(writer)) {
+      return "tiny_gltf::JsonToString() failed rapidjson conversion";
+    }
   }
   return buffer.GetString();
 #else
@@ -3197,6 +3224,7 @@ static bool ParseJsonAsValue(Value *ret, const json &o) {
       break;
     case json::value_t::null:
     case json::value_t::discarded:
+    case json::value_t::binary:
       // default:
       break;
   }
@@ -4220,7 +4248,9 @@ static bool ParseSparseAccessor(Accessor *accessor, std::string *err,
   accessor->sparse.isSparse = true;
 
   int count = 0;
-  ParseIntegerProperty(&count, err, o, "count", true);
+  if (!ParseIntegerProperty(&count, err, o, "count", true, "SparseAccessor")) {
+    return false;
+  }
 
   json_const_iterator indices_iterator;
   json_const_iterator values_iterator;
@@ -4238,18 +4268,24 @@ static bool ParseSparseAccessor(Accessor *accessor, std::string *err,
   const json &values_obj = GetValue(values_iterator);
 
   int indices_buffer_view = 0, indices_byte_offset = 0, component_type = 0;
-  ParseIntegerProperty(&indices_buffer_view, err, indices_obj, "bufferView",
-                       true);
+  if (!ParseIntegerProperty(&indices_buffer_view, err, indices_obj,
+                            "bufferView", true, "SparseAccessor")) {
+    return false;
+  }
   ParseIntegerProperty(&indices_byte_offset, err, indices_obj, "byteOffset",
-                       true);
-  ParseIntegerProperty(&component_type, err, indices_obj, "componentType",
-                       true);
+                       false);
+  if (!ParseIntegerProperty(&component_type, err, indices_obj, "componentType",
+                            true, "SparseAccessor")) {
+    return false;
+  }
 
   int values_buffer_view = 0, values_byte_offset = 0;
-  ParseIntegerProperty(&values_buffer_view, err, values_obj, "bufferView",
-                       true);
+  if (!ParseIntegerProperty(&values_buffer_view, err, values_obj, "bufferView",
+                            true, "SparseAccessor")) {
+    return false;
+  }
   ParseIntegerProperty(&values_byte_offset, err, values_obj, "byteOffset",
-                       true);
+                       false);
 
   accessor->sparse.count = count;
   accessor->sparse.indices.bufferView = indices_buffer_view;
@@ -4258,8 +4294,6 @@ static bool ParseSparseAccessor(Accessor *accessor, std::string *err,
   accessor->sparse.values.bufferView = values_buffer_view;
   accessor->sparse.values.byteOffset = values_byte_offset;
 
-  // todo check theses values
-
   return true;
 }
 
@@ -4467,6 +4501,7 @@ static bool GetAttributeForAllPoints(uint32_t componentType, draco::Mesh *mesh,
 static bool ParseDracoExtension(Primitive *primitive, Model *model,
                                 std::string *err,
                                 const Value &dracoExtensionValue) {
+  (void)err;
   auto bufferViewValue = dracoExtensionValue.Get("bufferView");
   if (!bufferViewValue.IsInt()) return false;
   auto attributesValue = dracoExtensionValue.Get("attributes");
@@ -4527,7 +4562,6 @@ static bool ParseDracoExtension(Primitive *primitive, Model *model,
 
     int dracoAttributeIndex = attribute.second.Get<int>();
     const auto pAttribute = mesh->GetAttributeByUniqueId(dracoAttributeIndex);
-    const auto pBuffer = pAttribute->buffer();
     const auto componentType =
         model->accessors[primitiveAttribute->second].componentType;
 
@@ -5086,12 +5120,13 @@ static bool ParseSampler(Sampler *sampler, std::string *err, const json &o,
   int magFilter = -1;
   int wrapS = TINYGLTF_TEXTURE_WRAP_REPEAT;
   int wrapT = TINYGLTF_TEXTURE_WRAP_REPEAT;
-  int wrapR = TINYGLTF_TEXTURE_WRAP_REPEAT;
+  // int wrapR = TINYGLTF_TEXTURE_WRAP_REPEAT;
   ParseIntegerProperty(&minFilter, err, o, "minFilter", false);
   ParseIntegerProperty(&magFilter, err, o, "magFilter", false);
   ParseIntegerProperty(&wrapS, err, o, "wrapS", false);
   ParseIntegerProperty(&wrapT, err, o, "wrapT", false);
-  ParseIntegerProperty(&wrapR, err, o, "wrapR", false);  // tinygltf extension
+  // ParseIntegerProperty(&wrapR, err, o, "wrapR", false);  // tinygltf
+  // extension
 
   // TODO(syoyo): Check the value is alloed one.
   // (e.g. we allow 9728(NEAREST), but don't allow 9727)
@@ -5100,7 +5135,7 @@ static bool ParseSampler(Sampler *sampler, std::string *err, const json &o,
   sampler->magFilter = magFilter;
   sampler->wrapS = wrapS;
   sampler->wrapT = wrapT;
-  sampler->wrapR = wrapR;
+  // sampler->wrapR = wrapR;
 
   ParseExtensionsProperty(&(sampler->extensions), err, o);
   ParseExtrasProperty(&(sampler->extras), o);
@@ -5827,13 +5862,13 @@ bool TinyGLTF::LoadFromString(Model *model, std::string *err, std::string *warn,
         {
           json_const_iterator it;
           if (FindMember(o, "extensions", it)) {
-            model->extensions_json_string = JsonToString(GetValue(it));
+            scene.extensions_json_string = JsonToString(GetValue(it));
           }
         }
         {
           json_const_iterator it;
           if (FindMember(o, "extras", it)) {
-            model->extras_json_string = JsonToString(GetValue(it));
+            scene.extras_json_string = JsonToString(GetValue(it));
           }
         }
       }
@@ -6213,44 +6248,109 @@ bool TinyGLTF::LoadBinaryFromMemory(Model *model, std::string *err,
 
   unsigned int version;       // 4 bytes
   unsigned int length;        // 4 bytes
-  unsigned int model_length;  // 4 bytes
-  unsigned int model_format;  // 4 bytes;
+  unsigned int chunk0_length;  // 4 bytes
+  unsigned int chunk0_format;  // 4 bytes;
 
-  // @todo { Endian swap for big endian machine. }
   memcpy(&version, bytes + 4, 4);
   swap4(&version);
   memcpy(&length, bytes + 8, 4);
   swap4(&length);
-  memcpy(&model_length, bytes + 12, 4);
-  swap4(&model_length);
-  memcpy(&model_format, bytes + 16, 4);
-  swap4(&model_format);
+  memcpy(&chunk0_length, bytes + 12, 4); // JSON data length
+  swap4(&chunk0_length);
+  memcpy(&chunk0_format, bytes + 16, 4);
+  swap4(&chunk0_format);
 
+  // https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#binary-gltf-layout
+  //
   // In case the Bin buffer is not present, the size is exactly 20 + size of
   // JSON contents,
   // so use "greater than" operator.
-  if ((20 + model_length > size) || (model_length < 1) || (length > size) ||
-      (20 + model_length > length) ||
-      (model_format != 0x4E4F534A)) {  // 0x4E4F534A = JSON format.
+  //
+  // https://github.com/syoyo/tinygltf/issues/372
+  // Use 64bit uint to avoid integer overflow.
+  uint64_t json_size = 20ull + uint64_t(chunk0_length);
+
+  if (json_size > std::numeric_limits<uint32_t>::max()) {
+    // Do not allow 4GB or more GLB data.
+   (*err) = "Invalid glTF binary. GLB data exceeds 4GB.";
+  }
+
+  if ((json_size > uint64_t(size)) || (chunk0_length < 1) || (length > size) ||
+      (json_size > uint64_t(length)) ||
+      (chunk0_format != 0x4E4F534A)) {  // 0x4E4F534A = JSON format.
     if (err) {
       (*err) = "Invalid glTF binary.";
     }
     return false;
   }
 
+  // Padding check
+  // The start and the end of each chunk must be aligned to a 4-byte boundary.
+  // No padding check for chunk0 start since its 4byte-boundary is ensured.
+  if ((json_size % 4) != 0) {
+    if (err) {
+      (*err) = "JSON Chunk end does not aligned to a 4-byte boundary.";
+    }
+  }
+
+  // Read Chunk1 info(BIN data)
+  if ((json_size + 8ull) > uint64_t(length)) {
+    if (err) {
+      (*err) = "Insufficient storage space for Chunk1(BIN data).";
+    }
+    return false;
+  }
+
+  unsigned int chunk1_length;  // 4 bytes
+  unsigned int chunk1_format;  // 4 bytes;
+  memcpy(&chunk1_length, bytes + json_size, 4); // JSON data length
+  swap4(&chunk1_length);
+  memcpy(&chunk1_format, bytes + json_size + 4, 4);
+  swap4(&chunk1_format);
+
+  if (chunk1_length < 4) {
+    // TODO: Do we allow 0byte BIN data?
+    if (err) {
+      (*err) = "Insufficient Chunk1(BIN) data size.";
+    }
+    return false;
+  }
+
+  if ((chunk1_length % 4) != 0) {
+    if (err) {
+      (*err) = "BIN Chunk end does not aligned to a 4-byte boundary.";
+    }
+    return false;
+  }
+
+  if (uint64_t(chunk1_length) + json_size > uint64_t(length)) {
+    if (err) {
+      (*err) = "BIN Chunk data length exceeds the GLB size.";
+    }
+    return false;
+  }
+
+  if (chunk1_format != 0x004e4942) {
+    if (err) {
+      (*err) = "Invlid type for chunk1 data.";
+    }
+    return false;
+  }
+
+  bin_data_ = bytes + json_size +
+              8;  // 4 bytes (bin_buffer_length) + 4 bytes(bin_buffer_format)
+
+  bin_size_ = size_t(chunk1_length);
+
   // Extract JSON string.
   std::string jsonString(reinterpret_cast<const char *>(&bytes[20]),
-                         model_length);
+                         chunk0_length);
 
   is_binary_ = true;
-  bin_data_ = bytes + 20 + model_length +
-              8;  // 4 bytes (buffer_length) + 4 bytes(buffer_format)
-  bin_size_ =
-      length - (20 + model_length);  // extract header + JSON scene data.
 
   bool ret = LoadFromString(model, err, warn,
                             reinterpret_cast<const char *>(&bytes[20]),
-                            model_length, base_dir, check_sections);
+                            chunk0_length, base_dir, check_sections);
   if (!ret) {
     return ret;
   }
@@ -6621,8 +6721,33 @@ static void SerializeGltfAccessor(Accessor &accessor, json &o) {
 
   SerializeNumberProperty<int>("componentType", accessor.componentType, o);
   SerializeNumberProperty<size_t>("count", accessor.count, o);
-  SerializeNumberArrayProperty<double>("min", accessor.minValues, o);
-  SerializeNumberArrayProperty<double>("max", accessor.maxValues, o);
+
+  if ((accessor.componentType == TINYGLTF_COMPONENT_TYPE_FLOAT) ||
+      (accessor.componentType == TINYGLTF_COMPONENT_TYPE_DOUBLE)) {
+    SerializeNumberArrayProperty<double>("min", accessor.minValues, o);
+    SerializeNumberArrayProperty<double>("max", accessor.maxValues, o);
+  } else {
+    // Issue #301. Serialize as integer.
+    // Assume int value is within [-2**31-1, 2**31-1]
+    {
+      std::vector<int> values;
+      std::transform(accessor.minValues.begin(), accessor.minValues.end(),
+                     std::back_inserter(values),
+                     [](double v) { return static_cast<int>(v); });
+
+      SerializeNumberArrayProperty<int>("min", values, o);
+    }
+
+    {
+      std::vector<int> values;
+      std::transform(accessor.maxValues.begin(), accessor.maxValues.end(),
+                     std::back_inserter(values),
+                     [](double v) { return static_cast<int>(v); });
+
+      SerializeNumberArrayProperty<int>("max", values, o);
+    }
+  }
+
   if (accessor.normalized)
     SerializeValue("normalized", Value(accessor.normalized), o);
   std::string type;
@@ -6656,6 +6781,27 @@ static void SerializeGltfAccessor(Accessor &accessor, json &o) {
   if (accessor.extras.Type() != NULL_TYPE) {
     SerializeValue("extras", accessor.extras, o);
   }
+
+  // sparse
+  if (accessor.sparse.isSparse)
+  {
+      json sparse;
+      SerializeNumberProperty<int>("count", accessor.sparse.count, sparse);
+      {
+          json indices;
+          SerializeNumberProperty<int>("bufferView", accessor.sparse.indices.bufferView, indices);
+          SerializeNumberProperty<int>("byteOffset", accessor.sparse.indices.byteOffset, indices);
+          SerializeNumberProperty<int>("componentType", accessor.sparse.indices.componentType, indices);
+          JsonAddMember(sparse, "indices", std::move(indices));
+      }
+      {
+          json values;
+          SerializeNumberProperty<int>("bufferView", accessor.sparse.values.bufferView, values);
+          SerializeNumberProperty<int>("byteOffset", accessor.sparse.values.byteOffset, values);
+          JsonAddMember(sparse, "values", std::move(values));
+      }
+      JsonAddMember(o, "sparse", std::move(sparse));
+  }
 }
 
 static void SerializeGltfAnimationChannel(AnimationChannel &channel, json &o) {
@@ -6732,10 +6878,15 @@ static void SerializeGltfAsset(Asset &asset, json &o) {
     SerializeStringProperty("copyright", asset.copyright, o);
   }
 
-  if (!asset.version.empty()) {
-    SerializeStringProperty("version", asset.version, o);
+  if (asset.version.empty()) {
+    // Just in case
+    // `version` must be defined
+    asset.version = "2.0";
   }
 
+  // TODO(syoyo): Do we need to check if `version` is greater or equal to 2.0?
+  SerializeStringProperty("version", asset.version, o);
+
   if (asset.extras.Keys().size()) {
     SerializeValue("extras", asset.extras, o);
   }
@@ -7133,7 +7284,7 @@ static void SerializeGltfSampler(Sampler &sampler, json &o) {
   if (sampler.minFilter != -1) {
     SerializeNumberProperty("minFilter", sampler.minFilter, o);
   }
-  SerializeNumberProperty("wrapR", sampler.wrapR, o);
+  // SerializeNumberProperty("wrapR", sampler.wrapR, o);
   SerializeNumberProperty("wrapS", sampler.wrapS, o);
   SerializeNumberProperty("wrapT", sampler.wrapT, o);
 
@@ -7208,11 +7359,17 @@ static void SerializeGltfScene(Scene &scene, json &o) {
 }
 
 static void SerializeGltfSkin(Skin &skin, json &o) {
-  if (skin.inverseBindMatrices != -1)
-    SerializeNumberProperty("inverseBindMatrices", skin.inverseBindMatrices, o);
-
+  // required
   SerializeNumberArrayProperty<int>("joints", skin.joints, o);
-  SerializeNumberProperty("skeleton", skin.skeleton, o);
+
+  if (skin.inverseBindMatrices >= 0) {
+    SerializeNumberProperty("inverseBindMatrices", skin.inverseBindMatrices, o);
+  }
+
+  if (skin.skeleton >= 0) {
+    SerializeNumberProperty("skeleton", skin.skeleton, o);
+  }
+
   if (skin.name.size()) {
     SerializeStringProperty("name", skin.name, o);
   }
@@ -7299,7 +7456,8 @@ static void SerializeGltfModel(Model *model, json &o) {
       if (JsonIsNull(material)) {
         // Issue 294.
         // `material` does not have any required parameters
-        // so the result may be null(unmodified) when all material parameters have default value.
+        // so the result may be null(unmodified) when all material parameters
+        // have default value.
         //
         // null is not allowed thus we create an empty JSON object.
         JsonSetObject(material);
@@ -7442,7 +7600,7 @@ static void SerializeGltfModel(Model *model, json &o) {
   }
 
   // Extensions used
-  if (model->extensionsUsed.size()) {
+  if (extensionsUsed.size()) {
     SerializeStringArrayProperty("extensionsUsed", extensionsUsed, o);
   }
 
@@ -7480,37 +7638,32 @@ static bool WriteGltfFile(const std::string &output,
   return WriteGltfStream(gltfFile, content);
 }
 
-static void WriteBinaryGltfStream(std::ostream &stream,
+static bool WriteBinaryGltfStream(std::ostream &stream,
                                   const std::string &content,
                                   const std::vector<unsigned char> &binBuffer) {
   const std::string header = "glTF";
   const int version = 2;
 
-  // https://stackoverflow.com/questions/3407012/c-rounding-up-to-the-nearest-multiple-of-a-number
-  auto roundUp = [](uint32_t numToRound, uint32_t multiple) {
-    if (multiple == 0) return numToRound;
-
-    uint32_t remainder = numToRound % multiple;
-    if (remainder == 0) return numToRound;
-
-    return numToRound + multiple - remainder;
-  };
-
-  const uint32_t padding_size =
-      roundUp(uint32_t(content.size()), 4) - uint32_t(content.size());
+  const uint32_t content_size = uint32_t(content.size());
+  const uint32_t binBuffer_size = uint32_t(binBuffer.size());
+  // determine number of padding bytes required to ensure 4 byte alignment
+  const uint32_t content_padding_size =
+      content_size % 4 == 0 ? 0 : 4 - content_size % 4;
+  const uint32_t bin_padding_size =
+      binBuffer_size % 4 == 0 ? 0 : 4 - binBuffer_size % 4;
 
   // 12 bytes for header, JSON content length, 8 bytes for JSON chunk info.
-  // Chunk data must be located at 4-byte boundary.
+  // Chunk data must be located at 4-byte boundary, which may require padding
   const uint32_t length =
-      12 + 8 + roundUp(uint32_t(content.size()), 4) +
-      (binBuffer.size() ? (8 + roundUp(uint32_t(binBuffer.size()), 4)) : 0);
+      12 + 8 + content_size + content_padding_size +
+      (binBuffer_size ? (8 + binBuffer_size + bin_padding_size) : 0);
 
   stream.write(header.c_str(), std::streamsize(header.size()));
   stream.write(reinterpret_cast<const char *>(&version), sizeof(version));
   stream.write(reinterpret_cast<const char *>(&length), sizeof(length));
 
   // JSON chunk info, then JSON data
-  const uint32_t model_length = uint32_t(content.size()) + padding_size;
+  const uint32_t model_length = uint32_t(content.size()) + content_padding_size;
   const uint32_t model_format = 0x4E4F534A;
   stream.write(reinterpret_cast<const char *>(&model_length),
                sizeof(model_length));
@@ -7519,13 +7672,11 @@ static void WriteBinaryGltfStream(std::ostream &stream,
   stream.write(content.c_str(), std::streamsize(content.size()));
 
   // Chunk must be multiplies of 4, so pad with spaces
-  if (padding_size > 0) {
-    const std::string padding = std::string(size_t(padding_size), ' ');
+  if (content_padding_size > 0) {
+    const std::string padding = std::string(size_t(content_padding_size), ' ');
     stream.write(padding.c_str(), std::streamsize(padding.size()));
   }
   if (binBuffer.size() > 0) {
-    const uint32_t bin_padding_size =
-        roundUp(uint32_t(binBuffer.size()), 4) - uint32_t(binBuffer.size());
     // BIN chunk info, then BIN data
     const uint32_t bin_length = uint32_t(binBuffer.size()) + bin_padding_size;
     const uint32_t bin_format = 0x004e4942;
@@ -7543,9 +7694,12 @@ static void WriteBinaryGltfStream(std::ostream &stream,
                    std::streamsize(padding.size()));
     }
   }
+
+  // TODO: Check error on stream.write
+  return true;
 }
 
-static void WriteBinaryGltfFile(const std::string &output,
+static bool WriteBinaryGltfFile(const std::string &output,
                                 const std::string &content,
                                 const std::vector<unsigned char> &binBuffer) {
 #ifdef _WIN32
@@ -7563,7 +7717,7 @@ static void WriteBinaryGltfFile(const std::string &output,
 #else
   std::ofstream gltfFile(output.c_str(), std::ios::binary);
 #endif
-  WriteBinaryGltfStream(gltfFile, content, binBuffer);
+  return WriteBinaryGltfStream(gltfFile, content, binBuffer);
 }
 
 bool TinyGLTF::WriteGltfSceneToStream(Model *model, std::ostream &stream,
@@ -7602,7 +7756,7 @@ bool TinyGLTF::WriteGltfSceneToStream(Model *model, std::ostream &stream,
       // UpdateImageObject need baseDir but only uses it if embeddedImages is
       // enabled, since we won't write separate images when writing to a stream
       // we
-      UpdateImageObject(model->images[i], dummystring, int(i), false,
+      UpdateImageObject(model->images[i], dummystring, int(i), true,
                         &this->WriteImageData, this->write_image_user_data_);
       SerializeGltfImage(model->images[i], image);
       JsonPushBack(images, std::move(image));
@@ -7611,12 +7765,11 @@ bool TinyGLTF::WriteGltfSceneToStream(Model *model, std::ostream &stream,
   }
 
   if (writeBinary) {
-    WriteBinaryGltfStream(stream, JsonToString(output), binBuffer);
+    return WriteBinaryGltfStream(stream, JsonToString(output), binBuffer);
   } else {
-    WriteGltfStream(stream, JsonToString(output, prettyPrint ? 2 : -1));
+    return WriteGltfStream(stream, JsonToString(output, prettyPrint ? 2 : -1));
   }
 
-  return true;
 }
 
 bool TinyGLTF::WriteGltfSceneToFile(Model *model, const std::string &filename,
@@ -7701,12 +7854,11 @@ bool TinyGLTF::WriteGltfSceneToFile(Model *model, const std::string &filename,
   }
 
   if (writeBinary) {
-    WriteBinaryGltfFile(filename, JsonToString(output), binBuffer);
+    return WriteBinaryGltfFile(filename, JsonToString(output), binBuffer);
   } else {
-    WriteGltfFile(filename, JsonToString(output, (prettyPrint ? 2 : -1)));
+    return WriteGltfFile(filename, JsonToString(output, (prettyPrint ? 2 : -1)));
   }
 
-  return true;
 }
 
 }  // namespace tinygltf