Add document on schema validation feature.

Now schema validation is getting to work.

.gitignore

@@ -67,5 +67,4 @@ imgui.ini
 loader_example
 tests/tester
 tests/tester_noexcept
-tests/issue-97.gltf
 

.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

LICENSE.rapidjson.txt

@@ -0,0 +1,13 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.

LICENSE.tinyktx

@@ -1,25 +0,0 @@
-BSD 2-Clause License
-
-Copyright (c) 2019, DeanoC
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -2,12 +2,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.
+`TinyGLTF` uses single-header version of RapidJson(https://github.com/Tencent/rapidjson) as a JSON parser.
 
 ## Status
 
- - v2.3.0 release(Support loading KTX image through tiny_ktx)
+ - v2.3.0 release(Support built-in schema validation)
  - v2.2.0 release(Support loading 16bit PNG. Sparse accessor support)
  - v2.1.0 release(Draco support)
  - v2.0.0 release(22 Aug, 2018)!
@@ -35,6 +34,7 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
   * [x] ASCII glTF
   * [x] Binary glTF(GLB)
   * [x] PBR material description
+  * [x] Validate inpit glTF JSON with schema
 * Buffers
   * [x] Parse BASE64 encoded embedded buffer data(DataURI).
   * [x] Load `.bin` file.
@@ -53,8 +53,7 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
   * [x] Image load
   * [x] Image save
 * Extensions
-  * [x] Draco mesh decoding(`TINYGLTF_ENABLE_DRACO` required)
-  * [x] KTX image support(no mipmap. `TINYGLTF_ENABLE_KTX` required)
+  * [x] Draco mesh decoding
 
 ## Examples
 
@@ -68,9 +67,13 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
 * 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)
 
+## For developer
+
+Generate single rapidjson file using this node.js script: https://github.com/Tencent/rapidjson/issues/863
+Add `cursorstreamwrapper.h` and `error/en.h` inclusion in `rapidjson-all.h` before running merge script.
+
 ## TODOs
 
 * [ ] Write C++ code generator which emits C++ code from JSON schema for robust parsing.
@@ -83,7 +86,6 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
   * [ ] OpenEXR extension through TinyEXR.
 * [ ] 16bit PNG support in Serialization
 * [ ] Write example and tests for `animation` and `skin`
-* [ ] mipmap support for KTX image.
 
 ## Licenses
 
@@ -95,14 +97,11 @@ 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)
-* tinyktx.h : Copyright (c) 2019, DeanoC. Licensed under 2 clause BSD license.
 
 
 ## Build and example
 
-Copy `stb_image.h`, `stb_image_write.h`, `json.hpp` and `tiny_gltf.h` to your project.
-
-If you enable KTX support(`TINYGLTF_ENABLE_KTX`), Copy `tinyktx.h` to your project.
+Copy `stb_image.h`, `stb_image_write.h`, `rapidjson-amalgamation.h` and `tiny_gltf.h` to your project.
 
 ### Loading glTF 2.0 model
 
@@ -111,6 +110,7 @@ If you enable KTX support(`TINYGLTF_ENABLE_KTX`), Copy `tinyktx.h` to your proje
 #define TINYGLTF_IMPLEMENTATION
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
+// #define TINYGLTF_ENABLE_SCHEMA_VALIDATOR // optional. enable schema validation API.
 // #define TINYGLTF_NOEXCEPTION // optional. disable exception handling.
 #include "tiny_gltf.h"
 
