Add internal JSON backend option

Add bounds check to images loaded from bufferviews

AGENTS.md

@@ -0,0 +1,34 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- Core library lives in `tiny_gltf.h` (header-only) with `tiny_gltf.cc` provided for the amalgamated implementation flags. Keep public API updates localized and documented.
+- Example viewers and utilities sit under `examples/`; use them as references for loading, validation, and WASM builds. Temporary build outputs belong in `build/` (git-ignored).
+- Tests reside in `tests/` with sample assets in `data/` and `models/`; avoid committing generated binaries in `build/`, `tmp/`, or `tests/tester*`.
+
+## Build, Test, and Development Commands
+- Quick build of the loader example: `make` (uses clang++, C++11, optional `EXTRA_CXXFLAGS` for sanitizers).
+- Unit tests: `cd tests && make && ./tester && ./tester_noexcept`.
+- Parsing regression run: build `loader_example`, then `python test_runner.py` (requires local glTF-Sample-Models checkout and path update inside the script).
+- CMake alternative: `cmake -S . -B build && cmake --build build` for IDE integration or non-clang toolchains.
+- Lint header: `python deps/cpplint.py tiny_gltf.h`.
+
+## Coding Style & Naming Conventions
+- C++11, two-space indent, braces on the same line; mirror existing spacing and comment style in `tiny_gltf.h`.
+- Prefer `std::` facilities and minimal dependencies; keep new symbols in the `tinygltf` namespace.
+- Public API names stay PascalCase for types and camelCase for functions; keep enums/macros consistent with existing `TINYGLTF_*` patterns.
+- Guard optional features with the established `TINYGLTF_*` defines; avoid introducing new globals without discussion.
+
+## Testing Guidelines
+- Framework: Catch2 single-header (`tests/catch.hpp`); add `TEST_CASE` blocks alongside related helpers in `tests/tester.cc`.
+- Provide coverage for both exception-enabled and `TINYGLTF_NOEXCEPTION` builds; run both `tester` binaries before submitting.
+- For new formats or parsing code, add assets under `tests/` or reference `data/` and note provenance.
+
+## Commit & Pull Request Guidelines
+- Commit messages: concise, present-tense imperatives mirroring existing history (e.g., “Add bounds check to images loaded from bufferviews”).
+- PRs should describe the change, motivation, and testing (`tester`, `tester_noexcept`, fuzzing if relevant); link related issues.
+- Include platform notes if behavior differs (Windows vs. POSIX, filesystem callbacks, WASM). Add before/after metrics when touching performance-sensitive paths.
+
+## Security & Configuration Tips
+- Handle external data defensively: validate buffer sizes, offsets, and URI handling; prefer bounded allocations.
+- Keep optional callbacks (`fs::`, URI, image) robust against untrusted input; document new failure modes.
+- Avoid committing sample assets with unclear licensing; reuse existing test fixtures where possible.

CMakeLists.txt

@@ -16,6 +16,7 @@ option(TINYGLTF_BUILD_VALIDATOR_EXAMPLE "Build validator exampe" OFF)
 option(TINYGLTF_BUILD_BUILDER_EXAMPLE "Build glTF builder example" OFF)
 option(TINYGLTF_HEADER_ONLY "On: header-only mode. Off: create tinygltf library(No TINYGLTF_IMPLEMENTATION required in your project)" OFF)
 option(TINYGLTF_INSTALL "Install tinygltf files during install step. Usually set to OFF if you include tinygltf through add_subdirectory()" ON)
