Make lodepng optional.

Merge pull request #133 from Ybalrid/lodepng
fix ci build of example
2026-06-09 19:53:49 +00:00 · 2019-01-14 21:33:56 +09:00 · 2019-01-11 02:29:29 +09:00 · 2019-01-10 18:19:20 +00:00 · 2019-01-07 02:27:28 +09:00 · 2019-01-07 01:05:12 +09:00
39 changed files with 9517 additions and 20032 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -67,5 +67,4 @@ imgui.ini
 loader_example
 tests/tester
 tests/tester_noexcept
-tests/issue-97.gltf

--- a/.travis.yml
+++ b/.travis.yml
@@ -42,10 +42,6 @@ script:
  - ${CC} -v
  - ${CXX} ${EXTRA_CXXFLAGS} -std=c++11 -Wall -g -o loader_example loader_example.cc
  - ./loader_example ./models/Cube/Cube.gltf
-  - cd tests
-  - make
-  - ./tester
-  - ./tester_noexcept
-  - cd ../examples/raytrace
+  - cd examples/raytrace
  - ../../premake5 gmake
  - make
--- a/examples/common/LICENSE.lodepng
+++ b/examples/common/LICENSE.lodepng
--- a/6
+++ b/6
@@ -2,12 +2,8 @@
 # Use this for strict compilation check(will work on clang 3.8+)
 #EXTRA_CXXFLAGS := -fsanitize=address -Wall -Werror -Weverything -Wno-c++11-long-long -Wno-c++98-compat

-# With draco
-# EXTRA_CXXFLAGS := -I../draco/src/ -I../draco/build -DTINYGLTF_ENABLE_DRACO -L../draco/build
-# EXTRA_LINKFLAGS := -L../draco/build/ -ldracodec -ldraco
-
 all:
-	clang++  $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o loader_example loader_example.cc $(EXTRA_LINKFLAGS)
+	clang++  $(EXTRA_CXXFLAGS) -std=c++11 -g -O0 -o loader_example loader_example.cc

 lint:
 	deps/cpplint.py tiny_gltf.h