@@ -123,6 +123,10 @@ 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)
+// Validate with glTF Schema
+// #if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR)
+// bool ret = loader.LoadASCIIFromFileWithValidation(&model, &err, &warn, argv[1]);
+// #endif
 
 if (!warn.empty()) {
   printf("Warn: %s\n", warn.c_str());
@@ -140,6 +144,7 @@ if (!ret) {
 
 ## Compile options
 
+* `TINYGLTF_ENABLE_SCHEMA_VALIDATOR` : Enable API with schema validation. glTF Schema JSON(`gltf.schema.resolved.inc`) are embeded into application binary, thus no need to read glTF Schema file at a runtime.
 * `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.
@@ -149,8 +154,6 @@ if (!ret) {
 * `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_ENABLE_KTX` : Enable loading KTX images( https://www.khronos.org/opengles/sdk/tools/KTX/ ) using `tiny_ktx.h`. Supported MIME is `image/ktx` ( https://github.com/KhronosGroup/glTF/issues/835 ). See `models/Cube-KTX` for details. Application also defined `TINYKTX_IMPLEMENTATION` in **one** .cc file.
-  * `TINYGLTF_NO_INCLUDE_TINYKTX` : Disable including `tinyktx.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`.
 
 
 ### Saving gltTF 2.0 model
@@ -189,6 +192,8 @@ $ ./tester
 $ ./tester_noexcept
 ```
 
-## Third party licenses used in unit tests
+## Third party licenses
 
+* json.hpp : Licensed under the MIT License <http://opensource.org/licenses/MIT>. Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
+* stb_image : Public domain.
 * catch : Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. Distributed under the Boost Software License, Version 1.0.

examples/basic/main.cpp

@@ -1,460 +1,365 @@
-#include <fstream>
-#include <iostream>
-
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include <glm/gtc/matrix_transform.hpp>
-
-#include "shaders.h"
-#include "window.h"
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Weverything"
-#endif
-
-// Inlude tinyktx.h before tiny_gltf.h
-// to get TKTX_*** definitions
-#define TINYKTX_IMPLEMENTATION
-#include "../../tinyktx.h"
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#define TINYGLTF_IMPLEMENTATION
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#define TINYGLTF_NOEXCEPTION
-#define JSON_NOEXCEPTION
-#define TINYGLTF_ENABLE_KTX
-// tinyktx.h is already included above,
-// so let tiny_gltf.h know do not include tinyktx.h anymore
-#define TINYGLTF_NO_INCLUDE_TINY_KTX
-#include "../../tiny_gltf.h"
-
-//#define BUFFER_OFFSET(i) ((char *)nullptr + (i))
-#define BUFFER_OFFSET(i) \
-  (reinterpret_cast<void *>(i))  // TODO(syoyo): Is this right way?
-
-bool loadModel(tinygltf::Model &model, const char *filename) {
-  tinygltf::TinyGLTF loader;
-  std::string err;
-  std::string warn;
-
-  bool res = loader.LoadASCIIFromFile(&model, &err, &warn, filename);
-  if (!warn.empty()) {
-    std::cout << "WARN: " << warn << std::endl;
-  }
-
-  if (!err.empty()) {
-    std::cout << "ERR: " << err << std::endl;
-  }
-
-  if (!res)
-    std::cout << "Failed to load glTF: " << filename << std::endl;
-  else
-    std::cout << "Loaded glTF: " << filename << std::endl;
-
-  return res;
-}
-
-static bool GetOpenGLFormatFromKTX(int ktx_fmt, GLint *internal_format, GLenum *format, GLenum *type) {
-#if defined(TINYGLTF_ENABLE_KTX)
-    bool ret = true;
-
-    std::cout << "fmt = " << ktx_fmt << ", rgb8 fmt = " << TKTX_R8G8B8_UNORM << "\n";
-
-    if (ktx_fmt == TKTX_R8G8B8_UNORM) {
-      (*internal_format) = GL_RGB;
-      (*format) = GL_RGB;
-      (*type) = GL_UNSIGNED_BYTE;
-    } else {
-      // TODO(syoyo): Support more KTX formats.
-      ret = false;
-    }
-
-    return ret;
-#else
-    (void)fmt;
-    (void)internal_format;
-    (void)internal_format;
-    return false;
-#endif
-}
-
-std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
-                               tinygltf::Model &model, tinygltf::Mesh &mesh) {
-  for (size_t i = 0; i < model.bufferViews.size(); ++i) {
-    const tinygltf::BufferView &bufferView = model.bufferViews[i];
-    if (bufferView.target == 0) {  // TODO impl drawarrays
-      std::cout << "WARN: bufferView.target is zero" << std::endl;
-      continue;  // Unsupported bufferView.
-                 /*
-                   From spec2.0 readme:
-                   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0
-                            ... drawArrays function should be used with a count equal to
-                   the count            property of any of the accessors referenced by the
-                   attributes            property            (they are all equal for a
-                   given            primitive).
-                 */
-    }
-
-    tinygltf::Buffer buffer = model.buffers[bufferView.buffer];
-    std::cout << "bufferview.target " << bufferView.target << std::endl;
-
-    GLuint vbo;
-    glGenBuffers(1, &vbo);
-    vbos[i] = vbo;
-    glBindBuffer(bufferView.target, vbo);
-
-    std::cout << "buffer.data.size = " << buffer.data.size()
-              << ", bufferview.byteOffset = " << bufferView.byteOffset
-              << std::endl;
-
-    glBufferData(bufferView.target, bufferView.byteLength,
-                 &buffer.data.at(0) + bufferView.byteOffset, GL_STATIC_DRAW);
-  }
-
-  for (size_t i = 0; i < mesh.primitives.size(); ++i) {
-    tinygltf::Primitive primitive = mesh.primitives[i];
-    tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
-
-    for (auto &attrib : primitive.attributes) {
-      tinygltf::Accessor accessor = model.accessors[attrib.second];
-      int byteStride =
-          accessor.ByteStride(model.bufferViews[accessor.bufferView]);
-      glBindBuffer(GL_ARRAY_BUFFER, vbos[accessor.bufferView]);
-
-      int size = 1;
-      if (accessor.type != TINYGLTF_TYPE_SCALAR) {
-        size = accessor.type;
-      }
-
-      int vaa = -1;
-      if (attrib.first.compare("POSITION") == 0) vaa = 0;
-      if (attrib.first.compare("NORMAL") == 0) vaa = 1;
-      if (attrib.first.compare("TEXCOORD_0") == 0) vaa = 2;
-      if (vaa > -1) {
-        glEnableVertexAttribArray(vaa);
-        glVertexAttribPointer(vaa, size, accessor.componentType,
-                              accessor.normalized ? GL_TRUE : GL_FALSE,
-                              byteStride, BUFFER_OFFSET(accessor.byteOffset));
-      } else
-        std::cout << "Unsupported vertex attribute: " << attrib.first << std::endl;
-    }
-
-    GLuint texid;
-    glGenTextures(1, &texid);
-
-    tinygltf::Texture &tex = model.textures[0];
-    tinygltf::Image &image = model.images[tex.source];
-
-    glBindTexture(GL_TEXTURE_2D, texid);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
-    GLint internal_format = GL_RGBA;
-    GLenum format = GL_RGBA;
-    GLenum type = GL_UNSIGNED_BYTE;
-
-    bool valid = false;
-
-    // KTX extension
-    if (image.extras.Has("ktx_format")) {
-
-      valid = GetOpenGLFormatFromKTX(image.extras.Get("ktx_format").Get<int>(), &internal_format, &format, &type);
-
-      if (valid) {
-
-        std::cout << "ktx_format: " << image.extras.Get("ktx_format").Get<int>() << std::endl;
-        std::cout << "ktx image size: " << image.width << ", " << image.height << std::endl;
-      }
-
-    } else {
-
-      valid = true;
-
-      if (image.component == 1) {
-        format = GL_RED;
-      } else if (image.component == 2) {
-        format = GL_RG;
-      } else if (image.component == 3) {
-        format = GL_RGB;
-      } else if (image.component == 4) {
-        format = GL_RGBA;
-      } else {
-        valid = false;
-      }
-
-      if (image.bits == 8) {
-        type = GL_UNSIGNED_BYTE;
-      } else if (image.bits == 16) {
-        type = GL_UNSIGNED_SHORT;
-      } else {
-        valid = false;
-      }
-
-    }
-
-    if (valid) {
-
-      glTexImage2D(GL_TEXTURE_2D, 0, internal_format, image.width, image.height, 0,
-                   format, type, &image.image.at(0));
-    }
-  }
-
-  return vbos;
-}
-
-// bind models
-void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model,
-                    tinygltf::Node &node) {
-  bindMesh(vbos, model, model.meshes[node.mesh]);
-  for (size_t i = 0; i < node.children.size(); i++) {
-    bindModelNodes(vbos, model, model.nodes[node.children[i]]);
-  }
-}
-GLuint bindModel(tinygltf::Model &model) {
-  std::map<int, GLuint> vbos;
-  GLuint vao;
-  glGenVertexArrays(1, &vao);
-  glBindVertexArray(vao);
-
-  const tinygltf::Scene &scene = model.scenes[model.defaultScene];
-  for (size_t i = 0; i < scene.nodes.size(); ++i) {
-    bindModelNodes(vbos, model, model.nodes[scene.nodes[i]]);
-  }
-
-  glBindVertexArray(0);
-  // cleanup vbos
-  for (size_t i = 0; i < vbos.size(); ++i) {
-    glDeleteBuffers(1, &vbos[i]);
-  }
-
-  return vao;
-}
-
-void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
-  for (size_t i = 0; i < mesh.primitives.size(); ++i) {
-    tinygltf::Primitive primitive = mesh.primitives[i];
-    tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
-
-    glDrawElements(primitive.mode, indexAccessor.count,
-                   indexAccessor.componentType,
-                   BUFFER_OFFSET(indexAccessor.byteOffset));
-  }
-}
-
-// recursively draw node and children nodes of model
-void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) {
-  drawMesh(model, model.meshes[node.mesh]);
-  for (size_t i = 0; i < node.children.size(); i++) {
-    drawModelNodes(model, model.nodes[node.children[i]]);
-  }
-}
-void drawModel(GLuint vao, tinygltf::Model &model) {
-  glBindVertexArray(vao);
-
-  const tinygltf::Scene &scene = model.scenes[model.defaultScene];
-  for (size_t i = 0; i < scene.nodes.size(); ++i) {
-    drawModelNodes(model, model.nodes[scene.nodes[i]]);
-  }
-
-  glBindVertexArray(0);
-}
-
-void dbgModel(tinygltf::Model &model) {
-  for (auto &mesh : model.meshes) {
-    std::cout << "mesh : " << mesh.name << std::endl;
-    for (auto &primitive : mesh.primitives) {
-      const tinygltf::Accessor &indexAccessor =
-          model.accessors[primitive.indices];
-
-      std::cout << "indexaccessor: count " << indexAccessor.count << ", type "
-                << indexAccessor.componentType << std::endl;
-
-      tinygltf::Material &mat = model.materials[primitive.material];
-      for (auto &mats : mat.values) {
-        std::cout << "mat : " << mats.first.c_str() << std::endl;
-      }
-
-      for (auto &image : model.images) {
-        std::cout << "image name : " << image.uri << std::endl;
-        std::cout << "  size : " << image.image.size() << std::endl;
-        std::cout << "  w/h : " << image.width << "/" << image.height
-                  << std::endl;
-      }
-
-      std::cout << "indices : " << primitive.indices << std::endl;
-      std::cout << "mode     : "
-                << "(" << primitive.mode << ")" << std::endl;
-
-      for (auto &attrib : primitive.attributes) {
-        std::cout << "attribute : " << attrib.first.c_str() << std::endl;
-      }
-    }
-  }
-}
-
-glm::mat4 genView(glm::vec3 pos, glm::vec3 lookat) {
-  // Camera matrix
-  glm::mat4 view = glm::lookAt(
-      pos,                // Camera in World Space
-      lookat,             // and looks at the origin
-      glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
-  );
-
-  return view;
-}
-
-glm::mat4 genMVP(glm::mat4 view_mat, glm::mat4 model_mat, float fov, int w,
-                 int h) {
-  glm::mat4 Projection =
-      glm::perspective(glm::radians(fov), (float)w / (float)h, 0.01f, 1000.0f);
-
-  // Or, for an ortho camera :
-  // glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f);
-  // // In world coordinates
-
-  glm::mat4 mvp = Projection * view_mat * model_mat;
-
-  return mvp;
-}
-
-void displayLoop(Window &window, const std::string &filename) {
-  Shaders shader = Shaders();
-  glUseProgram(shader.pid);
-
-  // grab uniforms to modify
-  GLuint MVP_u = glGetUniformLocation(shader.pid, "MVP");
-  GLuint sun_position_u = glGetUniformLocation(shader.pid, "sun_position");
-  GLuint sun_color_u = glGetUniformLocation(shader.pid, "sun_color");
-
-  tinygltf::Model model;
-  if (!loadModel(model, filename.c_str())) return;
-
-  GLuint vao = bindModel(model);
-  // dbgModel(model); return;
-
-  // Model matrix : an identity matrix (model will be at the origin)
-  glm::mat4 model_mat = glm::mat4(1.0f);
-  glm::mat4 model_rot = glm::mat4(1.0f);
-  glm::vec3 model_pos = glm::vec3(-3, 0, -3);
-
-  // generate a camera view, based on eye-position and lookAt world-position
-  glm::mat4 view_mat = genView(glm::vec3(2, 2, 20), model_pos);
-
-  glm::vec3 sun_position = glm::vec3(3.0, 10.0, -5.0);
-  glm::vec3 sun_color = glm::vec3(1.0);
-
-  while (!window.Close()) {
-    window.Resize();
-
-    glClearColor(0.2, 0.2, 0.2, 1.0);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-    glm::mat4 trans =
-        glm::translate(glm::mat4(1.0f), model_pos);  // reposition model
-    model_rot = glm::rotate(model_rot, glm::radians(0.8f),
-                            glm::vec3(0, 1, 0));  // rotate model on y axis
-    model_mat = trans * model_rot;
-
-    // build a model-view-projection
-    GLint w, h;
-    glfwGetWindowSize(window.window, &w, &h);
-    glm::mat4 mvp = genMVP(view_mat, model_mat, 45.0f, w, h);
-    glUniformMatrix4fv(MVP_u, 1, GL_FALSE, &mvp[0][0]);
-
-    glUniform3fv(sun_position_u, 1, &sun_position[0]);
-    glUniform3fv(sun_color_u, 1, &sun_color[0]);
-
-    drawModel(vao, model);
-    glfwSwapBuffers(window.window);
-    glfwPollEvents();
-  }
-}
-
-static void error_callback(int error, const char *description) {
-  (void)error;
-  fprintf(stderr, "Error: %s\n", description);
-}
-
-static void drop_callback(GLFWwindow *window, int num, const char **paths) {
-  (void)window;
-  printf("dropCB %d\n", num);
-  for (int i = 0; i < num; i++) {
-      printf("%s\n", paths[i]);
-  }
-}
-
-int main(int argc, char **argv) {
-  std::string filename = "../../models/Cube/Cube.gltf";
-
-  if (argc > 1) {
-    filename = argv[1];
-  }
-
-  glfwSetErrorCallback(error_callback);
-
-  if (!glfwInit()) return -1;
-
-    // NOTE(syoyo): For some reason, Linux + NVIDIA driver + apt-installed
-    // glew(1.13) cannot initialize some ARB functions when CONTEXT_VERSION are
-    // explicitly given. Proably we need to compile app with recent glfw and
-    // glew(or use glad) package
-#if !defined(__linux__)
-  // Try to create OpenGL 3.3 context on Windows and macOS
-  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-#endif
-
-  // glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-#ifdef __APPLE__
-  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-#endif
-
-  Window window = Window(800, 600, "TinyGLTF basic example");
-
-  glfwSetDropCallback(window.window, drop_callback);
-
-  glfwMakeContextCurrent(window.window);
-
-#ifdef __APPLE__
-  // https://stackoverflow.com/questions/50192625/openggl-segmentation-fault
-  glewExperimental = GL_TRUE;
-#endif
-
-  if (glewInit() != GLEW_OK) {
-    std::cerr << "Failed to initialie glew." << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << glGetString(GL_RENDERER) << ", " << glGetString(GL_VERSION)
-            << std::endl;
-
-  if (!GLEW_ARB_vertex_array_object) {
-    std::cerr << "GLEW_ARB_vertex_array_object was not available." << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  if (!GLEW_VERSION_3_3) {
-    std::cerr << "OpenGL 3.3 is required to execute this app." << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  glEnable(GL_DEPTH_TEST);
-  glDepthFunc(GL_LESS);
-
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  glEnable(GL_BLEND);
-
-  displayLoop(window, filename);
-
-  glfwTerminate();
-  return 0;
-}
+#include <fstream>
+#include <iostream>
+
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include "shaders.h"
+#include "window.h"
+
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define TINYGLTF_NOEXCEPTION
+#define JSON_NOEXCEPTION
+#include "../../tiny_gltf.h"
+
+#define BUFFER_OFFSET(i) ((char *)NULL + (i))
+
+bool loadModel(tinygltf::Model &model, const char *filename) {
+  tinygltf::TinyGLTF loader;
+  std::string err;
+  std::string warn;
+
+  bool res = loader.LoadASCIIFromFile(&model, &err, &warn, filename);
+  if (!warn.empty()) {
+    std::cout << "WARN: " << warn << std::endl;
+  }
+
+  if (!err.empty()) {
+    std::cout << "ERR: " << err << std::endl;
+  }
+
+  if (!res)
+    std::cout << "Failed to load glTF: " << filename << std::endl;
+  else
+    std::cout << "Loaded glTF: " << filename << std::endl;
+
+  return res;
+}
+
+std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
+                               tinygltf::Model &model, tinygltf::Mesh &mesh) {
+  for (size_t i = 0; i < model.bufferViews.size(); ++i) {
+    const tinygltf::BufferView &bufferView = model.bufferViews[i];
+    if (bufferView.target == 0) {  // TODO impl drawarrays
+      std::cout << "WARN: bufferView.target is zero" << std::endl;
+      continue;  // Unsupported bufferView.
+                 /*
+                   From spec2.0 readme:
+                   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0
+                            ... drawArrays function should be used with a count equal to
+                   the count            property of any of the accessors referenced by the
+                   attributes            property            (they are all equal for a given
+                   primitive).
+                 */
+    }
+
+    tinygltf::Buffer buffer = model.buffers[bufferView.buffer];
+    std::cout << "bufferview.target " << bufferView.target << std::endl;
+
+    GLuint vbo;
+    glGenBuffers(1, &vbo);
+    vbos[i] = vbo;
+    glBindBuffer(bufferView.target, vbo);
+
+    std::cout << "buffer.data.size = " << buffer.data.size()
+              << ", bufferview.byteOffset = " << bufferView.byteOffset
+              << std::endl;
+
+    glBufferData(bufferView.target, bufferView.byteLength,
+                 &buffer.data.at(0) + bufferView.byteOffset, GL_STATIC_DRAW);
+  }
+
+  for (size_t i = 0; i < mesh.primitives.size(); ++i) {
+    tinygltf::Primitive primitive = mesh.primitives[i];
+    tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
+
+    for (auto &attrib : primitive.attributes) {
+      tinygltf::Accessor accessor = model.accessors[attrib.second];
+      int byteStride =
+          accessor.ByteStride(model.bufferViews[accessor.bufferView]);
+      glBindBuffer(GL_ARRAY_BUFFER, vbos[accessor.bufferView]);
+
+      int size = 1;
+      if (accessor.type != TINYGLTF_TYPE_SCALAR) {
+        size = accessor.type;
+      }
+
+      int vaa = -1;
+      if (attrib.first.compare("POSITION") == 0) vaa = 0;
+      if (attrib.first.compare("NORMAL") == 0) vaa = 1;
+      if (attrib.first.compare("TEXCOORD_0") == 0) vaa = 2;
+      if (vaa > -1) {
+        glEnableVertexAttribArray(vaa);
+        glVertexAttribPointer(vaa, size, accessor.componentType,
+                              accessor.normalized ? GL_TRUE : GL_FALSE,
+                              byteStride, BUFFER_OFFSET(accessor.byteOffset));
+      } else
+        std::cout << "vaa missing: " << attrib.first << std::endl;
+    }
+
+    GLuint texid;
+    glGenTextures(1, &texid);
+
+    tinygltf::Texture &tex = model.textures[0];
+    tinygltf::Image &image = model.images[tex.source];
+
+    glBindTexture(GL_TEXTURE_2D, texid);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+    GLenum format = GL_RGBA;
+
+    if (image.component == 1) {
+      format = GL_RED;
+    } else if (image.component == 2) {
+      format = GL_RG;
+    } else if (image.component == 3) {
+      format = GL_RGB;
+    } else {
+      // ???
+    }
+
+    GLenum type = GL_UNSIGNED_BYTE;
+    if (image.bits == 8) {
+      // ok
+    } else if (image.bits == 16) {
+      type = GL_UNSIGNED_SHORT;
+    } else {
+      // ???
+    }
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
+                 format, type, &image.image.at(0));
+  }
+
+  return vbos;
+}
+
+// bind models
+void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model,
+                    tinygltf::Node &node) {
+  bindMesh(vbos, model, model.meshes[node.mesh]);
+  for (size_t i = 0; i < node.children.size(); i++) {
+    bindModelNodes(vbos, model, model.nodes[node.children[i]]);
+  }
+}
+GLuint bindModel(tinygltf::Model &model) {
+  std::map<int, GLuint> vbos;
+  GLuint vao;
+  glGenVertexArrays(1, &vao);
+  glBindVertexArray(vao);
+
+  const tinygltf::Scene &scene = model.scenes[model.defaultScene];
+  for (size_t i = 0; i < scene.nodes.size(); ++i) {
+    bindModelNodes(vbos, model, model.nodes[scene.nodes[i]]);
+  }
+
+  glBindVertexArray(0);
+  // cleanup vbos
+  for (size_t i = 0; i < vbos.size(); ++i) {
+    glDeleteBuffers(1, &vbos[i]);
+  }
+
+  return vao;
+}
+
+void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
+  for (size_t i = 0; i < mesh.primitives.size(); ++i) {
+    tinygltf::Primitive primitive = mesh.primitives[i];
+    tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
+
+    glDrawElements(primitive.mode, indexAccessor.count,
+                   indexAccessor.componentType,
+                   BUFFER_OFFSET(indexAccessor.byteOffset));
+  }
+}
+
+// recursively draw node and children nodes of model
+void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) {
+  drawMesh(model, model.meshes[node.mesh]);
+  for (size_t i = 0; i < node.children.size(); i++) {
+    drawModelNodes(model, model.nodes[node.children[i]]);
+  }
+}
+void drawModel(GLuint vao, tinygltf::Model &model) {
+  glBindVertexArray(vao);
+
+  const tinygltf::Scene &scene = model.scenes[model.defaultScene];
+  for (size_t i = 0; i < scene.nodes.size(); ++i) {
+    drawModelNodes(model, model.nodes[scene.nodes[i]]);
+  }
+
+  glBindVertexArray(0);
+}
+
+void dbgModel(tinygltf::Model &model) {
+  for (auto &mesh : model.meshes) {
+    std::cout << "mesh : " << mesh.name << std::endl;
+    for (auto &primitive : mesh.primitives) {
+      const tinygltf::Accessor &indexAccessor =
+          model.accessors[primitive.indices];
+
+      std::cout << "indexaccessor: count " << indexAccessor.count << ", type "
+                << indexAccessor.componentType << std::endl;
+
+      tinygltf::Material &mat = model.materials[primitive.material];
+      for (auto &mats : mat.values) {
+        std::cout << "mat : " << mats.first.c_str() << std::endl;
+      }
+
+      for (auto &image : model.images) {
+        std::cout << "image name : " << image.uri << std::endl;
+        std::cout << "  size : " << image.image.size() << std::endl;
+        std::cout << "  w/h : " << image.width << "/" << image.height
+                  << std::endl;
+      }
+
+      std::cout << "indices : " << primitive.indices << std::endl;
+      std::cout << "mode     : "
+                << "(" << primitive.mode << ")" << std::endl;
+
+      for (auto &attrib : primitive.attributes) {
+        std::cout << "attribute : " << attrib.first.c_str() << std::endl;
+      }
+    }
+  }
+}
+
+glm::mat4 genView(glm::vec3 pos, glm::vec3 lookat) {
+  // Camera matrix
+  glm::mat4 view = glm::lookAt(
+      pos,                // Camera in World Space
+      lookat,             // and looks at the origin
+      glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
+  );
+
+  return view;
+}
+
+glm::mat4 genMVP(glm::mat4 view_mat, glm::mat4 model_mat, float fov, int w,
+                 int h) {
+  glm::mat4 Projection =
+      glm::perspective(glm::radians(fov), (float)w / (float)h, 0.01f, 1000.0f);
+
+  // Or, for an ortho camera :
+  // glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f);
+  // // In world coordinates
+
+  glm::mat4 mvp = Projection * view_mat * model_mat;
+
+  return mvp;
+}
+
+void displayLoop(Window &window, const std::string &filename) {
+  Shaders shader = Shaders();
+  glUseProgram(shader.pid);
+
+  // grab uniforms to modify
+  GLuint MVP_u = glGetUniformLocation(shader.pid, "MVP");
+  GLuint sun_position_u = glGetUniformLocation(shader.pid, "sun_position");
+  GLuint sun_color_u = glGetUniformLocation(shader.pid, "sun_color");
+
+  tinygltf::Model model;
+  if (!loadModel(model, filename.c_str())) return;
+
+  GLuint vao = bindModel(model);
+  // dbgModel(model); return;
+
+  // Model matrix : an identity matrix (model will be at the origin)
+  glm::mat4 model_mat = glm::mat4(1.0f);
+  glm::mat4 model_rot = glm::mat4(1.0f);
+  glm::vec3 model_pos = glm::vec3(-3, 0, -3);
+
+  // generate a camera view, based on eye-position and lookAt world-position
+  glm::mat4 view_mat = genView(glm::vec3(2, 2, 20), model_pos);
+
+  glm::vec3 sun_position = glm::vec3(3.0, 10.0, -5.0);
+  glm::vec3 sun_color = glm::vec3(1.0);
+
+  while (!window.Close()) {
+    window.Resize();
+
+    glClearColor(0.2, 0.2, 0.2, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    glm::mat4 trans =
+        glm::translate(glm::mat4(1.0f), model_pos);  // reposition model
+    model_rot = glm::rotate(model_rot, glm::radians(0.8f),
+                            glm::vec3(0, 1, 0));  // rotate model on y axis
+    model_mat = trans * model_rot;
+
+    // build a model-view-projection
+    GLint w, h;
+    glfwGetWindowSize(window.window, &w, &h);
+    glm::mat4 mvp = genMVP(view_mat, model_mat, 45.0f, w, h);
+    glUniformMatrix4fv(MVP_u, 1, GL_FALSE, &mvp[0][0]);
+
+    glUniform3fv(sun_position_u, 1, &sun_position[0]);
+    glUniform3fv(sun_color_u, 1, &sun_color[0]);
+
+    drawModel(vao, model);
+    glfwSwapBuffers(window.window);
+    glfwPollEvents();
+  }
+}
+
+static void error_callback(int error, const char *description) {
+  (void)error;
+  fprintf(stderr, "Error: %s\n", description);
+}
+
+int main(int argc, char **argv) {
+  std::string filename = "../../models/Cube/Cube.gltf";
+
+  if (argc > 1) {
+    filename = argv[1];
+  }
+
+  glfwSetErrorCallback(error_callback);
+
+  if (!glfwInit()) return -1;
+
+  // Force create OpenGL 3.3
+  // NOTE(syoyo): Linux + NVIDIA driver segfaults for some reason? commenting out glfwWindowHint will work.
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+#endif
+
+  Window window = Window(800, 600, "TinyGLTF basic example");
+  glfwMakeContextCurrent(window.window);
+
+#ifdef __APPLE__
+  // https://stackoverflow.com/questions/50192625/openggl-segmentation-fault
+  glewExperimental = GL_TRUE;
+#endif
+
+  glewInit();
+  std::cout << glGetString(GL_RENDERER) << ", " << glGetString(GL_VERSION)
+            << std::endl;
+
+  if (!GLEW_VERSION_3_3) {
+    std::cerr << "OpenGL 3.3 is required to execute this app." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LESS);
+
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glEnable(GL_BLEND);
+
+  displayLoop(window, filename);
+
+  glfwTerminate();
+  return 0;
+}

loader_example.cc

@@ -2,6 +2,7 @@
 // TODO(syoyo): Print extensions and extras for each glTF object.
 //
 #define TINYGLTF_IMPLEMENTATION
+#define TINYGLTF_ENABLE_SCHEMA_VALIDATOR
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "tiny_gltf.h"
@@ -640,8 +641,13 @@ int main(int argc, char **argv) {
   } else {
     std::cout << "Reading ASCII glTF" << std::endl;
     // assume ascii glTF.
+#if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR)
+    ret =
+        gltf_ctx.LoadASCIIFromFileWithValidation(&model, &err, &warn, input_filename.c_str());
+#else
     ret =
         gltf_ctx.LoadASCIIFromFile(&model, &err, &warn, input_filename.c_str());
+#endif
   }
 
   if (!warn.empty()) {

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"
-  }
-}

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"
-  }
-}

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"
-  }
-}

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"
-  }
-}