+option(TINYGLTF_INSTALL_VENDOR "Install vendored nlohmann/json and nothings/stb headers" ON)
 
 if (TINYGLTF_BUILD_LOADER_EXAMPLE)
   add_executable(loader_example
@@ -61,19 +62,26 @@ endif (TINYGLTF_HEADER_ONLY)
 
 if (TINYGLTF_INSTALL)
   install(TARGETS tinygltf EXPORT tinygltfTargets)
-  install(EXPORT tinygltfTargets NAMESPACE tinygltf:: FILE TinyGLTFTargets.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+  install(EXPORT tinygltfTargets NAMESPACE tinygltf:: FILE TinyGLTFTargets.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/tinygltf)
   configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/TinyGLTFConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/TinyGLTFConfig.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/TinyGLTFConfig.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/TinyGLTFConfig.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/tinygltf)
   # Do not install .lib even if !TINYGLTF_HEADER_ONLY
 
   INSTALL ( FILES
-    json.hpp
-    stb_image.h
-    stb_image_write.h
     tiny_gltf.h
     ${TINYGLTF_EXTRA_SOUECES}
     DESTINATION
     include
     )
 
+    if(TINYGLTF_INSTALL_VENDOR)
+      INSTALL ( FILES
+        json.hpp
+        stb_image.h
+        stb_image_write.h
+        DESTINATION
+        include
+        )
+    endif()
+
 endif(TINYGLTF_INSTALL)

README.md

@@ -9,7 +9,7 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch (b
 ## Status
 
 Currently TinyGLTF is stable and maintenance mode. No drastic changes and feature additions planned.
-
+ - v2.9.0 Various fixes and improvements. Filesystem callback API change.
  - v2.8.0 Add URICallbacks for custom URI handling in Buffer and Image. PR#397
  - v2.7.0 Change WriteImageDataFunction user callback function signature. PR#393
  - v2.6.0 Support serializing sparse accessor(Thanks to @fynv).
@@ -211,6 +211,11 @@ set(TINYGLTF_INSTALL OFF CACHE INTERNAL "" FORCE)
 add_subdirectory(/path/to/tinygltf)
 ```
 
+NOTE: Using tinygltf as a submodule doesn't automatically add the headers to your include path (as standard for many libraries). To get this functionality, add the following to the CMakeLists.txt file from above:
+
+```
+target_include_directories(${PROJECT_NAME} PRIVATE "/path/to/tinygltf")
+```
 
 ### Saving gltTF 2.0 model
 

examples/glview/glview.cc

@@ -788,8 +788,10 @@ static void QuatToAngleAxis(const std::vector<double> quaternion,
     return;
   }
 
+  constexpr double pi = 3.14159265358979323846;
+
   double denom = sqrt(1-qw*qw);
-  outAngleDegrees = angleRadians * 180.0 / M_PI;
+  outAngleDegrees = angleRadians * 180.0 / pi;
   axis[0] = qx / denom;
   axis[1] = qy / denom;
   axis[2] = qz / denom;

tests/tester.cc

@@ -4,7 +4,9 @@
 #include "tiny_gltf.h"
 
 // Nlohmann json(include ../json.hpp)
+#if !defined(TINYGLTF_USE_INTERNAL_JSON) && !defined(TINYGLTF_USE_RAPIDJSON)
 #include "json.hpp"
+#endif
 
 #define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
 #include "catch.hpp"
@@ -474,7 +476,7 @@ TEST_CASE("image-uri-spaces", "[issue-236]") {
     }
     REQUIRE(true == ret);
     REQUIRE(err.empty());
-    REQUIRE(!warn.empty());  // relative image path won't exist in tests/
+    REQUIRE(warn.empty());
     REQUIRE(saved.images.size() == model.images.size());
 
     // The image uri in CubeImageUriMultipleSpaces.gltf is not encoded and
@@ -662,10 +664,11 @@ TEST_CASE("serialize-image-callback", "[issue-394]") {
 
   auto writer = [](const std::string *basepath, const std::string *filename,
                    const tinygltf::Image *image, bool embedImages,
-                   const tinygltf::URICallbacks *uri_cb, std::string *out_uri,
-                   void *user_pointer) -> bool {
+                   const tinygltf::FsCallbacks* fs, const tinygltf::URICallbacks *uri_cb,
+                   std::string *out_uri, void *user_pointer) -> bool {
     (void)basepath;
     (void)image;
+    (void)fs;
     (void)uri_cb;
     REQUIRE(*filename == "foo");
     REQUIRE(embedImages == true);
@@ -699,12 +702,13 @@ TEST_CASE("serialize-image-failure", "[issue-394]") {
 
   auto writer = [](const std::string *basepath, const std::string *filename,
                    const tinygltf::Image *image, bool embedImages,
-                   const tinygltf::URICallbacks *uri_cb, std::string *out_uri,
-                   void *user_pointer) -> bool {
+                   const tinygltf::FsCallbacks* fs, const tinygltf::URICallbacks *uri_cb,
+                   std::string *out_uri, void *user_pointer) -> bool {
     (void)basepath;
     (void)filename;
     (void)image;
     (void)embedImages;
+    (void)fs;
     (void)uri_cb;
     (void)out_uri;
     (void)user_pointer;
@@ -756,6 +760,194 @@ TEST_CASE("load-issue-416-model", "[issue-416]") {
   REQUIRE(true == ret);
 }
 
+TEST_CASE("reject-unsafe-paths", "[security]") {
+  tinygltf::TinyGLTF ctx;
+
+  SECTION("parent-directory reference is rejected") {
+    tinygltf::Model model;
+    std::string err;
+    std::string warn;
+
+    const std::string gltf = R"({
+      "asset": {"version": "2.0"},
+      "buffers": [
+        {"uri": "../secret.bin", "byteLength": 4}
+      ]
+    })";
+
+    bool ret = ctx.LoadASCIIFromString(&model, &err, &warn, gltf.c_str(),
+                                       static_cast<unsigned int>(gltf.size()),
+                                       ".");
+    REQUIRE_FALSE(ret);
+    REQUIRE_THAT(err, Catch::Contains("Rejected unsafe filename"));
+  }
+
+  SECTION("absolute path is rejected") {
+    tinygltf::Model model;
+    std::string err;
+    std::string warn;
+
+    const std::string gltf = R"({
+      "asset": {"version": "2.0"},
+      "buffers": [
+        {"uri": "/tmp/secret.bin", "byteLength": 4}
+      ]
+    })";
+
+    bool ret = ctx.LoadASCIIFromString(&model, &err, &warn, gltf.c_str(),
+                                       static_cast<unsigned int>(gltf.size()),
+                                       ".");
+    REQUIRE_FALSE(ret);
+    REQUIRE_THAT(err, Catch::Contains("Rejected unsafe filename"));
+  }
+}
+
+TEST_CASE("data-uri-size-limit", "[security]") {
+  tinygltf::TinyGLTF ctx;
+  ctx.SetMaxDataURISize(16);  // small limit to exercise rejection path.
+
+  const std::string payload(24, 'A');  // decodes to 18 bytes.
+  const std::string data_uri =
+      "data:application/octet-stream;base64," + payload;
+  const std::string gltf = R"({
+    "asset": {"version": "2.0"},
+    "buffers": [
+      {"uri": ")" + data_uri + R"(", "byteLength": 18}
+    ]
+  })";
+
+  tinygltf::Model model;
+  std::string err;
+  std::string warn;
+
+  bool ret = ctx.LoadASCIIFromString(&model, &err, &warn, gltf.c_str(),
+                                     static_cast<unsigned int>(gltf.size()),
+                                     ".");
+  REQUIRE_FALSE(ret);
+  REQUIRE_THAT(err,
+               Catch::Contains("Data URI for buffer exceeds maximum allowed"));
+
+  SECTION("ceiling estimation rejects near-limit payloads") {
+    tinygltf::TinyGLTF ctx2;
+    ctx2.SetMaxDataURISize(4);
+    // 8 chars base64 -> 6 decoded bytes, should be rejected by max size.
+    const std::string small_payload(8, 'A');
+    const std::string small_uri =
+        "data:application/octet-stream;base64," + small_payload;
+    const std::string gltf_small = R"({
+      "asset": {"version": "2.0"},
+      "buffers": [
+        {"uri": ")" + small_uri + R"(", "byteLength": 6}
+      ]
+    })";
+
+    tinygltf::Model m2;
+    std::string err2;
+    std::string warn2;
+    bool ok = ctx2.LoadASCIIFromString(
+        &m2, &err2, &warn2, gltf_small.c_str(),
+        static_cast<unsigned int>(gltf_small.size()), ".");
+    REQUIRE_FALSE(ok);
+    REQUIRE_THAT(err2,
+                 Catch::Contains("Data URI for buffer exceeds maximum allowed"));
+  }
+}
+
+TEST_CASE("max-external-file-size", "[security]") {
+  tinygltf::TinyGLTF ctx;
+  ctx.SetMaxExternalFileSize(16);  // small limit to force rejection.
+
+  const std::string gltf_path = "oversize.gltf";
+  {
+    std::ofstream ofs(gltf_path, std::ios::binary);
+    ofs << R"({"asset":{"version":"2.0"}})" << std::string(64, ' ');
+  }
+
+  tinygltf::Model model;
+  std::string err;
+  std::string warn;
+  bool ok = ctx.LoadASCIIFromFile(&model, &err, &warn, gltf_path);
+  REQUIRE_FALSE(ok);
+  REQUIRE_THAT(err,
+               Catch::Contains("exceeds maximum allowed file size"));
+  std::remove(gltf_path.c_str());
+
+  const std::string glb_path = "oversize.glb";
+  {
+    std::ofstream ofs(glb_path, std::ios::binary);
+    ofs << std::string(32, '\0');
+  }
+
+  err.clear();
+  warn.clear();
+  ok = ctx.LoadBinaryFromFile(&model, &err, &warn, glb_path);
+  REQUIRE_FALSE(ok);
+  REQUIRE_THAT(err,
+               Catch::Contains("exceeds maximum allowed file size"));
+  std::remove(glb_path.c_str());
+}
+
+TEST_CASE("max-size-in-memory", "[security]") {
+  tinygltf::TinyGLTF ctx;
+  ctx.SetMaxExternalFileSize(16);
+
+  // LoadASCIIFromString should reject oversized input.
+  {
+    tinygltf::Model model;
+    std::string err;
+    std::string warn;
+    std::string large_json(20, ' ');
+    bool ok = ctx.LoadASCIIFromString(
+        &model, &err, &warn, large_json.c_str(),
+        static_cast<unsigned int>(large_json.size()), ".");
+    REQUIRE_FALSE(ok);
+    REQUIRE_THAT(err, Catch::Contains("Input size exceeds maximum"));
+  }
+
+  // LoadBinaryFromMemory should reject oversized input even before parsing.
+  {
+    tinygltf::Model model;
+    std::string err;
+    std::string warn;
+    std::array<unsigned char, 32> bytes{};
+    // Craft minimal glTF header; size still exceeds limit and should be
+    // rejected early.
+    bytes[0] = 'g'; bytes[1] = 'l'; bytes[2] = 'T'; bytes[3] = 'F';
+    bytes[4] = 2; // version little-endian
+    bool ok = ctx.LoadBinaryFromMemory(&model, &err, &warn, bytes.data(),
+                                       static_cast<unsigned int>(bytes.size()),
+                                       ".");
+    REQUIRE_FALSE(ok);
+    REQUIRE_THAT(err, Catch::Contains("Input size exceeds maximum"));
+  }
+
+  SECTION("GLB length mismatch is rejected in strict mode") {
+    tinygltf::TinyGLTF ctx_strict;
+    ctx_strict.SetParseStrictness(tinygltf::ParseStrictness::Strict);
+
+    // Construct a minimal GLB with length field smaller than actual buffer.
+    std::array<unsigned char, 32> glb{};
+    glb[0] = 'g'; glb[1] = 'l'; glb[2] = 'T'; glb[3] = 'F';
+    glb[4] = 2; // version
+    uint32_t length = 24; // claimed length (smaller than actual buffer size)
+    memcpy(&glb[8], &length, 4);
+    uint32_t json_len = 4;
+    memcpy(&glb[12], &json_len, 4);
+    uint32_t json_fmt = 0x4E4F534A; // "JSON"
+    memcpy(&glb[16], &json_fmt, 4);
+
+    tinygltf::Model model;
+    std::string err;
+    std::string warn;
+    bool ok = ctx_strict.LoadBinaryFromMemory(
+        &model, &err, &warn, glb.data(),
+        static_cast<unsigned int>(glb.size()), ".");
+    REQUIRE_FALSE(ok);
+    REQUIRE_THAT(err,
+                 Catch::Contains("Length field does not match data size"));
+  }
+}
+
 TEST_CASE("serialize-empty-node", "[issue-457]") {
   tinygltf::Model m;
   // Add default constructed node to model
@@ -926,3 +1118,322 @@ TEST_CASE("zero-sized-bin-chunk-glb", "[issue-440]") {
 
   REQUIRE(true == ret);
 }
+
+TEST_CASE("serialize-node-emitter", "[KHR_audio]") {
+  // Stream to serialize to
+  std::stringstream os;
+
+  {
+    tinygltf::Model m;
+    // Create a default audio emitter
+    m.audioEmitters.resize(1);
+    // Create a single node
+    m.nodes.resize(1);
+    // The node references the single emitter
+    m.nodes[0].emitter = 0;
+    // Create a single scene
+    m.scenes.resize(1);
+    // Make the scene reference the single node
+    m.scenes[0].nodes.push_back(0);
+
+    // Serialize model to output stream
+    tinygltf::TinyGLTF ctx;
+    bool ret = ctx.WriteGltfSceneToStream(&m, os, false, false);
+    REQUIRE(true == ret);
+  }
+
+  {
+    tinygltf::Model m;
+    tinygltf::TinyGLTF ctx;
+    // Parse the serialized model
+    bool ok = ctx.LoadASCIIFromString(&m, nullptr, nullptr, os.str().c_str(), os.str().size(), "");
+    REQUIRE(true == ok);
+
+    // Make sure the single scene is there
+    REQUIRE(1 == m.scenes.size());
+    // Make sure all three nodes are there
+    REQUIRE(1 == m.nodes.size());
+    // Make sure the single root node of the scene is there
+    REQUIRE(1 == m.scenes[0].nodes.size());
+    REQUIRE(0 == m.scenes[0].nodes[0]);
+    // Retrieve the scene root node
+    const tinygltf::Node& node = m.nodes[m.scenes[0].nodes[0]];
+    // Make sure the single root node has both lod nodes
+    REQUIRE(0 == node.emitter);
+  }
+}
+
+TEST_CASE("serialize-lods", "[lods]") {
+  // Stream to serialize to
+  std::stringstream os;
+
+  {
+    tinygltf::Model m;
+
+    m.nodes.resize(4);
+    // Add Node 1 and Node 2 as lods to Node 0
+    m.nodes[0].lods.push_back(1);
+    m.nodes[0].lods.push_back(2);
+
+    // Add Material 1 and Material 2 as lods to Material 0
+    m.materials.resize(4);
+    m.materials[0].lods.push_back(1);
+    m.materials[0].lods.push_back(2);
+
+    tinygltf::Scene scene;
+    // Scene uses Node 0 and 3 as root node
+    scene.nodes.push_back(0);
+    scene.nodes.push_back(3);
+    // Add scene to the model
+    m.scenes.push_back(scene);
+
+    // Serialize model to output stream
+    tinygltf::TinyGLTF ctx;
+    bool ret = ctx.WriteGltfSceneToStream(&m, os, false, false);
+    REQUIRE(true == ret);
+  }
+
+  {
+    tinygltf::Model m;
+    tinygltf::TinyGLTF ctx;
+    // Parse the serialized model
+    bool ok = ctx.LoadASCIIFromString(&m, nullptr, nullptr, os.str().c_str(), os.str().size(), "");
+    REQUIRE(true == ok);
+    // Make sure the model's used extensions hold MSFT_lod
+    CHECK(m.extensionsUsed.size() == 1);
+    CHECK(m.extensionsUsed[0].compare("MSFT_lod") == 0);
+    // MSFT_lod is not a required extension
+    CHECK(m.extensionsRequired.size() == 0);
+
+    // Make sure all four materials are there
+    REQUIRE(4 == m.materials.size());
+    // Make sure the first material has both lod materials
+    REQUIRE(2 == m.materials[0].lods.size());
+    // Make sure the order is still the same after serialization and deserialization
+    CHECK(1 == m.materials[0].lods[0]);
+    CHECK(2 == m.materials[0].lods[1]);
+    // Make sure the material with lods exposes the MSFT_lod extension
+    CHECK(m.materials[0].extensions.size() == 1);
+    CHECK(m.materials[0].extensions.count("MSFT_lod") == 1);
+    // Make sure the last material has no lod materials
+    CHECK(0 == m.materials[3].lods.size());
+    // Make sure the material without lods does not exposes the MSFT_lod extension
+    CHECK(m.materials[3].extensions.size() == 0);
+    CHECK(m.materials[3].extensions.count("MSFT_lod") == 0);
+
+    // Make sure the single scene is there
+    REQUIRE(1 == m.scenes.size());
+    // Make sure all four nodes are there
+    REQUIRE(4 == m.nodes.size());
+    // Make sure the two root nodes of the scene are there
+    REQUIRE(2 == m.scenes[0].nodes.size());
+    REQUIRE(0 == m.scenes[0].nodes[0]);
+    REQUIRE(3 == m.scenes[0].nodes[1]);
+    // Retrieve the node with lods
+    const tinygltf::Node& nodeWithLods = m.nodes[m.scenes[0].nodes[0]];
+    // Make sure the node has both lod nodes
+    REQUIRE(2 == nodeWithLods.lods.size());
+    // Make sure the order is still the same after serialization and deserialization
+    CHECK(1 == nodeWithLods.lods[0]);
+    CHECK(2 == nodeWithLods.lods[1]);
+    // Make sure the node with lods exposes the MSFT_lod extension
+    CHECK(nodeWithLods.extensions.size() == 1);
+    CHECK(nodeWithLods.extensions.count("MSFT_lod") == 1);
+    // Retrieve the node without lods
+    const tinygltf::Node& nodeWithoutLods = m.nodes[m.scenes[0].nodes[1]];
+    // Make sure the node has no lod nodes
+    CHECK(0 == nodeWithoutLods.lods.size());
+    // Make sure the node without lods does not exposes the MSFT_lod extension
+    CHECK(nodeWithoutLods.extensions.size() == 0);
+    CHECK(nodeWithoutLods.extensions.count("MSFT_lod") == 0);
+  }
+}
+
+TEST_CASE("write-image-issue", "[issue-473]") {
+  std::string err;
+  std::string warn;
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+  bool ok = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/Cube/Cube.gltf");
+  REQUIRE(ok);
+  REQUIRE(err.empty());
+  REQUIRE(warn.empty());
+
+  REQUIRE(model.images.size() == 2);
+  REQUIRE(model.images[0].uri == "Cube_BaseColor.png");
+  REQUIRE(model.images[1].uri == "Cube_MetallicRoughness.png");
+
+  REQUIRE_FALSE(model.images[0].image.empty());
+  REQUIRE_FALSE(model.images[1].image.empty());
+
+  ok = ctx.WriteGltfSceneToFile(&model, "Cube.gltf");
+  REQUIRE(ok);
+
+  for (const auto& image : model.images) {
+    std::fstream file(image.uri);
+    CHECK(file.good());
+  }
+}
+
+TEST_CASE("images-as-is", "[issue-487]") {
+  std::string err;
+  std::string warn;
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+  ctx.SetImagesAsIs(true);
+  bool ok = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/Cube/Cube.gltf");
+  REQUIRE(ok);
+  REQUIRE(err.empty());
+  REQUIRE(warn.empty());
+
+  for (const auto& image : model.images) {
+    CHECK(image.as_is == true);
+    CHECK_FALSE(image.uri.empty());
+    CHECK_FALSE(image.image.empty());
+
+#ifndef TINYGLTF_NO_STB_IMAGE
+    // Make sure we can decode the images
+    int w = -1, h = -1, component = -1;
+    unsigned char *data = stbi_load_from_memory(image.image.data(), static_cast<int>(image.image.size()), &w, &h, &component, 0);
+    CHECK(data != nullptr);
+    CHECK(w == 512);
+    CHECK(h == 512);
+    CHECK(component >= 3);
+    stbi_image_free(data);
+#endif
+  }
+
+  // Write glTF model to disk, and images as separate files
+  {
+    ok = ctx.WriteGltfSceneToFile(&model, "Cube_with_image_files.gltf");
+    REQUIRE(ok);
+
+    // All the images should have been written to disk with their original data
+    for (const auto& image : model.images)  {
+      // Make sure the image files exist
+      std::fstream file(image.uri);
+      CHECK(file.good());
+#ifndef TINYGLTF_NO_STB_IMAGE
+      // Make sure we can load the images
+      int w = -1, h = -1, component = -1;
+      unsigned char *data = stbi_load(image.uri.c_str(), &w, &h, &component, 0);
+      CHECK(data != nullptr);
+      CHECK(w == 512);
+      CHECK(h == 512);
+      CHECK(component >= 3);
+      stbi_image_free(data);
+#endif
+    }
+  }
+
+  // Write glTF model to disk, and embed images as data URIs
+  {
+    ok = ctx.WriteGltfSceneToFile(&model, "Cube_with_embedded_images.gltf", true, false);
+    REQUIRE(ok);
+
+    // Load above model again, and check if the images are loaded properly
+    tinygltf::Model embeddedImages;
+    ctx.SetImagesAsIs(false);
+    bool ok = ctx.LoadASCIIFromFile(&embeddedImages, &err, &warn, "Cube_with_embedded_images.gltf");
+    REQUIRE(ok);
+    REQUIRE(err.empty());
+    REQUIRE(warn.empty());
+
+    for (const auto& image : embeddedImages.images) {
+      CHECK(image.as_is == false);
+      CHECK_FALSE(image.mimeType.empty());
+      CHECK_FALSE(image.image.empty());
+      CHECK(image.width == 512);
+      CHECK(image.height == 512);
+      CHECK(image.component >= 3);
+    }
+  }
+
+  // Write glTF model to disk, as GLB
+  {
+    ok = ctx.WriteGltfSceneToFile(&model, "Cube.glb", true, true, true, true);
+    REQUIRE(ok);
+
+    // Load above model again, and check if the images are loaded properly
+    tinygltf::Model glbModel;
+    ctx.SetImagesAsIs(false);
+    bool ok = ctx.LoadBinaryFromFile(&glbModel, &err, &warn, "Cube.glb");
+    REQUIRE(ok);
+    REQUIRE(err.empty());
+    REQUIRE(warn.empty());
+
+    for (const auto& image : glbModel.images) {
+      CHECK(image.as_is == false);
+      CHECK_FALSE(image.mimeType.empty());
+      CHECK_FALSE(image.image.empty());
+      CHECK(image.width == 512);
+      CHECK(image.height == 512);
+      CHECK(image.component >= 3);
+    }
+  }
+}
+
+TEST_CASE("inverse-bind-matrices-optional", "[issue-492]") {
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+  std::string err;
+  std::string warn;
+
+  bool ret = ctx.LoadBinaryFromFile(&model, &err, &warn, "issue-492.glb");
+  if (!warn.empty()) {
+    std::cout << "WARN:" << warn << std::endl;
+  }
+  if (!err.empty()) {
+    std::cerr << "ERR:" << err << std::endl;
+  }
+
+  REQUIRE(true == ret);
+  REQUIRE(err.empty());
+}
+
+bool LoadImageData(tinygltf::Image * /* image */, const int /* image_idx */, std::string * /* err */,
+                   std::string * /* warn */, int /* req_width */, int /* req_height */,
+                   const unsigned char * /* bytes */, int /* size */, void * /*user_data */) {
+    return true;
+}
+
+bool WriteImageData(const std::string * /* basepath */, const std::string * /* filename */,
+                    const tinygltf::Image *image, bool /* embedImages */,
+                    const tinygltf::FsCallbacks * /* fs_cb */, const tinygltf::URICallbacks * /* uri_cb */,
+                    std::string * /* out_uri */, void * user_pointer) {
+    REQUIRE(user_pointer != nullptr);
+    auto counter = static_cast<int*>(user_pointer);
+    *counter = *counter + 1;
+    return true;
+}
+
+TEST_CASE("empty-images-not-written", "[issue-495]") {
+  std::string err;
+  std::string warn;
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+
+  ctx.SetImageLoader(LoadImageData, nullptr);
+  bool ok = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/Cube/Cube.gltf");
+  REQUIRE(ok);
+  REQUIRE(err.empty());
+  REQUIRE(warn.empty());
+
+  CHECK(model.images.size() == 2);
+  for (const auto& image : model.images) {
+    // No data loaded or decoded
+    CHECK(image.image.empty());
+    // The URI is kept
+    CHECK_FALSE(image.uri.empty());
+    // The URI should not be a data URI
+    CHECK(image.uri.find("data:") != 0);
+  }
+
+  // Now write the loaded model
+  int counter = 0;
+  ctx.SetImageWriter(WriteImageData, &counter);
+  ok = ctx.WriteGltfSceneToFile(&model, "issue-495-external.gltf");
+  CHECK(ok);
+  // WriteImageData should be invoked for both images
+  CHECK(counter == 2);
+}