--- a/README.md
+++ b/README.md
@@ -3,15 +3,11 @@
 `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.
-If you are looking for old, C++03 version, please use `devel-picojson` branch.
+If you are looking for old, C++03 version, please use `devel-picojson` branch.  

 ## Status

- - 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)!
+v2.0.0 release(22 Aug, 2018)! 

 ## Builds

@@ -42,31 +38,19 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
 * Image(Using stb_image)
  * [x] Parse BASE64 encoded embedded image data(DataURI).
  * [x] Load external image file.
-  * [x] Load PNG(8bit and 16bit)
-  * [x] Load JPEG(8bit only)
-  * [x] Load BMP
-  * [x] Load GIF
+  * [x] PNG(8bit only)
+  * [x] JPEG(8bit only)
+  * [x] BMP
+  * [x] GIF
  * [x] Custom Image decoder callback(e.g. for decoding OpenEXR image)
-* Morph traget
-  * [x] Sparse accessor
-* Load glTF from memory
+* Load from memory
 * Custom callback handler
  * [x] Image load
-  * [x] Image save
-* Extensions
-  * [x] Draco mesh decoding
-
-## Note on extension property
-
-In extension(`ExtensionMap`), JSON number value is parsed as int or float(number) and stored as `tinygltf::Value` object. If you want a floating point value from `tinygltf::Value`, use `GetNumberAsDouble()` method.
-
-`IsNumber()` returns true if the underlying value is an int value or a floating point value.

 ## Examples

 * [glview](examples/glview) : Simple glTF geometry viewer.
 * [validator](examples/validator) : Simple glTF validator with JSON schema.
-* [basic](examples/basic) : Basic glTF viewer with texturing support.

 ## Projects using TinyGLTF

@@ -74,21 +58,19 @@ In extension(`ExtensionMap`), JSON number value is parsed as int or float(number
 * Physical based rendering with Vulkan using glTF 2.0 models https://github.com/SaschaWillems/Vulkan-glTF-PBR
 * GLTF loader plugin for OGRE 2.1. Support for PBR materials via HLMS/PBS https://github.com/Ybalrid/Ogre_glTF
 * [TinyGltfImporter](http://doc.magnum.graphics/magnum/classMagnum_1_1Trade_1_1TinyGltfImporter.html) plugin for [Magnum](https://github.com/mosra/magnum), a lightweight and modular C++11/C++14 graphics middleware for games and data visualization.
-* [Diligent Engine](https://github.com/DiligentGraphics/DiligentEngine) - A modern cross-platform low-level graphics library and rendering framework
 * Your projects here! (Please send PR)

 ## TODOs

 * [ ] 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
-  * [ ] Open3DGC?
-* [x] Support `extensions` and `extras` property
+  * [ ] Load Draco compressed mesh
+* [ ] Support `extensions` and `extras` property
 * [ ] HDR image?
  * [ ] OpenEXR extension through TinyEXR.
-* [ ] 16bit PNG support in Serialization
-* [ ] Write example and tests for `animation` and `skin`
+* [ ] Write example and tests for `animation` and `skin` 
+  * [ ] Skinning
+  * [ ] Morph targets

 ## Licenses

@@ -100,6 +82,7 @@ TinyGLTF uses the following third party libraries.
 * base64 : Copyright (C) 2004-2008 René Nyffenegger
 * stb_image.h : v2.08 - public domain image loader - [Github link](https://github.com/nothings/stb/blob/master/stb_image.h)
 * stb_image_write.h : v1.09 - public domain image writer - [Github link](https://github.com/nothings/stb/blob/master/stb_image_write.h)
+* lodepng : Copyright (c) 2005-2018 Lode Vandevenne. zlib license. https://lodev.org/lodepng/


 ## Build and example
@@ -118,13 +101,13 @@ Copy `stb_image.h`, `stb_image_write.h`, `json.hpp` and `tiny_gltf.h` to your pr

 using namespace tinygltf;

-Model model;
+Model model; 
 TinyGLTF loader;
 std::string err;
 std::string warn;
-
+  
 bool ret = loader.LoadASCIIFromFile(&model, &err, &warn, argv[1]);
-//bool ret = loader.LoadBinaryFromFile(&model, &err, &warn, argv[1]); // for binary glTF(.glb)
+//bool ret = loader.LoadBinaryFromFile(&model, &err, &warn, argv[1]); // for binary glTF(.glb) 

 if (!warn.empty()) {
  printf("Warn: %s\n", warn.c_str());
@@ -145,15 +128,9 @@ if (!ret) {
 * `TINYGLTF_NOEXCEPTION` : Disable C++ exception in JSON parsing. You can use `-fno-exceptions` or by defining the symbol `JSON_NOEXCEPTION` and `TINYGLTF_NOEXCEPTION`  to fully remove C++ exception codes when compiling TinyGLTF.
 * `TINYGLTF_NO_STB_IMAGE` : Do not load images with stb_image. Instead use `TinyGLTF::SetImageLoader(LoadimageDataFunction LoadImageData, void *user_data)` to set a callback for loading images.
 * `TINYGLTF_NO_STB_IMAGE_WRITE` : Do not write images with stb_image_write. Instead use `TinyGLTF::SetImageWriter(WriteimageDataFunction WriteImageData, void *user_data)` to set a callback for writing images.
-* `TINYGLTF_NO_EXTERNAL_IMAGE` : Do not try to load external image file. This option would be helpful if you do not want to load image files during glTF parsing.
+* `TINYGLTF_NO_EXTERNAL_IMAGE` : Do not try to load external image file. This option woulde be helpful if you do not want load image file during glTF parsing.
 * `TINYGLTF_ANDROID_LOAD_FROM_ASSETS`: Load all files from packaged app assets instead of the regular file system. **Note:** You must pass a valid asset manager from your android app to `tinygltf::asset_manager` beforehand.
-* `TINYGLTF_ENABLE_DRACO`: Enable Draco compression. User must provide include path and link correspnding libraries in your project file.
-* `TINYGLTF_NO_INCLUDE_JSON `: Disable including `json.hpp` from within `tiny_gltf.h` because it has been already included before or you want to include it using custom path before including `tiny_gltf.h`.
-* `TINYGLTF_NO_INCLUDE_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_CPP14` : Use C++14 feature(requires C++14 compiler). This may give better performance than C++11.
-
+* `TINYGLTF_USE_LODEPNG` : Load 16bit PNG image with lodepng(Valid when `TINYGLTF_NO_STB_IMAGE` was **not** defined). Must defined `LODEPNG_IMPLEMENTATION` in one .cc.

 ### Saving gltTF 2.0 model
 * [ ] Buffers.
@@ -195,5 +172,5 @@ $ ./tester_noexcept

 * json.hpp : Licensed under the MIT License <http://opensource.org/licenses/MIT>. Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
 * stb_image : Public domain.
+* lodepng : zlib license
 * 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/
--- a/examples/basic/README.md
+++ b/examples/basic/README.md
@@ -1,21 +0,0 @@
-# Basic glTF viewer
-
-## Requirements
-
-* glew
-* glfw3
-* premake5(linux)
-* OpenGL 3.3+ GPU
-
-## Build on Linux and macOS
-
-```
-$ premake5 gmake
-$ make
-```
-
-## Build on Visual Studio
-
-Plese use solution file located at `basic` folder.
-
-
--- a/examples/basic/main.cpp
+++ b/examples/basic/main.cpp
--- a/examples/basic/premake5.lua
+++ b/examples/basic/premake5.lua
@@ -1,44 +0,0 @@
-solution "basic_viewer"
-   -- location ( "build" )
-   configurations { "Debug", "Release" }
-   platforms {"native", "x64", "x32"}
-   
-   project "basic_viewer"
-
-      kind "ConsoleApp"
-      language "C++"
-	  cppdialect "C++11"
-      files { "main.cpp", "shaders.cpp", "window.cpp" }
-      includedirs { "./" }
-      includedirs { "../../" }
-      includedirs { "../common/glm" }
-
-      configuration { "linux" }
-         linkoptions { "`pkg-config --libs glfw3`" }
-         links { "GL", "GLU", "m", "GLEW", "X11", "Xrandr", "Xinerama", "Xi", "Xxf86vm", "Xcursor", "dl" }
-
-      configuration { "windows" }
-         -- Edit path to glew and GLFW3 fit to your environment.
-         includedirs { "../../../../local/glew-1.13.0/include/" }
-         includedirs { "../../../../local/glfw-3.2.bin.WIN32/include/" }
-         libdirs { "../../../../local/glew-1.13.0/lib/Release/Win32/" }
-         libdirs { "../../../../local/glfw-3.2.bin.WIN32/lib-vc2013/" }
-         links { "glfw3", "gdi32", "winmm", "user32", "glew32", "glu32","opengl32", "kernel32" }
-         defines { "_CRT_SECURE_NO_WARNINGS" }
-
-      configuration { "macosx" }
-         includedirs { "/usr/local/include" }
-         buildoptions { "-Wno-deprecated-declarations" }
-         libdirs { "/usr/local/lib" }
-         links { "glfw", "GLEW" }
-         linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" }
-
-      configuration "Debug"
-         defines { "DEBUG" }
-		 symbols "On"
-		 warnings "Extra"
-
-      configuration "Release"
-         defines { "NDEBUG" }
-		 optimize "On"
-		 warnings "Extra"
--- a/examples/basic/shaders.cpp
+++ b/examples/basic/shaders.cpp
@@ -19,7 +19,7 @@ uniform vec3 sun_color; \n\
 out vec4 color;\n\
 void main() {\n\
 	float lum = max(dot(normal, normalize(sun_position)), 0.0);\n\
-	color = texture(tex, texcoord) * vec4((0.3 + 0.7 * lum) * sun_color, 1.0);\n\
+	color = texture2D(tex, texcoord) * vec4((0.3 + 0.7 * lum) * sun_color, 1.0);\n\
 }\n\
 ";

--- a/examples/common/lodepng.h
+++ b/examples/common/lodepng.h
--- a/examples/common/tinyexr.h
+++ b/examples/common/tinyexr.h
--- a/examples/gltfutil/CMakeLists.txt
+++ b/examples/gltfutil/CMakeLists.txt
@@ -4,10 +4,9 @@ project(gltfutil)
 set(CMAKE_CXX_STANDARD 11)

 include_directories(../../)
-include_directories(../common/)

 file(GLOB gltfutil_sources *.cc *.h)
-add_executable(gltfutil ${gltfutil_sources} ../common/lodepng.cpp)
+add_executable(gltfutil ${gltfutil_sources})

 install ( TARGETS
  gltfutil
--- a/examples/gltfutil/gltfuilconfig.h
+++ b/examples/gltfutil/gltfuilconfig.h
@@ -49,7 +49,6 @@ struct configuration {
  cli_action action = cli_action::not_set;
  texture_dumper::texture_output_format requested_format =
      texture_dumper::texture_output_format::not_specified;
-  bool use_exr = false;

  bool has_output_dir;
  bool is_valid() {
--- a/examples/gltfutil/main.cc
+++ b/examples/gltfutil/main.cc
@@ -11,9 +11,6 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb_image_write.h"

-#define TINYEXR_IMPLEMENTATION
-#include "tinyexr.h"
-
 namespace gltfutil {
 int usage(int ret = 0) {
  using std::cout;
@@ -23,9 +20,8 @@ int usage(int ret = 0) {
          "[path to output directory])\n\n"
       //<< "\t\t -i: start in interactive mode\n"
       << "\t\t -d: dump enclosed content (image assets)\n"
-       << "\t\t -f: file format for image output\n"
-       << "\t\t -o: ouptput directory path\n"
-       << "\t\t -e: Use OpenEXR format for 16bit image\n"
+       << "\t\t -f: file format for image output"
+       << "\t\t -o: ouptput directory path"
       << "\t\t -h: print this help\n";
  return ret;
 }
@@ -48,9 +44,6 @@ int parse_args(int argc, char** argv) {
          config.mode = ui_mode::cli;
          config.action = cli_action::dump;
          break;
-        case 'e':
-          config.use_exr = true;
-          break;
        case 'i':
          config.mode = ui_mode::interactive;
          break;
@@ -104,11 +97,6 @@ int parse_args(int argc, char** argv) {

        case cli_action::dump: {
          texture_dumper dumper(model);
-
-          if (config.use_exr) {
-            dumper.set_use_exr(true);
-          }
-
          if (config.requested_format !=
              texture_dumper::texture_output_format::not_specified)
            dumper.set_output_format(config.requested_format);
--- a/examples/gltfutil/texture_dumper.cc
+++ b/examples/gltfutil/texture_dumper.cc
@@ -1,84 +1,15 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>

 #include "stb_image_write.h"
 #include "texture_dumper.h"

-#include "lodepng.h"  // ../common
-
-#include "tinyexr.h"
-
 #include <tiny_gltf.h>

 using namespace gltfutil;
 using namespace tinygltf;
 using std::cout;

-static LodePNGColorType GetLodePNGColorType(int channels) {
-  if (channels == 1) {
-    return LodePNGColorType::LCT_GREY;
-  } else if (channels == 2) {
-    return LodePNGColorType::LCT_GREY_ALPHA;
-  } else if (channels == 3) {
-    return LodePNGColorType::LCT_RGB;
-  } else if (channels == 4) {
-    return LodePNGColorType::LCT_RGBA;
-  } else {
-    std::cerr << "??? unsupported channels " << channels << "\n";
-    return LodePNGColorType::LCT_RGB;  // FIXME(syoyo): Raise error
-  }
-}
-
-static void ToBigEndian(std::vector<uint8_t>* image) {
-
-  assert(image->size() % 2 == 0);
-
-  union {
-    unsigned int i;
-    char c[4];
-  } bint = {0x01020304};
-
-  bool is_big_endian = (bint.c[0] == 1);
-
-  if (is_big_endian) {
-    return;
-  }
-
-  uint16_t *ptr = reinterpret_cast<uint16_t *>(image->data());
-  size_t n = image->size() / 2;
-
-  for (size_t i = 0; i < n; i++) {
-    ptr[i] = ((0xFF00 & ptr[i]) >> 8) | ((0x00FF & ptr[i]) << 8);
-  }
-}
-
-static bool Save16bitImageAsEXR(const std::string& filename,
-                                const tinygltf::Image& image) {
-  assert(image.bits == 16);
-
-  std::vector<float> buf(image.width * image.height * image.component);
-
-  // widen to float image.
-  // Store as is(i.e, pixel value range is [0.0, 65535.0])
-  const unsigned short* ptr =
-      reinterpret_cast<const unsigned short*>(image.image.data());
-  for (size_t i = 0; i < image.width * image.height * image.component; i++) {
-    buf[i] = float(ptr[i]);
-  }
-
-  const char* err = nullptr;
-  int ret = SaveEXR(buf.data(), image.width, image.height, image.component,
-                    /* save_as_fp16 */ 0, filename.c_str(), &err);
-
-  if (err) {
-    std::cerr << "EXR err: " << err << std::endl;
-    FreeEXRErrorMessage(err);
-    return false;
-  }
-
-  return (ret == TINYEXR_SUCCESS);
-}
-
 texture_dumper::texture_dumper(const Model& input)
    : model(input), configured_format(texture_output_format::png) {
  cout << "Texture dumper\n";
@@ -95,58 +26,26 @@ void texture_dumper::dump_to_folder(const std::string& path) {
    cout << "image name is: \"" << image.name << "\"\n";
    cout << "image size is: " << image.width << 'x' << image.height << '\n';
    cout << "pixel channel count :" << image.component << '\n';
-    cout << "pixel bit depth :" << image.bits << '\n';
-    std::string basename =
-        image.name.empty() ? std::to_string(index) : image.name;
+    std::string name = image.name.empty() ? std::to_string(index) : image.name;

-    unsigned char* bytes_to_write =
-        const_cast<unsigned char*>(image.image.data());
-
-    std::string filename;
    switch (configured_format) {
      case texture_output_format::png:
-        filename = path + "/" + basename + ".png";
-
-        if (this->use_exr) {
-          if (image.pixel_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
-            filename = path + "/" + basename + ".exr";
-          }
-        }
-
-        std::cout << "Image will be written to " << filename << '\n';
-
-        if (image.pixel_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
-          if (this->use_exr) {
-            bool ret = Save16bitImageAsEXR(filename, image);
-            assert(ret);
-          } else {
-            // Use lodepng to save 16bit PNG.
-            // NOTE(syoyo): `loadpng::encode` requires image data must be stored in big endian.
-            std::vector<uint8_t> tmp = image.image; // copy
-            ToBigEndian(&tmp);
-
-            unsigned ret = lodepng::encode(
-                filename, tmp.data(), image.width, image.height,
-                GetLodePNGColorType(image.component), /* bits */ 16);
-            assert(ret == 0);  // 0 = no err.
-          }
-        } else {
-          // TODO(syoyo): check status
-          stbi_write_png(filename.c_str(), image.width, image.height,
-                         image.component, bytes_to_write, 0);
-        }
+        name = path + "/" + name + ".png";
+        std::cout << "Image will be written to " << name << '\n';
+        stbi_write_png(name.c_str(), image.width, image.height, image.component,
+                       image.image.data(), 0);
        break;
      case texture_output_format::bmp:
-        filename = path + "/" + basename + ".bmp";
-        std::cout << "Image will be written to " << filename << '\n';
-        stbi_write_bmp(filename.c_str(), image.width, image.height,
-                       image.component, bytes_to_write);
+        std::cout << "Image will be written to " << name << '\n';
+        name = path + "/" + name + ".bmp";
+        stbi_write_bmp(name.c_str(), image.width, image.height, image.component,
+                       image.image.data());
        break;
      case texture_output_format::tga:
-        filename = path + "/" + basename + ".tga";
-        std::cout << "Image will be written to " << filename << '\n';
-        stbi_write_tga(filename.c_str(), image.width, image.height,
-                       image.component, bytes_to_write);
+        std::cout << "Image will be written to " << name << '\n';
+        name = path + "/" + name + ".tga";
+        stbi_write_tga(name.c_str(), image.width, image.height, image.component,
+                       image.image.data());
        break;
    }
  }
--- a/examples/gltfutil/texture_dumper.h
+++ b/examples/gltfutil/texture_dumper.h
@@ -12,15 +12,11 @@ class texture_dumper {
 private:
  const tinygltf::Model& model;
  texture_output_format configured_format;
-  bool use_exr = false; // Use EXR for 16bit image?

 public:
  texture_dumper(const tinygltf::Model& inputModel);
  void dump_to_folder(const std::string& path = "./");
  void set_output_format(texture_output_format format);
-  void set_use_exr(const bool value) {
-    use_exr = value;
-  }

  static texture_output_format get_fromat_from_string(const std::string& str);
 };
--- a/examples/glview/CMakeLists.txt
+++ b/examples/glview/CMakeLists.txt
@@ -1,10 +1,8 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.6)
 project(glview)

 set ( CMAKE_PREFIX_PATH cmake )

-set ( DRACO_DIR "" CACHE STRING "Path to draco" )
-
 find_package ( GLEW REQUIRED )
 find_package ( GLFW3 REQUIRED )
 find_package ( OpenGL REQUIRED )
@@ -23,18 +21,6 @@ endif (APPLE)

 set(CMAKE_CXX_STANDARD 11)

-if (DEFINED DRACO_DIR)
-  if (DRACO_DIR STREQUAL "")
-  else ()
-    # 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 ()
-endif()
-
 include_directories(
  ../../
  ../common
@@ -49,7 +35,6 @@ add_executable(glview
  )

 target_link_libraries ( glview
-  ${DRACO_LIBRARY} 
  ${GLFW3_UNIX_LINK_LIBRARIES}
  ${GLEW_LIBRARY}
  ${GLFW3_glfw_LIBRARY}
--- a/examples/glview/README.md
+++ b/examples/glview/README.md
@@ -27,17 +27,6 @@ Open .sln in Visual Studio 2013

 When running .exe, glew and glfw dll must exist in the working directory.

-#### Build with Draco(optional)
-
-Assume CMake build.
-
-```
-$ mkdir build
-$ cd build
-$ cmake -DDRACO_DIR=/path/to/draco ../
-$ make
-```
-
 ## TODO

 * [ ] PBR Material
--- a/examples/glview/glview.cc
+++ b/examples/glview/glview.cc
@@ -28,6 +28,7 @@
 #include "tiny_gltf.h"
 #endif

+
 #define BUFFER_OFFSET(i) ((char *)NULL + (i))

 #define CheckGLErrors(desc)                                                   \
@@ -54,9 +55,7 @@ float eye[3], lookat[3], up[3];

 GLFWwindow *window;

-typedef struct {
-  GLuint vb;
-} GLBufferState;
+typedef struct { GLuint vb; } GLBufferState;

 typedef struct {
  std::vector<GLuint> diffuseTex;  // for each primitive in mesh
@@ -255,26 +254,6 @@ void motionFunc(GLFWwindow *window, double mouse_x, double mouse_y) {
  prevMouseY = mouse_y;
 }

-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;
-  }
-}
-
 static void SetupMeshState(tinygltf::Model &model, GLuint progId) {
  // Buffer
  {
@@ -285,117 +264,14 @@ static void SetupMeshState(tinygltf::Model &model, GLuint progId) {
        continue;  // Unsupported bufferView.
      }

-      int sparse_accessor = -1;
-      for (size_t a_i = 0; a_i < model.accessors.size(); ++a_i) {
-        const auto &accessor = model.accessors[a_i];
-        if (accessor.bufferView == i) {
-          std::cout << i << " is used by accessor " << a_i << std::endl;
-          if (accessor.sparse.isSparse) {
-            std::cout
-                << "WARN: this bufferView has at least one sparse accessor to "
-                   "it. We are going to load the data as patched by this "
-                   "sparse accessor, not the original data"
-                << std::endl;
-            sparse_accessor = a_i;
-            break;
-          }
-        }
-      }
-
      const tinygltf::Buffer &buffer = model.buffers[bufferView.buffer];
      GLBufferState state;
      glGenBuffers(1, &state.vb);
      glBindBuffer(bufferView.target, state.vb);
      std::cout << "buffer.size= " << buffer.data.size()
                << ", byteOffset = " << bufferView.byteOffset << std::endl;
-
-      if (sparse_accessor < 0)
-        glBufferData(bufferView.target, bufferView.byteLength,
-                     &buffer.data.at(0) + bufferView.byteOffset,
-                     GL_STATIC_DRAW);
-      else {
-        const auto accessor = model.accessors[sparse_accessor];
-        // copy the buffer to a temporary one for sparse patching
-        unsigned char *tmp_buffer = new unsigned char[bufferView.byteLength];
-        memcpy(tmp_buffer, buffer.data.data() + bufferView.byteOffset,
-               bufferView.byteLength);
-
-        const size_t size_of_object_in_buffer =
-            ComponentTypeByteSize(accessor.componentType);
-        const size_t size_of_sparse_indices =
-            ComponentTypeByteSize(accessor.sparse.indices.componentType);
-
-        const auto &indices_buffer_view =
-            model.bufferViews[accessor.sparse.indices.bufferView];
-        const auto &indices_buffer = model.buffers[indices_buffer_view.buffer];
-
-        const auto &values_buffer_view =
-            model.bufferViews[accessor.sparse.values.bufferView];
-        const auto &values_buffer = model.buffers[values_buffer_view.buffer];
-
-        for (size_t sparse_index = 0; sparse_index < accessor.sparse.count;
-             ++sparse_index) {
-          int index = 0;
-          // std::cout << "accessor.sparse.indices.componentType = " <<
-          // accessor.sparse.indices.componentType << std::endl;
-          switch (accessor.sparse.indices.componentType) {
-            case TINYGLTF_COMPONENT_TYPE_BYTE:
-            case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
-              index = (int)*(
-                  unsigned char *)(indices_buffer.data.data() +
-                                   indices_buffer_view.byteOffset +
-                                   accessor.sparse.indices.byteOffset +
-                                   (sparse_index * size_of_sparse_indices));
-              break;
-            case TINYGLTF_COMPONENT_TYPE_SHORT:
-            case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
-              index = (int)*(
-                  unsigned short *)(indices_buffer.data.data() +
-                                    indices_buffer_view.byteOffset +
-                                    accessor.sparse.indices.byteOffset +
-                                    (sparse_index * size_of_sparse_indices));
-              break;
-            case TINYGLTF_COMPONENT_TYPE_INT:
-            case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
-              index = (int)*(
-                  unsigned int *)(indices_buffer.data.data() +
-                                  indices_buffer_view.byteOffset +
-                                  accessor.sparse.indices.byteOffset +
-                                  (sparse_index * size_of_sparse_indices));
-              break;
-          }
-          std::cout << "updating sparse data at index  : " << index
-                    << std::endl;
-          // index is now the target of the sparse index to patch in
-          const unsigned char *read_from =
-              values_buffer.data.data() +
-              (values_buffer_view.byteOffset +
-               accessor.sparse.values.byteOffset) +
-              (sparse_index * (size_of_object_in_buffer * accessor.type));
-
-          /*
-          std::cout << ((float*)read_from)[0] << "\n";
-          std::cout << ((float*)read_from)[1] << "\n";
-          std::cout << ((float*)read_from)[2] << "\n";
-          */
-
-          unsigned char *write_to =
-              tmp_buffer + index * (size_of_object_in_buffer * accessor.type);
-
-          memcpy(write_to, read_from, size_of_object_in_buffer * accessor.type);
-        }
-
-        // debug:
-        /*for(size_t p = 0; p < bufferView.byteLength/sizeof(float); p++)
-        {
-          float* b = (float*)tmp_buffer;
-          std::cout << "modified_buffer [" << p << "] = " << b[p] << '\n';
-        }*/
-
-        glBufferData(bufferView.target, bufferView.byteLength, tmp_buffer,
-                     GL_STATIC_DRAW);
-        delete[] tmp_buffer;
-      }
+      glBufferData(bufferView.target, bufferView.byteLength,
+                   &buffer.data.at(0) + bufferView.byteOffset, GL_STATIC_DRAW);
      glBindBuffer(bufferView.target, 0);

      gBufferState[i] = state;
@@ -403,55 +279,55 @@ static void SetupMeshState(tinygltf::Model &model, GLuint progId) {
  }

 #if 0  // TODO(syoyo): Implement
-	// Texture
-	{
-		for (size_t i = 0; i < model.meshes.size(); i++) {
-			const tinygltf::Mesh &mesh = model.meshes[i];
+  // Texture
+  {
+    for (size_t i = 0; i < model.meshes.size(); i++) {
+      const tinygltf::Mesh &mesh = model.meshes[i];

-			gMeshState[mesh.name].diffuseTex.resize(mesh.primitives.size());
-			for (size_t primId = 0; primId < mesh.primitives.size(); primId++) {
-				const tinygltf::Primitive &primitive = mesh.primitives[primId];
+      gMeshState[mesh.name].diffuseTex.resize(mesh.primitives.size());
+      for (size_t primId = 0; primId < mesh.primitives.size(); primId++) {
+        const tinygltf::Primitive &primitive = mesh.primitives[primId];

-				gMeshState[mesh.name].diffuseTex[primId] = 0;
+        gMeshState[mesh.name].diffuseTex[primId] = 0;

-				if (primitive.material < 0) {
-					continue;
-				}
-				tinygltf::Material &mat = model.materials[primitive.material];
-				// printf("material.name = %s\n", mat.name.c_str());
-				if (mat.values.find("diffuse") != mat.values.end()) {
-					std::string diffuseTexName = mat.values["diffuse"].string_value;
-					if (model.textures.find(diffuseTexName) != model.textures.end()) {
-						tinygltf::Texture &tex = model.textures[diffuseTexName];
-						if (scene.images.find(tex.source) != model.images.end()) {
-							tinygltf::Image &image = model.images[tex.source];
-							GLuint texId;
-							glGenTextures(1, &texId);
-							glBindTexture(tex.target, texId);
-							glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-							glTexParameterf(tex.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-							glTexParameterf(tex.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        if (primitive.material < 0) {
+          continue;
+        }
+        tinygltf::Material &mat = model.materials[primitive.material];
+        // printf("material.name = %s\n", mat.name.c_str());
+        if (mat.values.find("diffuse") != mat.values.end()) {
+          std::string diffuseTexName = mat.values["diffuse"].string_value;
+          if (model.textures.find(diffuseTexName) != model.textures.end()) {
+            tinygltf::Texture &tex = model.textures[diffuseTexName];
+            if (scene.images.find(tex.source) != model.images.end()) {
+              tinygltf::Image &image = model.images[tex.source];
+              GLuint texId;
+              glGenTextures(1, &texId);
+              glBindTexture(tex.target, texId);
+              glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+              glTexParameterf(tex.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+              glTexParameterf(tex.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

-							// Ignore Texture.fomat.
-							GLenum format = GL_RGBA;
-							if (image.component == 3) {
-								format = GL_RGB;
-							}
-							glTexImage2D(tex.target, 0, tex.internalFormat, image.width,
-									image.height, 0, format, tex.type,
-									&image.image.at(0));
+              // Ignore Texture.fomat.
+              GLenum format = GL_RGBA;
+              if (image.component == 3) {
+                format = GL_RGB;
+              }
+              glTexImage2D(tex.target, 0, tex.internalFormat, image.width,
+                           image.height, 0, format, tex.type,
+                           &image.image.at(0));

-							CheckErrors("texImage2D");
-							glBindTexture(tex.target, 0);
+              CheckErrors("texImage2D");
+              glBindTexture(tex.target, 0);

-							printf("TexId = %d\n", texId);
-							gMeshState[mesh.name].diffuseTex[primId] = texId;
-						}
-					}
-				}
-			}
-		}
-	}
+              printf("TexId = %d\n", texId);
+              gMeshState[mesh.name].diffuseTex[primId] = texId;
+            }
+          }
+        }
+      }
+    }
+  }
 #endif

  glUseProgram(progId);
@@ -472,164 +348,164 @@ static void SetupMeshState(tinygltf::Model &model, GLuint progId) {
 #if 0  // TODO(syoyo): Implement
 // Setup curves geometry extension
 static void SetupCurvesState(tinygltf::Scene &scene, GLuint progId) {
-	// Find curves primitive.
-	{
-		std::map<std::string, tinygltf::Mesh>::const_iterator it(
-				scene.meshes.begin());
-		std::map<std::string, tinygltf::Mesh>::const_iterator itEnd(
-				scene.meshes.end());
+  // Find curves primitive.
+  {
+    std::map<std::string, tinygltf::Mesh>::const_iterator it(
+        scene.meshes.begin());
+    std::map<std::string, tinygltf::Mesh>::const_iterator itEnd(
+        scene.meshes.end());

-		for (; it != itEnd; it++) {
-			const tinygltf::Mesh &mesh = it->second;
+    for (; it != itEnd; it++) {
+      const tinygltf::Mesh &mesh = it->second;

-			// Currently we only support one primitive per mesh.
-			if (mesh.primitives.size() > 1) {
-				continue;
-			}
+      // Currently we only support one primitive per mesh.
+      if (mesh.primitives.size() > 1) {
+        continue;
+      }

-			for (size_t primId = 0; primId < mesh.primitives.size(); primId++) {
-				const tinygltf::Primitive &primitive = mesh.primitives[primId];
+      for (size_t primId = 0; primId < mesh.primitives.size(); primId++) {
+        const tinygltf::Primitive &primitive = mesh.primitives[primId];

-				gMeshState[mesh.name].diffuseTex[primId] = 0;
+        gMeshState[mesh.name].diffuseTex[primId] = 0;

-				if (primitive.material.empty()) {
-					continue;
-				}
+        if (primitive.material.empty()) {
+          continue;
+        }

-				bool has_curves = false;
-				if (primitive.extras.IsObject()) {
-					if (primitive.extras.Has("ext_mode")) {
-						const tinygltf::Value::Object &o =
-							primitive.extras.Get<tinygltf::Value::Object>();
-						const tinygltf::Value &ext_mode = o.find("ext_mode")->second;
+        bool has_curves = false;
+        if (primitive.extras.IsObject()) {
+          if (primitive.extras.Has("ext_mode")) {
+            const tinygltf::Value::Object &o =
+                primitive.extras.Get<tinygltf::Value::Object>();
+            const tinygltf::Value &ext_mode = o.find("ext_mode")->second;

-						if (ext_mode.IsString()) {
-							const std::string &str = ext_mode.Get<std::string>();
-							if (str.compare("curves") == 0) {
-								has_curves = true;
-							}
-						}
-					}
-				}
+            if (ext_mode.IsString()) {
+              const std::string &str = ext_mode.Get<std::string>();
+              if (str.compare("curves") == 0) {
+                has_curves = true;
+              }
+            }
+          }
+        }

-				if (!has_curves) {
-					continue;
-				}
+        if (!has_curves) {
+          continue;
+        }

-				// Construct curves buffer
-				const tinygltf::Accessor &vtx_accessor =
-					scene.accessors[primitive.attributes.find("POSITION")->second];
-				const tinygltf::Accessor &nverts_accessor =
-					scene.accessors[primitive.attributes.find("NVERTS")->second];
-				const tinygltf::BufferView &vtx_bufferView =
-					scene.bufferViews[vtx_accessor.bufferView];
-				const tinygltf::BufferView &nverts_bufferView =
-					scene.bufferViews[nverts_accessor.bufferView];
-				const tinygltf::Buffer &vtx_buffer =
-					scene.buffers[vtx_bufferView.buffer];
-				const tinygltf::Buffer &nverts_buffer =
-					scene.buffers[nverts_bufferView.buffer];
+        // Construct curves buffer
+        const tinygltf::Accessor &vtx_accessor =
+            scene.accessors[primitive.attributes.find("POSITION")->second];
+        const tinygltf::Accessor &nverts_accessor =
+            scene.accessors[primitive.attributes.find("NVERTS")->second];
+        const tinygltf::BufferView &vtx_bufferView =
+            scene.bufferViews[vtx_accessor.bufferView];
+        const tinygltf::BufferView &nverts_bufferView =
+            scene.bufferViews[nverts_accessor.bufferView];
+        const tinygltf::Buffer &vtx_buffer =
+            scene.buffers[vtx_bufferView.buffer];
+        const tinygltf::Buffer &nverts_buffer =
+            scene.buffers[nverts_bufferView.buffer];

-				// std::cout << "vtx_bufferView = " << vtx_accessor.bufferView <<
-				// std::endl;
-				// std::cout << "nverts_bufferView = " << nverts_accessor.bufferView <<
-				// std::endl;
-				// std::cout << "vtx_buffer.size = " << vtx_buffer.data.size() <<
-				// std::endl;
-				// std::cout << "nverts_buffer.size = " << nverts_buffer.data.size() <<
-				// std::endl;
+        // std::cout << "vtx_bufferView = " << vtx_accessor.bufferView <<
+        // std::endl;
+        // std::cout << "nverts_bufferView = " << nverts_accessor.bufferView <<
+        // std::endl;
+        // std::cout << "vtx_buffer.size = " << vtx_buffer.data.size() <<
+        // std::endl;
+        // std::cout << "nverts_buffer.size = " << nverts_buffer.data.size() <<
+        // std::endl;

-				const int *nverts =
-					reinterpret_cast<const int *>(nverts_buffer.data.data());
-				const float *vtx =
-					reinterpret_cast<const float *>(vtx_buffer.data.data());
+        const int *nverts =
+            reinterpret_cast<const int *>(nverts_buffer.data.data());
+        const float *vtx =
+            reinterpret_cast<const float *>(vtx_buffer.data.data());

-				// Convert to GL_LINES data.
-				std::vector<float> line_pts;
-				size_t vtx_offset = 0;
-				for (int k = 0; k < static_cast<int>(nverts_accessor.count); k++) {
-					for (int n = 0; n < nverts[k] - 1; n++) {
+        // Convert to GL_LINES data.
+        std::vector<float> line_pts;
+        size_t vtx_offset = 0;
+        for (int k = 0; k < static_cast<int>(nverts_accessor.count); k++) {
+          for (int n = 0; n < nverts[k] - 1; n++) {

-						line_pts.push_back(vtx[3 * (vtx_offset + n) + 0]);
-						line_pts.push_back(vtx[3 * (vtx_offset + n) + 1]);
-						line_pts.push_back(vtx[3 * (vtx_offset + n) + 2]);
+            line_pts.push_back(vtx[3 * (vtx_offset + n) + 0]);
+            line_pts.push_back(vtx[3 * (vtx_offset + n) + 1]);
+            line_pts.push_back(vtx[3 * (vtx_offset + n) + 2]);

-						line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 0]);
-						line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 1]);
-						line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 2]);
+            line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 0]);
+            line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 1]);
+            line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 2]);

-						// std::cout << "p0 " << vtx[3 * (vtx_offset + n) + 0] << ", "
-						//                  << vtx[3 * (vtx_offset + n) + 1] << ", "
-						//                  << vtx[3 * (vtx_offset + n) + 2] << std::endl;
+            // std::cout << "p0 " << vtx[3 * (vtx_offset + n) + 0] << ", "
+            //                  << vtx[3 * (vtx_offset + n) + 1] << ", "
+            //                  << vtx[3 * (vtx_offset + n) + 2] << std::endl;

-						// std::cout << "p1 " << vtx[3 * (vtx_offset + n+1) + 0] << ", "
-						//                  << vtx[3 * (vtx_offset + n+1) + 1] << ", "
-						//                  << vtx[3 * (vtx_offset + n+1) + 2] << std::endl;
-					}
+            // std::cout << "p1 " << vtx[3 * (vtx_offset + n+1) + 0] << ", "
+            //                  << vtx[3 * (vtx_offset + n+1) + 1] << ", "
+            //                  << vtx[3 * (vtx_offset + n+1) + 2] << std::endl;
+          }

-					vtx_offset += nverts[k];
-				}
+          vtx_offset += nverts[k];
+        }

-				GLCurvesState state;
-				glGenBuffers(1, &state.vb);
-				glBindBuffer(GL_ARRAY_BUFFER, state.vb);
-				glBufferData(GL_ARRAY_BUFFER, line_pts.size() * sizeof(float),
-						line_pts.data(), GL_STATIC_DRAW);
-				glBindBuffer(GL_ARRAY_BUFFER, 0);
+        GLCurvesState state;
+        glGenBuffers(1, &state.vb);
+        glBindBuffer(GL_ARRAY_BUFFER, state.vb);
+        glBufferData(GL_ARRAY_BUFFER, line_pts.size() * sizeof(float),
+                     line_pts.data(), GL_STATIC_DRAW);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);

-				state.count = line_pts.size() / 3;
-				gCurvesMesh[mesh.name] = state;
+        state.count = line_pts.size() / 3;
+        gCurvesMesh[mesh.name] = state;

-				// Material
-				tinygltf::Material &mat = scene.materials[primitive.material];
-				// printf("material.name = %s\n", mat.name.c_str());
-				if (mat.values.find("diffuse") != mat.values.end()) {
-					std::string diffuseTexName = mat.values["diffuse"].string_value;
-					if (scene.textures.find(diffuseTexName) != scene.textures.end()) {
-						tinygltf::Texture &tex = scene.textures[diffuseTexName];
-						if (scene.images.find(tex.source) != scene.images.end()) {
-							tinygltf::Image &image = scene.images[tex.source];
-							GLuint texId;
-							glGenTextures(1, &texId);
-							glBindTexture(tex.target, texId);
-							glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-							glTexParameterf(tex.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-							glTexParameterf(tex.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        // Material
+        tinygltf::Material &mat = scene.materials[primitive.material];
+        // printf("material.name = %s\n", mat.name.c_str());
+        if (mat.values.find("diffuse") != mat.values.end()) {
+          std::string diffuseTexName = mat.values["diffuse"].string_value;
+          if (scene.textures.find(diffuseTexName) != scene.textures.end()) {
+            tinygltf::Texture &tex = scene.textures[diffuseTexName];
+            if (scene.images.find(tex.source) != scene.images.end()) {
+              tinygltf::Image &image = scene.images[tex.source];
+              GLuint texId;
+              glGenTextures(1, &texId);
+              glBindTexture(tex.target, texId);
+              glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+              glTexParameterf(tex.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+              glTexParameterf(tex.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

-							// Ignore Texture.fomat.
-							GLenum format = GL_RGBA;
-							if (image.component == 3) {
-								format = GL_RGB;
-							}
-							glTexImage2D(tex.target, 0, tex.internalFormat, image.width,
-									image.height, 0, format, tex.type,
-									&image.image.at(0));
+              // Ignore Texture.fomat.
+              GLenum format = GL_RGBA;
+              if (image.component == 3) {
+                format = GL_RGB;
+              }
+              glTexImage2D(tex.target, 0, tex.internalFormat, image.width,
+                           image.height, 0, format, tex.type,
+                           &image.image.at(0));

-							CheckErrors("texImage2D");
-							glBindTexture(tex.target, 0);
+              CheckErrors("texImage2D");
+              glBindTexture(tex.target, 0);

-							printf("TexId = %d\n", texId);
-							gMeshState[mesh.name].diffuseTex[primId] = texId;
-						}
-					}
-				}
-			}
-		}
-	}
+              printf("TexId = %d\n", texId);
+              gMeshState[mesh.name].diffuseTex[primId] = texId;
+            }
+          }
+        }
+      }
+    }
+  }

-	glUseProgram(progId);
-	GLint vtloc = glGetAttribLocation(progId, "in_vertex");
-	GLint nrmloc = glGetAttribLocation(progId, "in_normal");
-	GLint uvloc = glGetAttribLocation(progId, "in_texcoord");
+  glUseProgram(progId);
+  GLint vtloc = glGetAttribLocation(progId, "in_vertex");
+  GLint nrmloc = glGetAttribLocation(progId, "in_normal");
+  GLint uvloc = glGetAttribLocation(progId, "in_texcoord");

-	GLint diffuseTexLoc = glGetUniformLocation(progId, "diffuseTex");
-	GLint isCurvesLoc = glGetUniformLocation(progId, "uIsCurves");
+  GLint diffuseTexLoc = glGetUniformLocation(progId, "diffuseTex");
+  GLint isCurvesLoc = glGetUniformLocation(progId, "uIsCurves");

-	gGLProgramState.attribs["POSITION"] = vtloc;
-	gGLProgramState.attribs["NORMAL"] = nrmloc;
-	gGLProgramState.attribs["TEXCOORD_0"] = uvloc;
-	gGLProgramState.uniforms["diffuseTex"] = diffuseTexLoc;
-	gGLProgramState.uniforms["uIsCurves"] = isCurvesLoc;
+  gGLProgramState.attribs["POSITION"] = vtloc;
+  gGLProgramState.attribs["NORMAL"] = nrmloc;
+  gGLProgramState.attribs["TEXCOORD_0"] = uvloc;
+  gGLProgramState.uniforms["diffuseTex"] = diffuseTexLoc;
+  gGLProgramState.uniforms["uIsCurves"] = isCurvesLoc;
 };
 #endif

@@ -682,13 +558,12 @@ static void DrawMesh(tinygltf::Model &model, const tinygltf::Mesh &mesh) {
          (it->first.compare("TEXCOORD_0") == 0)) {
        if (gGLProgramState.attribs[it->first] >= 0) {
          // Compute byteStride from Accessor + BufferView combination.
-          int byteStride =
-              accessor.ByteStride(model.bufferViews[accessor.bufferView]);
+          int byteStride = accessor.ByteStride(model.bufferViews[accessor.bufferView]);
          assert(byteStride != -1);
          glVertexAttribPointer(gGLProgramState.attribs[it->first], size,
-                                accessor.componentType,
-                                accessor.normalized ? GL_TRUE : GL_FALSE,
-                                byteStride, BUFFER_OFFSET(accessor.byteOffset));
+                                accessor.componentType, accessor.normalized ? GL_TRUE : GL_FALSE,
+                                byteStride,
+                                BUFFER_OFFSET(accessor.byteOffset));
          CheckErrors("vertex attrib pointer");
          glEnableVertexAttribArray(gGLProgramState.attribs[it->first]);
          CheckErrors("enable vertex attrib array");
@@ -742,32 +617,32 @@ static void DrawMesh(tinygltf::Model &model, const tinygltf::Mesh &mesh) {

 #if 0  // TODO(syoyo): Implement
 static void DrawCurves(tinygltf::Scene &scene, const tinygltf::Mesh &mesh) {
-	(void)scene;
+  (void)scene;

-	if (gCurvesMesh.find(mesh.name) == gCurvesMesh.end()) {
-		return;
-	}
+  if (gCurvesMesh.find(mesh.name) == gCurvesMesh.end()) {
+    return;
+  }

-	if (gGLProgramState.uniforms["isCurvesLoc"] >= 0) {
-		glUniform1i(gGLProgramState.uniforms["isCurvesLoc"], 1);
-	}
+  if (gGLProgramState.uniforms["isCurvesLoc"] >= 0) {
+    glUniform1i(gGLProgramState.uniforms["isCurvesLoc"], 1);
+  }

-	GLCurvesState &state = gCurvesMesh[mesh.name];
+  GLCurvesState &state = gCurvesMesh[mesh.name];

-	if (gGLProgramState.attribs["POSITION"] >= 0) {
-		glBindBuffer(GL_ARRAY_BUFFER, state.vb);
-		glVertexAttribPointer(gGLProgramState.attribs["POSITION"], 3, GL_FLOAT,
-				GL_FALSE, /* stride */ 0, BUFFER_OFFSET(0));
-		CheckErrors("curve: vertex attrib pointer");
-		glEnableVertexAttribArray(gGLProgramState.attribs["POSITION"]);
-		CheckErrors("curve: enable vertex attrib array");
-	}
+  if (gGLProgramState.attribs["POSITION"] >= 0) {
+    glBindBuffer(GL_ARRAY_BUFFER, state.vb);
+    glVertexAttribPointer(gGLProgramState.attribs["POSITION"], 3, GL_FLOAT,
+                          GL_FALSE, /* stride */ 0, BUFFER_OFFSET(0));
+    CheckErrors("curve: vertex attrib pointer");
+    glEnableVertexAttribArray(gGLProgramState.attribs["POSITION"]);
+    CheckErrors("curve: enable vertex attrib array");
+  }

-	glDrawArrays(GL_LINES, 0, state.count);
+  glDrawArrays(GL_LINES, 0, state.count);

-	if (gGLProgramState.attribs["POSITION"] >= 0) {
-		glDisableVertexAttribArray(gGLProgramState.attribs["POSITION"]);
-	}
+  if (gGLProgramState.attribs["POSITION"] >= 0) {
+    glDisableVertexAttribArray(gGLProgramState.attribs["POSITION"]);
+  }
 }
 #endif

@@ -802,14 +677,10 @@ static void DrawNode(tinygltf::Model &model, const tinygltf::Node &node) {
  // std::cout << it->first << std::endl;
  // FIXME(syoyo): Refactor.
  // DrawCurves(scene, it->second);
-  if (node.mesh > -1) {
-    assert(node.mesh < model.meshes.size());
-    DrawMesh(model, model.meshes[node.mesh]);
-  }
+  DrawMesh(model, model.meshes[node.mesh]);

  // Draw child nodes.
  for (size_t i = 0; i < node.children.size(); i++) {
-    assert(node.children[i] < model.nodes.size());
    DrawNode(model, model.nodes[node.children[i]]);
  }

@@ -818,19 +689,18 @@ static void DrawNode(tinygltf::Model &model, const tinygltf::Node &node) {

 static void DrawModel(tinygltf::Model &model) {
 #if 0
-	std::map<std::string, tinygltf::Mesh>::const_iterator it(scene.meshes.begin());
-	std::map<std::string, tinygltf::Mesh>::const_iterator itEnd(scene.meshes.end());
+  std::map<std::string, tinygltf::Mesh>::const_iterator it(scene.meshes.begin());
+  std::map<std::string, tinygltf::Mesh>::const_iterator itEnd(scene.meshes.end());

-	for (; it != itEnd; it++) {
-		DrawMesh(scene, it->second);
-		DrawCurves(scene, it->second);
-	}
+  for (; it != itEnd; it++) {
+    DrawMesh(scene, it->second);
+    DrawCurves(scene, it->second);
+  }
 #else
-  // If the glTF asset has at least one scene, and doesn't define a default one
-  // just show the first one we can find
-  assert(model.scenes.size() > 0);
-  int scene_to_display = model.defaultScene > -1 ? model.defaultScene : 0;
-  const tinygltf::Scene &scene = model.scenes[scene_to_display];
+
+  // TODO(syoyo): Support non-default scenes.
+  assert(model.defaultScene >= 0);
+  const tinygltf::Scene &scene = model.scenes[model.defaultScene];
  for (size_t i = 0; i < scene.nodes.size(); i++) {
    DrawNode(model, model.nodes[scene.nodes[i]]);
  }
@@ -877,8 +747,7 @@ int main(int argc, char **argv) {

 #ifdef _WIN32
 #ifdef _DEBUG
-  std::string input_filename(argv[1] ? argv[1]
-                                     : "../../../models/Cube/Cube.gltf");
+    std::string input_filename(argv[1] ? argv[1] : "../../../models/Cube/Cube.gltf");
 #endif
 #else
  std::string input_filename(argv[1] ? argv[1] : "../../models/Cube/Cube.gltf");
@@ -889,8 +758,7 @@ int main(int argc, char **argv) {
  bool ret = false;
  if (ext.compare("glb") == 0) {
    // assume binary glTF.
-    ret =
-        loader.LoadBinaryFromFile(&model, &err, &warn, input_filename.c_str());
+    ret = loader.LoadBinaryFromFile(&model, &err, &warn, input_filename.c_str());
  } else {
    // assume ascii glTF.
    ret = loader.LoadASCIIFromFile(&model, &err, &warn, input_filename.c_str());
@@ -911,19 +779,17 @@ int main(int argc, char **argv) {
  Init();

  // DBG
-  PrintNodes(model.scenes[model.defaultScene > -1 ? model.defaultScene : 0]);
+  PrintNodes(model.scenes[model.defaultScene]);

  if (!glfwInit()) {
    std::cerr << "Failed to initialize GLFW." << std::endl;
    return -1;
  }

-  std::stringstream ss;
-  ss << "Simple glTF viewer: " << input_filename;
+  char title[1024];
+  sprintf(title, "Simple glTF viewer: %s", input_filename.c_str());

-  std::string title = ss.str();
-
-  window = glfwCreateWindow(width, height, title.c_str(), NULL, NULL);
+  window = glfwCreateWindow(width, height, title, NULL, NULL);
  if (window == NULL) {
    std::cerr << "Failed to open GLFW window. " << std::endl;
    glfwTerminate();
@@ -952,14 +818,15 @@ int main(int argc, char **argv) {

 #ifdef _WIN32
 #ifdef _DEBUG
-  const char *shader_frag_filename = "../shader.frag";
-  const char *shader_vert_filename = "../shader.vert";
+    const char *shader_frag_filename = "../shader.frag";
+    const char *shader_vert_filename = "../shader.vert";
 #endif
 #else
  const char *shader_frag_filename = "shader.frag";
  const char *shader_vert_filename = "shader.vert";
 #endif

+
  if (false == LoadShader(GL_VERTEX_SHADER, vertId, shader_vert_filename)) {
    return -1;
  }
--- a/examples/raytrace/image-impl.cc
+++ b/examples/raytrace/image-impl.cc
@@ -0,0 +1,6 @@
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#define LODEPNG_IMPLEMENTATION
+#include "lodepng.h"
--- a/examples/raytrace/img-loaders.cc
+++ b/examples/raytrace/img-loaders.cc
@@ -1,3 +1,5 @@

 #define STB_IMAGE_IMPLEMENTATION
 #include "stb_image.h"
+#define LODEPNG_IMPLEMENTATION
+#include "lodepng.h"
--- a/examples/raytrace/premake5.lua
+++ b/examples/raytrace/premake5.lua
@@ -9,7 +9,7 @@ newoption {
 }

 sources = {
-   "stbi-impl.cc",
+   "img-loaders.cc",
   "main.cc",
   "render.cc",
   "render-config.cc",
--- a/json.hpp
+++ b/json.hpp
--- a/loader_example.cc
+++ b/loader_example.cc
@@ -4,6 +4,7 @@
 #define TINYGLTF_IMPLEMENTATION
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
+#define LODEPNG_IMPLEMENTATION
 #include "tiny_gltf.h"

 #include <cstdio>
@@ -175,10 +176,7 @@ static std::string PrintIntArray(const std::vector<int> &arr) {
  std::stringstream ss;
  ss << "[ ";
  for (size_t i = 0; i < arr.size(); i++) {
-    ss << arr[i];
-    if (i != arr.size() - 1) {
-      ss << ", ";
-    }
+    ss << arr[i] << ((i != arr.size() - 1) ? ", " : "");
  }
  ss << " ]";

@@ -193,10 +191,7 @@ static std::string PrintFloatArray(const std::vector<double> &arr) {
  std::stringstream ss;
  ss << "[ ";
  for (size_t i = 0; i < arr.size(); i++) {
-    ss << arr[i];
-    if (i != arr.size() - 1) {
-      ss << ", ";
-    }
+    ss << arr[i] << ((i != arr.size() - 1) ? ", " : "");
  }
  ss << " ]";

@@ -234,8 +229,7 @@ static std::string PrintParameterMap(const tinygltf::ParameterMap &pmap) {
 #endif

 static std::string PrintValue(const std::string &name,
-                              const tinygltf::Value &value, const int indent,
-                              const bool tag = true) {
+                              const tinygltf::Value &value, const int indent, const bool tag = true) {
  std::stringstream ss;

  if (value.IsObject()) {
@@ -249,36 +243,36 @@ static std::string PrintValue(const std::string &name,
    if (tag) {
      ss << Indent(indent) << name << " : " << value.Get<std::string>();
    } else {
-      ss << Indent(indent) << value.Get<std::string>() << " ";
+      ss << " " << value.Get<std::string>() << " ";
    }
  } else if (value.IsBool()) {
    if (tag) {
      ss << Indent(indent) << name << " : " << value.Get<bool>();
    } else {
-      ss << Indent(indent) << value.Get<bool>() << " ";
+      ss << " " << value.Get<bool>() << " ";
    }
  } else if (value.IsNumber()) {
    if (tag) {
      ss << Indent(indent) << name << " : " << value.Get<double>();
    } else {
-      ss << Indent(indent) << value.Get<double>() << " ";
+      ss << " " << value.Get<double>() << " ";
    }
  } else if (value.IsInt()) {
    if (tag) {
      ss << Indent(indent) << name << " : " << value.Get<int>();
    } else {
-      ss << Indent(indent) << value.Get<int>() << " ";
+      ss << " " << value.Get<int>() << " ";
    }
  } else if (value.IsArray()) {
-    // TODO(syoyo): Better pretty printing of array item
-    ss << Indent(indent) << name << " [ \n";
+    ss << Indent(indent) << name << " [ ";
    for (size_t i = 0; i < value.Size(); i++) {
-      ss << PrintValue("", value.Get(int(i)), indent + 1, /* tag */ false);
-      if (i != (value.ArrayLen() - 1)) {
-        ss << ", \n";
+      ss << PrintValue("", value.Get(int(i)), indent + 1, /* tag */false);
+      if (i != (value.ArrayLen()-1)) {
+        ss << ", ";
      }
+
    }
-    ss << "\n" << Indent(indent) << "] ";
+    ss << Indent(indent) << "] ";
  }

  // @todo { binary }
@@ -337,61 +331,13 @@ static void DumpPrimitive(const tinygltf::Primitive &primitive, int indent) {
            << PrintValue("extras", primitive.extras, indent + 1) << std::endl;
 }

-static void DumpExtensions(const tinygltf::ExtensionMap &extension,
-                           const int indent) {
+static void DumpExtensions(const tinygltf::ExtensionMap &extension, const int indent)
+{
  // TODO(syoyo): pritty print Value
  for (auto &e : extension) {
    std::cout << Indent(indent) << e.first << std::endl;
-    std::cout << PrintValue("extensions", e.second, indent + 1) << std::endl;
-  }
-}
-
-static void DumpTextureInfo(const tinygltf::TextureInfo &texinfo,
-                            const int indent) {
-  std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
-  std::cout << Indent(indent) << "texCoord  : TEXCOORD_" << texinfo.texCoord
-            << "\n";
-  DumpExtensions(texinfo.extensions, indent + 1);
-  std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
-}
-
-static void DumpNormalTextureInfo(const tinygltf::NormalTextureInfo &texinfo,
-                                  const int indent) {
-  std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
-  std::cout << Indent(indent) << "texCoord  : TEXCOORD_" << texinfo.texCoord
-            << "\n";
-  std::cout << Indent(indent) << "scale     : " << texinfo.scale << "\n";
-  DumpExtensions(texinfo.extensions, indent + 1);
-  std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
-}
-
-static void DumpOcclusionTextureInfo(
-    const tinygltf::OcclusionTextureInfo &texinfo, const int indent) {
-  std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
-  std::cout << Indent(indent) << "texCoord  : TEXCOORD_" << texinfo.texCoord
-            << "\n";
-  std::cout << Indent(indent) << "strength  : " << texinfo.strength << "\n";
-  DumpExtensions(texinfo.extensions, indent + 1);
-  std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
-}
-
-static void DumpPbrMetallicRoughness(const tinygltf::PbrMetallicRoughness &pbr,
-                                     const int indent) {
-  std::cout << Indent(indent)
-            << "baseColorFactor   : " << PrintFloatArray(pbr.baseColorFactor)
-            << "\n";
-  std::cout << Indent(indent) << "baseColorTexture  :\n";
-  DumpTextureInfo(pbr.baseColorTexture, indent + 1);
-
-  std::cout << Indent(indent) << "metallicFactor    : " << pbr.metallicFactor
-            << "\n";
-  std::cout << Indent(indent) << "roughnessFactor   : " << pbr.roughnessFactor
-            << "\n";
-
-  std::cout << Indent(indent) << "metallicRoughnessTexture  :\n";
-  DumpTextureInfo(pbr.metallicRoughnessTexture, indent + 1);
-  DumpExtensions(pbr.extensions, indent + 1);
-  std::cout << PrintValue("extras", pbr.extras, indent + 1) << "\n";
+    std::cout << PrintValue("extensions", e.second, indent+1) << std::endl;
+  }  
 }

 static void Dump(const tinygltf::Model &model) {
@@ -464,30 +410,6 @@ static void Dump(const tinygltf::Model &model) {
        }
        std::cout << "]" << std::endl;
      }
-
-      if (accessor.sparse.isSparse) {
-        std::cout << Indent(2) << "sparse:" << std::endl;
-        std::cout << Indent(3) << "count  : " << accessor.sparse.count
-                  << std::endl;
-        std::cout << Indent(3) << "indices: " << std::endl;
-        std::cout << Indent(4)
-                  << "bufferView   : " << accessor.sparse.indices.bufferView
-                  << std::endl;
-        std::cout << Indent(4)
-                  << "byteOffset   : " << accessor.sparse.indices.byteOffset
-                  << std::endl;
-        std::cout << Indent(4) << "componentType: "
-                  << PrintComponentType(accessor.sparse.indices.componentType)
-                  << "(" << accessor.sparse.indices.componentType << ")"
-                  << std::endl;
-        std::cout << Indent(3) << "values : " << std::endl;
-        std::cout << Indent(4)
-                  << "bufferView   : " << accessor.sparse.values.bufferView
-                  << std::endl;
-        std::cout << Indent(4)
-                  << "byteOffset   : " << accessor.sparse.values.byteOffset
-                  << std::endl;
-      }
    }
  }

@@ -564,44 +486,16 @@ static void Dump(const tinygltf::Model &model) {
              << std::endl;
    for (size_t i = 0; i < model.materials.size(); i++) {
      const tinygltf::Material &material = model.materials[i];
-      std::cout << Indent(1) << "name                 : " << material.name
-                << std::endl;
-
-      std::cout << Indent(1) << "alphaMode            : " << material.alphaMode
-                << std::endl;
-      std::cout << Indent(1)
-                << "alphaCutoff          : " << material.alphaCutoff
-                << std::endl;
-      std::cout << Indent(1) << "doubleSided          : "
-                << (material.doubleSided ? "true" : "false") << std::endl;
-      std::cout << Indent(1) << "emissiveFactor       : "
-                << PrintFloatArray(material.emissiveFactor) << std::endl;
-
-      std::cout << Indent(1) << "pbrMetallicRoughness :\n";
-      DumpPbrMetallicRoughness(material.pbrMetallicRoughness, 2);
-
-      std::cout << Indent(1) << "normalTexture        :\n";
-      DumpNormalTextureInfo(material.normalTexture, 2);
-
-      std::cout << Indent(1) << "occlusionTexture     :\n";
-      DumpOcclusionTextureInfo(material.occlusionTexture, 2);
-
-      std::cout << Indent(1) << "emissiveTexture      :\n";
-      DumpTextureInfo(material.emissiveTexture, 2);
-
-      std::cout << Indent(1) << "----  legacy material parameter  ----\n";
+      std::cout << Indent(1) << "name         : " << material.name << std::endl;
      std::cout << Indent(1) << "values(items=" << material.values.size() << ")"
                << std::endl;
+
      tinygltf::ParameterMap::const_iterator p(material.values.begin());
      tinygltf::ParameterMap::const_iterator pEnd(material.values.end());
      for (; p != pEnd; p++) {
        std::cout << Indent(2) << p->first << ": "
                  << PrintParameterValue(p->second) << std::endl;
      }
-      std::cout << Indent(1) << "-------------------------------------\n";
-
-      DumpExtensions(material.extensions, 1);
-      std::cout << PrintValue("extras", material.extras, 2) << std::endl;
    }
  }

@@ -692,11 +586,10 @@ static void Dump(const tinygltf::Model &model) {
      }
    }
  }
-
+  
  // toplevel extensions
  {
-    std::cout << "extensions(items=" << model.extensions.size() << ")"
-              << std::endl;
+    std::cout << "extensions(items=" << model.extensions.size() << ")" << std::endl;
    DumpExtensions(model.extensions, 1);
  }
 }
@@ -710,7 +603,7 @@ int main(int argc, char **argv) {
  tinygltf::Model model;
  tinygltf::TinyGLTF gltf_ctx;
  std::string err;
-  std::string warn;
+  std::string warn; 
  std::string input_filename(argv[1]);
  std::string ext = GetFilePathExtension(input_filename);

@@ -718,19 +611,18 @@ int main(int argc, char **argv) {
  if (ext.compare("glb") == 0) {
    std::cout << "Reading binary glTF" << std::endl;
    // assume binary glTF.
-    ret = gltf_ctx.LoadBinaryFromFile(&model, &err, &warn,
-                                      input_filename.c_str());
+    ret = gltf_ctx.LoadBinaryFromFile(&model, &err, &warn, input_filename.c_str());
  } else {
    std::cout << "Reading ASCII glTF" << std::endl;
    // assume ascii glTF.
-    ret =
-        gltf_ctx.LoadASCIIFromFile(&model, &err, &warn, input_filename.c_str());
+    ret = gltf_ctx.LoadASCIIFromFile(&model, &err, &warn, input_filename.c_str());
  }

  if (!warn.empty()) {
    printf("Warn: %s\n", warn.c_str());
  }

+
  if (!err.empty()) {
    printf("Err: %s\n", err.c_str());
  }
--- a/examples/common/lodepng.cpp
+++ b/examples/common/lodepng.cpp
--- a/models/BoundsChecking/integer-out-of-bounds.gltf
+++ b/models/BoundsChecking/integer-out-of-bounds.gltf
@@ -1,67 +0,0 @@
-{
-  "scenes": [
-    {
-      "nodes": [0]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0
-    }
-  ],
-  "meshes": [
-    {
-      "primitives": [
-        {
-          "attributes": {
-            "POSITION": 1
-          },
-          "indices": 0
-        }
-      ]
-    }
-  ],
-  "buffers": [
-    {
-      "uri": "simpleTriangle.bin",
-      "byteLength": 44
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 1e300,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteOffset": 8,
-      "byteLength": 36,
-      "target": 34962
-    }
-  ],
-  "accessors": [
-    {
-      "bufferView": 0,
-      "byteOffset": 0,
-      "componentType": 5123,
-      "count": 3,
-      "type": "SCALAR",
-      "max": [2],
-      "min": [0]
-    },
-    {
-      "bufferView": 1,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 3,
-      "type": "VEC3",
-      "max": [1, 1, 0],
-      "min": [0, 0, 0]
-    }
-  ],
-  "asset": {
-    "version": "2.0"
-  }
-}
--- a/models/BoundsChecking/invalid-buffer-index.gltf
+++ b/models/BoundsChecking/invalid-buffer-index.gltf
@@ -1,53 +0,0 @@
-{
-  "scenes": [],
-  "nodes": [],
-  "meshes": [
-    {
-      "primitives": [
-        {
-          "attributes": {},
-          "indices": 0
-        }
-      ]
-    }
-  ],
-  "buffers": [
-    {
-      "uri": "simpleTriangle.bin",
-      "byteLength": 44
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 6,
-      "target": 34963
-    },
-    {
-      "buffer": 1,
-      "byteOffset": 0,
-      "byteLength": 6,
-      "target": 34963
-    }
-  ],
-  "images": [
-    {
-      "bufferView": 1,
-      "mimeType": "image/png"
-    }
-  ],
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5123,
-      "count": 3,
-      "type": "SCALAR",
-      "max": [2],
-      "min": [0]
-    }
-  ],
-  "asset": {
-    "version": "2.0"
-  }
-}
--- a/models/BoundsChecking/invalid-buffer-view-index.gltf
+++ b/models/BoundsChecking/invalid-buffer-view-index.gltf
@@ -1,36 +0,0 @@
-{
-  "scenes": [],
-  "nodes": [],
-  "buffers": [],
-  "meshes": [
-    {
-      "primitives": [
-        {
-          "attributes": {},
-          "indices": 0
-        }
-      ]
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 6,
-      "target": 34963
-    }
-  ],
-  "accessors": [
-    {
-      "bufferView": 1,
-      "componentType": 5123,
-      "count": 3,
-      "type": "SCALAR",
-      "max": [2],
-      "min": [0]
-    }
-  ],
-  "asset": {
-    "version": "2.0"
-  }
-}
--- a/models/BoundsChecking/invalid-primitive-indices.gltf
+++ b/models/BoundsChecking/invalid-primitive-indices.gltf
@@ -1,36 +0,0 @@
-{
-  "scenes": [],
-  "nodes": [],
-  "buffers": [],
-  "meshes": [
-    {
-      "primitives": [
-        {
-          "attributes": {},
-          "indices": 1
-        }
-      ]
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 6,
-      "target": 34963
-    }
-  ],
-  "accessors": [
-    {
-      "bufferView": 1,
-      "componentType": 5123,
-      "count": 3,
-      "type": "SCALAR",
-      "max": [2],
-      "min": [0]
-    }
-  ],
-  "asset": {
-    "version": "2.0"
-  }
-}
--- a/models/BoundsChecking/simpleTriangle.bin
+++ b/models/BoundsChecking/simpleTriangle.bin
--- a/models/Cube-texture-ext/Cube-textransform.gltf
+++ b/models/Cube-texture-ext/Cube-textransform.gltf
@@ -1,224 +0,0 @@
-{
-  "accessors": [
-    {
-      "bufferView": 0,
-      "byteOffset": 0,
-      "componentType": 5123,
-      "count": 36,
-      "max": [
-        35
-      ],
-      "min": [
-        0
-      ],
-      "type": "SCALAR"
-    },
-    {
-      "bufferView": 1,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1,
-        1.000001
-      ],
-      "min": [
-        -1,
-        -1,
-        -1
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1,
-        1
-      ],
-      "min": [
-        -1,
-        -1,
-        -1
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 3,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        -0,
-        -0,
-        1
-      ],
-      "min": [
-        0,
-        -0,
-        -1,
-        -1
-      ],
-      "type": "VEC4"
-    },
-    {
-      "bufferView": 4,
-      "byteOffset": 0,
-      "componentType": 5126,
-      "count": 36,
-      "max": [
-        1,
-        1
-      ],
-      "min": [
-        -1,
-        -1
-      ],
-      "type": "VEC2"
-    }
-  ],
-  "asset": {
-    "generator": "VKTS glTF 2.0 exporter",
-    "version": "2.0"
-  },
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 72,
-      "byteOffset": 0,
-      "target": 34963
-    },
-    {
-      "buffer": 0,
-      "byteLength": 432,
-      "byteOffset": 72,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 432,
-      "byteOffset": 504,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 576,
-      "byteOffset": 936,
-      "target": 34962
-    },
-    {
-      "buffer": 0,
-      "byteLength": 288,
-      "byteOffset": 1512,
-      "target": 34962
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 1800,
-      "uri": "Cube.bin"
-    }
-  ],
-  "images": [
-    {
-      "0comment": "Use Cube_MetallicRoughness.png to reduce scene filesize",
-      "uri": "Cube_MetallicRoughness.png"
-    },
-    {
-      "uri": "Cube_MetallicRoughness.png"
-    }
-  ],
-  "materials": [
-    {
-      "emissiveTexture": {
-        "index": 0,
-        "extensions": {
-          "KHR_texture_transform": {
-            "offset": [
-              0,
-              1
-            ],
-            "scale": [
-              1,
-              -1
-            ]
-          }
-        }
-      }
-    },
-    {
-      "name": "Cube",
-      "pbrMetallicRoughness": {
-        "baseColorTexture": {
-          "index": 0
-        },
-        "metallicRoughnessTexture": {
-          "index": 1,
-          "extensions": {
-            "KHR_texture_transform": {
-              "offset": [
-                0,
-                1
-              ],
-              "rotation": 1.57079632679,
-              "scale": [
-                0.5,
-                0.5
-              ]
-            }
-          }
-        }
-      }
-    }
-  ],
-  "meshes": [
-    {
-      "name": "Cube",
-      "primitives": [
-        {
-          "attributes": {
-            "NORMAL": 2,
-            "POSITION": 1,
-            "TANGENT": 3,
-            "TEXCOORD_0": 4
-          },
-          "indices": 0,
-          "material": 0,
-          "mode": 4
-        }
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "Cube"
-    }
-  ],
-  "samplers": [
-    {}
-  ],
-  "scene": 0,
-  "scenes": [
-    {
-      "nodes": [
-        0
-      ]
-    }
-  ],
-  "textures": [
-    {
-      "sampler": 0,
-      "source": 0
-    },
-    {
-      "sampler": 0,
-      "source": 1
-    }
-  ]
-}
--- a/models/Cube-texture-ext/Cube.bin
+++ b/models/Cube-texture-ext/Cube.bin
--- a/models/Cube-texture-ext/Cube_MetallicRoughness.png
+++ b/models/Cube-texture-ext/Cube_MetallicRoughness.png
--- a/models/Cube-texture-ext/README.md
+++ b/models/Cube-texture-ext/README.md
@@ -1,6 +0,0 @@
-Added KHR_texture_transform property to Cube scene.
-
-License: Donated by Norbert Nopper for glTF testing.
-
-https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/2.0/Cube
-
--- a/stb_image.h
+++ b/stb_image.h
--- a/stb_image_write.h
+++ b/stb_image_write.h
--- a/test_runner.py
+++ b/test_runner.py
@@ -14,7 +14,6 @@ import subprocess
 sample_model_dir = "/home/syoyo/work/glTF-Sample-Models"
 base_model_dir = os.path.join(sample_model_dir, "2.0")

-# Include `glTF-Draco` when you build `loader_example` with draco support.
 kinds = [ "glTF", "glTF-Binary", "glTF-Embedded", "glTF-MaterialsCommon"]
 # ---------------------------------

--- a/tests/tester.cc
+++ b/tests/tester.cc
@@ -13,14 +13,6 @@
 #include <sstream>
 #include <fstream>

-static JsonDocument JsonConstruct(const char* str)
-{
-  JsonDocument doc;
-  JsonParse(doc, str, strlen(str));
-  return doc;
-}
-
-
 TEST_CASE("parse-error", "[parse]") {

  tinygltf::Model model;
@@ -28,7 +20,7 @@ TEST_CASE("parse-error", "[parse]") {
  std::string err;
  std::string warn;

-  bool ret = ctx.LoadASCIIFromString(&model, &err, &warn, "bora", static_cast<int>(strlen("bora")), /* basedir*/ "");
+  bool ret = ctx.LoadASCIIFromString(&model, &err, &warn, "bora", strlen("bora"), /* basedir*/ "");

  REQUIRE(false == ret);

@@ -45,7 +37,7 @@ TEST_CASE("datauri-in-glb", "[issue-79]") {
  if (!err.empty()) {
    std::cerr << err << std::endl;
  }
-
+    
  REQUIRE(true == ret);
 }

@@ -90,246 +82,7 @@ TEST_CASE("extension-with-empty-object", "[issue-97]") {
    REQUIRE(m.materials[0].extensions.size() == 1);
    REQUIRE(m.materials[0].extensions.count("VENDOR_material_some_ext") == 1);
  }
-
+    
 }

-TEST_CASE("invalid-primitive-indices", "[bounds-checking]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;

-  // Loading is expected to fail, but not crash.
-  bool ret = ctx.LoadASCIIFromFile(
-      &model, &err, &warn,
-      "../models/BoundsChecking/invalid-primitive-indices.gltf");
-  REQUIRE_THAT(err,
-               Catch::Contains("primitive indices accessor out of bounds"));
-  REQUIRE_FALSE(ret);
-}
-
-TEST_CASE("invalid-buffer-view-index", "[bounds-checking]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  // Loading is expected to fail, but not crash.
-  bool ret = ctx.LoadASCIIFromFile(
-      &model, &err, &warn,
-      "../models/BoundsChecking/invalid-buffer-view-index.gltf");
-  REQUIRE_THAT(err, Catch::Contains("accessor[0] invalid bufferView"));
-  REQUIRE_FALSE(ret);
-}
-
-TEST_CASE("invalid-buffer-index", "[bounds-checking]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  // Loading is expected to fail, but not crash.
-  bool ret = ctx.LoadASCIIFromFile(
-      &model, &err, &warn,
-      "../models/BoundsChecking/invalid-buffer-index.gltf");
-  REQUIRE_THAT(
-      err, Catch::Contains("image[0] buffer \"1\" not found in the scene."));
-  REQUIRE_FALSE(ret);
-}
-
-TEST_CASE("glb-invalid-length", "[bounds-checking]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  // This glb has a much longer length than the provided data and should fail
-  // initial range checks.
-  const unsigned char glb_invalid_length[] = "glTF"
-      "\x20\x00\x00\x00" "\x6c\x66\x00\x00"     //
-  //  |     version     |     length      |
-      "\x02\x00\x00\x00" "\x4a\x53\x4f\x4e{}";  //
-  //  |  model length   |   model format  |
-
-  bool ret = ctx.LoadBinaryFromMemory(&model, &err, &warn, glb_invalid_length,
-                                      sizeof(glb_invalid_length));
-  REQUIRE_THAT(err, Catch::Contains("Invalid glTF binary."));
-  REQUIRE_FALSE(ret);
-}
-
-TEST_CASE("integer-out-of-bounds", "[bounds-checking]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  // Loading is expected to fail, but not crash.
-  bool ret = ctx.LoadASCIIFromFile(
-      &model, &err, &warn,
-      "../models/BoundsChecking/integer-out-of-bounds.gltf");
-  REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-  REQUIRE_FALSE(ret);
-}
-
-TEST_CASE("parse-integer", "[bounds-checking]") {
-  SECTION("parses valid numbers") {
-    std::string err;
-    int result = 123;
-    CHECK(tinygltf::ParseIntegerProperty(&result, &err, JsonConstruct("{\"zero\" : 0}"), "zero",
-                                         true));
-    REQUIRE(err == "");
-    REQUIRE(result == 0);
-
-    CHECK(tinygltf::ParseIntegerProperty(&result, &err, JsonConstruct("{\"int\": -1234}"), "int",
-                                         true));
-    REQUIRE(err == "");
-    REQUIRE(result == -1234);
-  }
-
-  SECTION("detects missing properties") {
-    std::string err;
-    int result = -1;
-    CHECK_FALSE(tinygltf::ParseIntegerProperty(&result, &err, JsonConstruct(""), "int", true));
-    REQUIRE_THAT(err, Catch::Contains("'int' property is missing"));
-    REQUIRE(result == -1);
-  }
-
-  SECTION("handled missing but not required properties") {
-    std::string err;
-    int result = -1;
-    CHECK_FALSE(
-        tinygltf::ParseIntegerProperty(&result, &err, JsonConstruct(""), "int", false));
-    REQUIRE(err == "");
-    REQUIRE(result == -1);
-  }
-
-  SECTION("invalid integers") {
-    std::string err;
-    int result = -1;
-
-    CHECK_FALSE(tinygltf::ParseIntegerProperty(&result, &err, JsonConstruct("{\"int\": 0.5}"),
-      "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not an integer type"));
-
-    // Excessively large values and NaN aren't allowed either.
-    err.clear();
-    CHECK_FALSE(tinygltf::ParseIntegerProperty(&result, &err, JsonConstruct("{\"int\": 1e300}"),
-      "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not an integer type"));
-
-    err.clear();
-    {
-      JsonDocument o;
-      double nan = std::numeric_limits<double>::quiet_NaN();
-      tinygltf::JsonAddMember(o, "int", json(nan));
-      CHECK_FALSE(tinygltf::ParseIntegerProperty(
-        &result, &err, o,
-        "int", true));
-      REQUIRE_THAT(err, Catch::Contains("not an integer type"));
-    }
-  }
-}
-
-TEST_CASE("parse-unsigned", "[bounds-checking]") {
-  SECTION("parses valid unsigned integers") {
-    // Use string-based parsing here, using the initializer list syntax doesn't
-    // parse 0 as unsigned.
-    auto zero_obj = JsonConstruct("{\"zero\": 0}");
-
-    std::string err;
-    size_t result = 123;
-    CHECK(
-        tinygltf::ParseUnsignedProperty(&result, &err, zero_obj, "zero", true));
-    REQUIRE(err == "");
-    REQUIRE(result == 0);
-  }
-
-  SECTION("invalid integers") {
-    std::string err;
-    size_t result = -1;
-
-    CHECK_FALSE(tinygltf::ParseUnsignedProperty(&result, &err, JsonConstruct("{\"int\": -1234}"),
-                                                "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-
-    err.clear();
-    CHECK_FALSE(tinygltf::ParseUnsignedProperty(&result, &err, JsonConstruct("{\"int\": 0.5}"),
-                                                "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-
-    // Excessively large values and NaN aren't allowed either.
-    err.clear();
-    CHECK_FALSE(tinygltf::ParseUnsignedProperty(&result, &err, JsonConstruct("{\"int\": 1e300}"),
-                                                "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-
-    err.clear();
-    {
-      JsonDocument o;
-      double nan = std::numeric_limits<double>::quiet_NaN();
-      tinygltf::JsonAddMember(o, "int", json(nan));
-      CHECK_FALSE(tinygltf::ParseUnsignedProperty(
-        &result, &err, o,
-        "int", true));
-      REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-    }
-  }
-}
-
-TEST_CASE("parse-integer-array", "[bounds-checking]") {
-  SECTION("parses valid integers") {
-    std::string err;
-    std::vector<int> result;
-    CHECK(tinygltf::ParseIntegerArrayProperty(&result, &err,
-                                              JsonConstruct("{\"x\": [-1, 2, 3]}"), "x", true));
-    REQUIRE(err == "");
-    REQUIRE(result.size() == 3);
-    REQUIRE(result[0] == -1);
-    REQUIRE(result[1] == 2);
-    REQUIRE(result[2] == 3);
-  }
-
-  SECTION("invalid integers") {
-    std::string err;
-    std::vector<int> result;
-    CHECK_FALSE(tinygltf::ParseIntegerArrayProperty(
-        &result, &err, JsonConstruct("{\"x\": [-1, 1e300, 3]}"), "x", true));
-    REQUIRE_THAT(err, Catch::Contains("not an integer type"));
-  }
-}
-
-TEST_CASE("pbr-khr-texture-transform", "[material]") {
-  tinygltf::Model model;
-  tinygltf::TinyGLTF ctx;
-  std::string err;
-  std::string warn;
-
-  // Loading is expected to fail, but not crash.
-  bool ret = ctx.LoadASCIIFromFile(
-      &model, &err, &warn,
-      "../models/Cube-texture-ext/Cube-textransform.gltf");
-  REQUIRE(ret == true);
-
-  REQUIRE(model.materials.size() == 2);
-  REQUIRE(model.materials[0].emissiveTexture.extensions.count("KHR_texture_transform") == 1);
-  REQUIRE(model.materials[0].emissiveTexture.extensions["KHR_texture_transform"].IsObject());
-
-  tinygltf::Value::Object &texform = model.materials[0].emissiveTexture.extensions["KHR_texture_transform"].Get<tinygltf::Value::Object>();
-
-  REQUIRE(texform.count("scale"));
-
-  REQUIRE(texform["scale"].IsArray());
-
-  // Note: It looks json.hpp parse integer JSON number as integer, not floating point.
-  // IsNumber return true either value is int or floating point.
-  REQUIRE(texform["scale"].Get(0).IsNumber());
-  REQUIRE(texform["scale"].Get(1).IsNumber());
-
-  double scale[2];
-  scale[0] = texform["scale"].Get(0).GetNumberAsDouble();
-  scale[1] = texform["scale"].Get(1).GetNumberAsDouble();
-
-  REQUIRE(scale[0] == Approx(1.0));
-  REQUIRE(scale[1] == Approx(-1.0));
-
-}
--- a/tiny_gltf.h
+++ b/tiny_gltf.h
Author	SHA1	Message	Date
Syoyo Fujita	1b7994a4f4	Make lodepng optional.	2019-01-14 21:33:56 +09:00
Syoyo Fujita	c91b6468e8	Merge pull request #133 from Ybalrid/lodepng fix ci build of example	2019-01-11 02:29:29 +09:00
Arthur Brainville (Ybalrid)	d4f8fcea10	fix ci build of example	2019-01-10 18:19:20 +00:00
Syoyo Fujita	ab069ffb40	Initial support of loading 16bit PNG using lodepng.	2019-01-07 02:27:28 +09:00
Syoyo Fujita	cbf13fef62	Merge branch 'master' into lodepng	2019-01-07 01:05:12 +09:00
Syoyo Fujita	57074aee04	Add single file version of lodepng.	2019-01-07 01:04:37 +09:00