models/Cube-KTX/Cube.gltf

@@ -1,193 +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.000000,
-            1.000000,
-            1.000001
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 2,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC3"
-      },
-      {
-         "bufferView" : 3,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            -0.000000,
-            -0.000000,
-            1.000000
-         ],
-         "min" : [
-            0.000000,
-            -0.000000,
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC4"
-      },
-      {
-         "bufferView" : 4,
-         "byteOffset" : 0,
-         "componentType" : 5126,
-         "count" : 36,
-         "max" : [
-            1.000000,
-            1.000000
-         ],
-         "min" : [
-            -1.000000,
-            -1.000000
-         ],
-         "type" : "VEC2"
-      }
-   ],
-   "asset" : {
-      "generator" : "VKTS glTF 2.0 exporter",
-      "version" : "2.0"
-   },
-   "bufferViews" : [
-      {
-         "buffer" : 0,
-         "byteLength" : 72,
-         "byteOffset" : 0,
-         "target" : 34963
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 72,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 432,
-         "byteOffset" : 504,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 576,
-         "byteOffset" : 936,
-         "target" : 34962
-      },
-      {
-         "buffer" : 0,
-         "byteLength" : 288,
-         "byteOffset" : 1512,
-         "target" : 34962
-      }
-   ],
-   "buffers" : [
-      {
-         "byteLength" : 1800,
-         "uri" : "Cube.bin"
-      }
-   ],
-   "images" : [
-      {
-         "uri" : "Cube_BaseColor.ktx"
-      },
-      {
-         "uri" : "Cube_MetallicRoughness.ktx"
-      }
-   ],
-   "materials" : [
-      {
-         "name" : "Cube",
-         "pbrMetallicRoughness" : {
-            "baseColorTexture" : {
-               "index" : 0
-            },
-            "metallicRoughnessTexture" : {
-               "index" : 1
-            }
-         }
-      }
-   ],
-   "meshes" : [
-      {
-         "name" : "Cube",
-         "primitives" : [
-            {
-               "attributes" : {
-                  "NORMAL" : 2,
-                  "POSITION" : 1,
-                  "TANGENT" : 3,
-                  "TEXCOORD_0" : 4
-               },
-               "indices" : 0,
-               "material" : 0,
-               "mode" : 4
-            }
-         ]
-      }
-   ],
-   "nodes" : [
-      {
-         "mesh" : 0,
-         "name" : "Cube"
-      }
-   ],
-   "samplers" : [
-      {}
-   ],
-   "scene" : 0,
-   "scenes" : [
-      {
-         "nodes" : [
-            0
-         ]
-      }
-   ],
-   "textures" : [
-      {
-         "sampler" : 0,
-         "source" : 0
-      },
-      {
-         "sampler" : 0,
-         "source" : 1
-      }
-   ]
-}

models/Cube-KTX/README.md

@@ -1,12 +0,0 @@
-License: Donated by Norbert Nopper for glTF testing.
-
-https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/2.0/Cube
-
-
-----
-
-Converted .png to .ktx image by Syoyo Fujita.
-
-.png -> .ppm using image magic(resize with 25% to reduce file size)
-.ppm -> .ktx using `toktx` in KTX-Software https://github.com/KhronosGroup/KTX-Software
-

tests/tester.cc

@@ -37,7 +37,7 @@ TEST_CASE("datauri-in-glb", "[issue-79]") {
   if (!err.empty()) {
     std::cerr << err << std::endl;
   }
-
+    
   REQUIRE(true == ret);
 }
 
@@ -82,200 +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, {{"zero", 0}}, "zero",
-                                         true));
-    REQUIRE(err == "");
-    REQUIRE(result == 0);
-
-    CHECK(tinygltf::ParseIntegerProperty(&result, &err, {{"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, {}, "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, {}, "int", false));
-    REQUIRE(err == "");
-    REQUIRE(result == -1);
-  }
-
-  SECTION("invalid integers") {
-    std::string err;
-    int result = -1;
-
-    CHECK_FALSE(tinygltf::ParseIntegerProperty(&result, &err, {{"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, {{"int", 1e300}},
-                                               "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not an integer type"));
-
-    err.clear();
-    CHECK_FALSE(tinygltf::ParseIntegerProperty(
-        &result, &err, {{"int", std::numeric_limits<double>::quiet_NaN()}},
-        "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.
-    json zero_obj = json::parse("{\"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, {{"int", -1234}},
-                                                "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-
-    err.clear();
-    CHECK_FALSE(tinygltf::ParseUnsignedProperty(&result, &err, {{"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, {{"int", 1e300}},
-                                                "int", true));
-    REQUIRE_THAT(err, Catch::Contains("not a positive integer"));
-
-    err.clear();
-    CHECK_FALSE(tinygltf::ParseUnsignedProperty(
-        &result, &err, {{"int", std::numeric_limits<double>::quiet_NaN()}},
-        "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,
-                                              {{"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, {{"x", {-1, 1e300, 3}}}, "x", true));
-    REQUIRE_THAT(err, Catch::Contains("not an integer type"));
-  }
-}

tools/schema_ref_resolver/README.md

@@ -0,0 +1,20 @@
+Create single schema string by deferencing $ref in glTF schema JSON for embedding JSON scheme string in C++.
+
+## Setup
+
+Use python2
+
+```
+$ pip2 install jsonpath-rw
+$ pip2 install simplejson
+```
+
+Put `ref_resolver.py` and `generate_single_schema_doc.py` to glTF schema direcotry(i.e. `$glTF/specification/2.0/schema`)
+
+## Generate
+
+Run `generate_single_schema_doc.py`
+
+## TODO
+
+* [ ] Print date and git commit id?

tools/schema_ref_resolver/generate_single_schema_doc.py

@@ -0,0 +1,37 @@
+# for print with `end` parameter
+from __future__ import print_function
+
+import json
+from ref_resolver import RefResolver
+import base64
+
+f = open("glTF.schema.json")
+j = json.loads(f.read())
+
+# call to API resolve method
+RefResolver("glTF.schema.json").resolve(j)
+
+j_str = json.dumps(j, indent=2)
+
+
+# Run json.dumps twice to get escaped string
+escaped_str = json.dumps(j_str)
+
+# MSVC does not accept string larger than 16K.
+# https://docs.microsoft.com/en-us/cpp/error-messages/compiler-errors-1/compiler-error-c2026?view=vs-2019
+# Also, it has a hard limit of 65,535 bytes even splitting a string with double quotation.
+# So, we write string as an array of string(then application must concatenate it)
+
+# https://stackoverflow.com/questions/9475241/split-string-every-nth-character
+n = 8000 # Conservative number
+
+splitted_string = [escaped_str[i:i+n] for i in range(0, len(escaped_str), n)]
+#print(len(splitted_string))
+
+print("const char *kglTFSchemaStrings[] = {", end='')
+for (i, s) in enumerate(splitted_string):
+    print(s, end='')
+    if i != (len(splitted_string) - 1):
+        print('",\n"', end='')
+
+print("};")

tools/schema_ref_resolver/ref_resolver.py

@@ -0,0 +1,82 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from urlparse import urlparse, urljoin
+import simplejson as json
+from os.path import isfile
+import jsonpath_rw
+import requests
+
+
+cache = {}
+
+class RefResolver:
+
+    def __init__(self):
+        self.url_fragments = None
+
+    def __init__(self, id):
+        self.id = id
+        if id is not None:
+            self.url_fragments = urlparse(id)
+        else:
+            self.url_fragments = None
+
+
+
+    def resolve(self, json_obj):
+        if isinstance(json_obj, dict):
+            for key, value in json_obj.items():
+                if key == "$ref":
+                    ref_frag = urlparse(value)
+                    ref_file = ref_frag.netloc + ref_frag.path
+                    json_dump = {}
+                    if ref_file in cache:
+                        json_dump = cache[ref_file]
+                    else:
+                        if self.url_fragments.scheme in ['http', 'https']:
+                            ref_url = urljoin(self.id, ref_file)
+                            if callable(requests.Response.json):
+                                json_dump = requests.get(ref_url).json()
+                            else:
+                                json_dump = requests.get(ref_url).json
+                            ref_id = None
+                            if 'tilte' in json_dump:
+                                ref_id = json_dump['title']
+                            cache[ref_file] = json_dump
+                            RefResolver(ref_id).resolve(json_dump)
+                            cache[ref_file] = json_dump
+                        #elif self.url_fragments.scheme == 'file':
+                        else:
+                            if isfile(ref_file):
+                                # if the ref is another file -> go there and get it
+                                json_dump = json.load(open(ref_file))
+                                ref_id = None
+                                if 'title' in json_dump:
+                                    ref_id = json_dump['title']
+                                cache[ref_file] = json_dump
+                                RefResolver(ref_id).resolve(json_dump)
+                                cache[ref_file] = json_dump
+                            else:
+                                # if the ref is in the same file grab it from the same file
+                                json_dump = json.load(open(self.url_fragments.netloc+self.url_fragments.path))
+                                cache[ref_file] = json_dump
+
+                    ref_path_expr = "$" + ".".join(ref_frag.fragment.split("/"))
+                    path_expression = jsonpath_rw.parse(ref_path_expr)
+                    list_of_values = [match.value for match in path_expression.find(json_dump)]
+
+                    if len(list_of_values) > 0:
+                        resolution = list_of_values[0]
+                        return resolution
+
+                resolved = self.resolve(value)
+                if resolved is not None:
+                    json_obj[key] = resolved
+        elif isinstance(json_obj, list):
+            for (key, value) in enumerate(json_obj):
+                resolved = self.resolve(value)
+                if resolved is not None:
+                    json_obj[key] = resolved
+        return None