| // |
| // Header-only tiny glTF 2.0 loader and serializer. |
| // |
| // |
| // The MIT License (MIT) |
| // |
| // Copyright (c) 2015 - 2019 Syoyo Fujita, Aurélien Chatelain and many |
| // contributors. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| // Version: |
| // - v2.3.0 Switch to use RapidJson. |
| // - v2.2.0 Add loading 16bit PNG support. Add Sparse accessor support(Thanks |
| // to @Ybalrid) |
| // - v2.1.0 Add draco compression. |
| // - v2.0.1 Add comparsion feature(Thanks to @Selmar). |
| // - v2.0.0 glTF 2.0!. |
| // |
| // Tiny glTF loader is using following third party libraries: |
| // |
| // - rapidjson-amalgamation.h: C++ JSON library. |
| // - base64: base64 decode/encode library. |
| // - stb_image: Image loading library. |
| // |
| #ifndef TINY_GLTF_H_ |
| #define TINY_GLTF_H_ |
| |
| #include <array> |
| #include <cassert> |
| #include <cstddef> |
| #include <cstdint> |
| #include <cstdlib> |
| #include <cstring> |
| #include <map> |
| #include <string> |
| #include <vector> |
| |
| #ifdef __ANDROID__ |
| #ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS |
| #include <android/asset_manager.h> |
| #endif |
| #endif |
| |
| namespace tinygltf { |
| |
| #define TINYGLTF_MODE_POINTS (0) |
| #define TINYGLTF_MODE_LINE (1) |
| #define TINYGLTF_MODE_LINE_LOOP (2) |
| #define TINYGLTF_MODE_LINE_STRIP (3) |
| #define TINYGLTF_MODE_TRIANGLES (4) |
| #define TINYGLTF_MODE_TRIANGLE_STRIP (5) |
| #define TINYGLTF_MODE_TRIANGLE_FAN (6) |
| |
| #define TINYGLTF_COMPONENT_TYPE_BYTE (5120) |
| #define TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE (5121) |
| #define TINYGLTF_COMPONENT_TYPE_SHORT (5122) |
| #define TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT (5123) |
| #define TINYGLTF_COMPONENT_TYPE_INT (5124) |
| #define TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT (5125) |
| #define TINYGLTF_COMPONENT_TYPE_FLOAT (5126) |
| #define TINYGLTF_COMPONENT_TYPE_DOUBLE (5130) |
| |
| #define TINYGLTF_TEXTURE_FILTER_NEAREST (9728) |
| #define TINYGLTF_TEXTURE_FILTER_LINEAR (9729) |
| #define TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST (9984) |
| #define TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST (9985) |
| #define TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR (9986) |
| #define TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR (9987) |
| |
| #define TINYGLTF_TEXTURE_WRAP_REPEAT (10497) |
| #define TINYGLTF_TEXTURE_WRAP_CLAMP_TO_EDGE (33071) |
| #define TINYGLTF_TEXTURE_WRAP_MIRRORED_REPEAT (33648) |
| |
| // Redeclarations of the above for technique.parameters. |
| #define TINYGLTF_PARAMETER_TYPE_BYTE (5120) |
| #define TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE (5121) |
| #define TINYGLTF_PARAMETER_TYPE_SHORT (5122) |
| #define TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT (5123) |
| #define TINYGLTF_PARAMETER_TYPE_INT (5124) |
| #define TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT (5125) |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT (5126) |
| |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC2 (35664) |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC3 (35665) |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC4 (35666) |
| |
| #define TINYGLTF_PARAMETER_TYPE_INT_VEC2 (35667) |
| #define TINYGLTF_PARAMETER_TYPE_INT_VEC3 (35668) |
| #define TINYGLTF_PARAMETER_TYPE_INT_VEC4 (35669) |
| |
| #define TINYGLTF_PARAMETER_TYPE_BOOL (35670) |
| #define TINYGLTF_PARAMETER_TYPE_BOOL_VEC2 (35671) |
| #define TINYGLTF_PARAMETER_TYPE_BOOL_VEC3 (35672) |
| #define TINYGLTF_PARAMETER_TYPE_BOOL_VEC4 (35673) |
| |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT2 (35674) |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT3 (35675) |
| #define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT4 (35676) |
| |
| #define TINYGLTF_PARAMETER_TYPE_SAMPLER_2D (35678) |
| |
| // End parameter types |
| |
| #define TINYGLTF_TYPE_VEC2 (2) |
| #define TINYGLTF_TYPE_VEC3 (3) |
| #define TINYGLTF_TYPE_VEC4 (4) |
| #define TINYGLTF_TYPE_MAT2 (32 + 2) |
| #define TINYGLTF_TYPE_MAT3 (32 + 3) |
| #define TINYGLTF_TYPE_MAT4 (32 + 4) |
| #define TINYGLTF_TYPE_SCALAR (64 + 1) |
| #define TINYGLTF_TYPE_VECTOR (64 + 4) |
| #define TINYGLTF_TYPE_MATRIX (64 + 16) |
| |
| #define TINYGLTF_IMAGE_FORMAT_JPEG (0) |
| #define TINYGLTF_IMAGE_FORMAT_PNG (1) |
| #define TINYGLTF_IMAGE_FORMAT_BMP (2) |
| #define TINYGLTF_IMAGE_FORMAT_GIF (3) |
| |
| #define TINYGLTF_TEXTURE_FORMAT_ALPHA (6406) |
| #define TINYGLTF_TEXTURE_FORMAT_RGB (6407) |
| #define TINYGLTF_TEXTURE_FORMAT_RGBA (6408) |
| #define TINYGLTF_TEXTURE_FORMAT_LUMINANCE (6409) |
| #define TINYGLTF_TEXTURE_FORMAT_LUMINANCE_ALPHA (6410) |
| |
| #define TINYGLTF_TEXTURE_TARGET_TEXTURE2D (3553) |
| #define TINYGLTF_TEXTURE_TYPE_UNSIGNED_BYTE (5121) |
| |
| #define TINYGLTF_TARGET_ARRAY_BUFFER (34962) |
| #define TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER (34963) |
| |
| #define TINYGLTF_SHADER_TYPE_VERTEX_SHADER (35633) |
| #define TINYGLTF_SHADER_TYPE_FRAGMENT_SHADER (35632) |
| |
| #define TINYGLTF_DOUBLE_EPS (1.e-12) |
| #define TINYGLTF_DOUBLE_EQUAL(a, b) (std::fabs((b) - (a)) < TINYGLTF_DOUBLE_EPS) |
| |
| #ifdef __ANDROID__ |
| #ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS |
| AAssetManager *asset_manager = nullptr; |
| #endif |
| #endif |
| |
| typedef enum { |
| NULL_TYPE = 0, |
| NUMBER_TYPE = 1, |
| INT_TYPE = 2, |
| BOOL_TYPE = 3, |
| STRING_TYPE = 4, |
| ARRAY_TYPE = 5, |
| BINARY_TYPE = 6, |
| OBJECT_TYPE = 7 |
| } Type; |
| |
| static inline int32_t GetComponentSizeInBytes(uint32_t componentType) { |
| if (componentType == TINYGLTF_COMPONENT_TYPE_BYTE) { |
| return 1; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { |
| return 1; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_SHORT) { |
| return 2; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { |
| return 2; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_INT) { |
| return 4; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { |
| return 4; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_FLOAT) { |
| return 4; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_DOUBLE) { |
| return 8; |
| } else { |
| // Unknown componenty type |
| return -1; |
| } |
| } |
| |
| static inline int32_t GetTypeSizeInBytes(uint32_t ty) { |
| if (ty == TINYGLTF_TYPE_SCALAR) { |
| return 1; |
| } else if (ty == TINYGLTF_TYPE_VEC2) { |
| return 2; |
| } else if (ty == TINYGLTF_TYPE_VEC3) { |
| return 3; |
| } else if (ty == TINYGLTF_TYPE_VEC4) { |
| return 4; |
| } else if (ty == TINYGLTF_TYPE_MAT2) { |
| return 4; |
| } else if (ty == TINYGLTF_TYPE_MAT3) { |
| return 9; |
| } else if (ty == TINYGLTF_TYPE_MAT4) { |
| return 16; |
| } else { |
| // Unknown componenty type |
| return -1; |
| } |
| } |
| |
| bool IsDataURI(const std::string &in); |
| bool DecodeDataURI(std::vector<unsigned char> *out, std::string &mime_type, |
| const std::string &in, size_t reqBytes, bool checkSize); |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| // Suppress warning for : static Value null_value |
| // https://stackoverflow.com/questions/15708411/how-to-deal-with-global-constructor-warning-in-clang |
| #pragma clang diagnostic ignored "-Wexit-time-destructors" |
| #pragma clang diagnostic ignored "-Wpadded" |
| #endif |
| |
| // Simple class to represent JSON object |
| class Value { |
| public: |
| typedef std::vector<Value> Array; |
| typedef std::map<std::string, Value> Object; |
| |
| Value() : type_(NULL_TYPE) {} |
| |
| explicit Value(bool b) : type_(BOOL_TYPE) { boolean_value_ = b; } |
| explicit Value(int i) : type_(INT_TYPE) { int_value_ = i; } |
| explicit Value(double n) : type_(NUMBER_TYPE) { number_value_ = n; } |
| explicit Value(const std::string &s) : type_(STRING_TYPE) { |
| string_value_ = s; |
| } |
| explicit Value(const unsigned char *p, size_t n) : type_(BINARY_TYPE) { |
| binary_value_.resize(n); |
| memcpy(binary_value_.data(), p, n); |
| } |
| explicit Value(const Array &a) : type_(ARRAY_TYPE) { |
| array_value_ = Array(a); |
| } |
| explicit Value(const Object &o) : type_(OBJECT_TYPE) { |
| object_value_ = Object(o); |
| } |
| |
| char Type() const { return static_cast<const char>(type_); } |
| |
| bool IsBool() const { return (type_ == BOOL_TYPE); } |
| |
| bool IsInt() const { return (type_ == INT_TYPE); } |
| |
| bool IsNumber() const { return (type_ == NUMBER_TYPE); } |
| |
| bool IsString() const { return (type_ == STRING_TYPE); } |
| |
| bool IsBinary() const { return (type_ == BINARY_TYPE); } |
| |
| bool IsArray() const { return (type_ == ARRAY_TYPE); } |
| |
| bool IsObject() const { return (type_ == OBJECT_TYPE); } |
| |
| // Accessor |
| template <typename T> |
| const T &Get() const; |
| template <typename T> |
| T &Get(); |
| |
| // Lookup value from an array |
| const Value &Get(int idx) const { |
| static Value null_value; |
| assert(IsArray()); |
| assert(idx >= 0); |
| return (static_cast<size_t>(idx) < array_value_.size()) |
| ? array_value_[static_cast<size_t>(idx)] |
| : null_value; |
| } |
| |
| // Lookup value from a key-value pair |
| const Value &Get(const std::string &key) const { |
| static Value null_value; |
| assert(IsObject()); |
| Object::const_iterator it = object_value_.find(key); |
| return (it != object_value_.end()) ? it->second : null_value; |
| } |
| |
| size_t ArrayLen() const { |
| if (!IsArray()) return 0; |
| return array_value_.size(); |
| } |
| |
| // Valid only for object type. |
| bool Has(const std::string &key) const { |
| if (!IsObject()) return false; |
| Object::const_iterator it = object_value_.find(key); |
| return (it != object_value_.end()) ? true : false; |
| } |
| |
| // List keys |
| std::vector<std::string> Keys() const { |
| std::vector<std::string> keys; |
| if (!IsObject()) return keys; // empty |
| |
| for (Object::const_iterator it = object_value_.begin(); |
| it != object_value_.end(); ++it) { |
| keys.push_back(it->first); |
| } |
| |
| return keys; |
| } |
| |
| size_t Size() const { return (IsArray() ? ArrayLen() : Keys().size()); } |
| |
| bool operator==(const tinygltf::Value &other) const; |
| |
| protected: |
| int type_; |
| |
| int int_value_; |
| double number_value_; |
| std::string string_value_; |
| std::vector<unsigned char> binary_value_; |
| Array array_value_; |
| Object object_value_; |
| bool boolean_value_; |
| }; |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic pop |
| #endif |
| |
| #define TINYGLTF_VALUE_GET(ctype, var) \ |
| template <> \ |
| inline const ctype &Value::Get<ctype>() const { \ |
| return var; \ |
| } \ |
| template <> \ |
| inline ctype &Value::Get<ctype>() { \ |
| return var; \ |
| } |
| TINYGLTF_VALUE_GET(bool, boolean_value_) |
| TINYGLTF_VALUE_GET(double, number_value_) |
| TINYGLTF_VALUE_GET(int, int_value_) |
| TINYGLTF_VALUE_GET(std::string, string_value_) |
| TINYGLTF_VALUE_GET(std::vector<unsigned char>, binary_value_) |
| TINYGLTF_VALUE_GET(Value::Array, array_value_) |
| TINYGLTF_VALUE_GET(Value::Object, object_value_) |
| #undef TINYGLTF_VALUE_GET |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wc++98-compat" |
| #pragma clang diagnostic ignored "-Wpadded" |
| #endif |
| |
| /// Agregate object for representing a color |
| using ColorValue = std::array<double, 4>; |
| |
| struct Parameter { |
| bool bool_value = false; |
| bool has_number_value = false; |
| std::string string_value; |
| std::vector<double> number_array; |
| std::map<std::string, double> json_double_value; |
| double number_value = 0.0; |
| // context sensitive methods. depending the type of the Parameter you are |
| // accessing, these are either valid or not |
| // If this parameter represent a texture map in a material, will return the |
| // texture index |
| |
| /// Return the index of a texture if this Parameter is a texture map. |
| /// Returned value is only valid if the parameter represent a texture from a |
| /// material |
| int TextureIndex() const { |
| const auto it = json_double_value.find("index"); |
| if (it != std::end(json_double_value)) { |
| return int(it->second); |
| } |
| return -1; |
| } |
| |
| /// Return the index of a texture coordinate set if this Parameter is a |
| /// texture map. Returned value is only valid if the parameter represent a |
| /// texture from a material |
| int TextureTexCoord() const { |
| const auto it = json_double_value.find("texCoord"); |
| if (it != std::end(json_double_value)) { |
| return int(it->second); |
| } |
| return 0; |
| } |
| |
| /// Material factor, like the roughness or metalness of a material |
| /// Returned value is only valid if the parameter represent a texture from a |
| /// material |
| double Factor() const { return number_value; } |
| |
| /// Return the color of a material |
| /// Returned value is only valid if the parameter represent a texture from a |
| /// material |
| ColorValue ColorFactor() const { |
| return { |
| {// this agregate intialize the std::array object, and uses C++11 RVO. |
| number_array[0], number_array[1], number_array[2], |
| (number_array.size() > 3 ? number_array[3] : 1.0)}}; |
| } |
| |
| bool operator==(const Parameter &) const; |
| }; |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic pop |
| #endif |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wpadded" |
| #endif |
| |
| typedef std::map<std::string, Parameter> ParameterMap; |
| typedef std::map<std::string, Value> ExtensionMap; |
| |
| struct AnimationChannel { |
| int sampler; // required |
| int target_node; // required (index of the node to target) |
| std::string target_path; // required in ["translation", "rotation", "scale", |
| // "weights"] |
| Value extras; |
| |
| AnimationChannel() : sampler(-1), target_node(-1) {} |
| bool operator==(const AnimationChannel &) const; |
| }; |
| |
| struct AnimationSampler { |
| int input; // required |
| int output; // required |
| std::string interpolation; // in ["LINEAR", "STEP", "CATMULLROMSPLINE", |
| // "CUBICSPLINE"], default "LINEAR" |
| Value extras; |
| |
| AnimationSampler() : input(-1), output(-1), interpolation("LINEAR") {} |
| bool operator==(const AnimationSampler &) const; |
| }; |
| |
| struct Animation { |
| std::string name; |
| std::vector<AnimationChannel> channels; |
| std::vector<AnimationSampler> samplers; |
| Value extras; |
| |
| bool operator==(const Animation &) const; |
| }; |
| |
| struct Skin { |
| std::string name; |
| int inverseBindMatrices; // required here but not in the spec |
| int skeleton; // The index of the node used as a skeleton root |
| std::vector<int> joints; // Indices of skeleton nodes |
| |
| Skin() { |
| inverseBindMatrices = -1; |
| skeleton = -1; |
| } |
| bool operator==(const Skin &) const; |
| }; |
| |
| struct Sampler { |
| std::string name; |
| int minFilter; // ["NEAREST", "LINEAR", "NEAREST_MIPMAP_LINEAR", |
| // "LINEAR_MIPMAP_NEAREST", "NEAREST_MIPMAP_LINEAR", |
| // "LINEAR_MIPMAP_LINEAR"] |
| int magFilter; // ["NEAREST", "LINEAR"] |
| int wrapS; // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT", "REPEAT"], default |
| // "REPEAT" |
| int wrapT; // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT", "REPEAT"], default |
| // "REPEAT" |
| int wrapR; // TinyGLTF extension |
| Value extras; |
| |
| Sampler() |
| : minFilter(TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR), |
| magFilter(TINYGLTF_TEXTURE_FILTER_LINEAR), |
| wrapS(TINYGLTF_TEXTURE_WRAP_REPEAT), |
| wrapT(TINYGLTF_TEXTURE_WRAP_REPEAT), |
| wrapR(TINYGLTF_TEXTURE_WRAP_REPEAT) {} |
| bool operator==(const Sampler &) const; |
| }; |
| |
| struct Image { |
| std::string name; |
| int width; |
| int height; |
| int component; |
| int bits; // bit depth per channel. 8(byte), 16 or 32. |
| int pixel_type; // pixel type(TINYGLTF_COMPONENT_TYPE_***). usually |
| // UBYTE(bits = 8) or USHORT(bits = 16) |
| std::vector<unsigned char> image; |
| int bufferView; // (required if no uri) |
| std::string mimeType; // (required if no uri) ["image/jpeg", "image/png", |
| // "image/bmp", "image/gif"] |
| std::string uri; // (required if no mimeType) |
| Value extras; |
| ExtensionMap extensions; |
| |
| // When this flag is true, data is stored to `image` in as-is format(e.g. jpeg |
| // compressed for "image/jpeg" mime) This feature is good if you use custom |
| // image loader function. (e.g. delayed decoding of images for faster glTF |
| // parsing) Default parser for Image does not provide as-is loading feature at |
| // the moment. (You can manipulate this by providing your own LoadImageData |
| // function) |
| bool as_is; |
| |
| Image() : as_is(false) { |
| bufferView = -1; |
| width = -1; |
| height = -1; |
| component = -1; |
| } |
| bool operator==(const Image &) const; |
| }; |
| |
| struct Texture { |
| std::string name; |
| |
| int sampler; |
| int source; |
| Value extras; |
| ExtensionMap extensions; |
| |
| Texture() : sampler(-1), source(-1) {} |
| bool operator==(const Texture &) const; |
| }; |
| |
| // Each extension should be stored in a ParameterMap. |
| // members not in the values could be included in the ParameterMap |
| // to keep a single material model |
| struct Material { |
| std::string name; |
| |
| ParameterMap values; // PBR metal/roughness workflow |
| ParameterMap additionalValues; // normal/occlusion/emissive values |
| |
| ExtensionMap extensions; |
| Value extras; |
| |
| bool operator==(const Material &) const; |
| }; |
| |
| struct BufferView { |
| std::string name; |
| int buffer; // Required |
| size_t byteOffset; // minimum 0, default 0 |
| size_t byteLength; // required, minimum 1 |
| size_t byteStride; // minimum 4, maximum 252 (multiple of 4), default 0 = |
| // understood to be tightly packed |
| int target; // ["ARRAY_BUFFER", "ELEMENT_ARRAY_BUFFER"] |
| Value extras; |
| bool dracoDecoded; // Flag indicating this has been draco decoded |
| |
| BufferView() : byteOffset(0), byteStride(0), dracoDecoded(false) {} |
| bool operator==(const BufferView &) const; |
| }; |
| |
| struct Accessor { |
| int bufferView; // optional in spec but required here since sparse accessor |
| // are not supported |
| std::string name; |
| size_t byteOffset; |
| bool normalized; // optional. |
| int componentType; // (required) One of TINYGLTF_COMPONENT_TYPE_*** |
| size_t count; // required |
| int type; // (required) One of TINYGLTF_TYPE_*** .. |
| Value extras; |
| |
| std::vector<double> minValues; // optional |
| std::vector<double> maxValues; // optional |
| |
| struct { |
| int count; |
| bool isSparse; |
| struct { |
| int byteOffset; |
| int bufferView; |
| int componentType; // a TINYGLTF_COMPONENT_TYPE_ value |
| } indices; |
| struct { |
| int bufferView; |
| int byteOffset; |
| } values; |
| } sparse; |
| |
| /// |
| /// Utility function to compute byteStride for a given bufferView object. |
| /// Returns -1 upon invalid glTF value or parameter configuration. |
| /// |
| int ByteStride(const BufferView &bufferViewObject) const { |
| if (bufferViewObject.byteStride == 0) { |
| // Assume data is tightly packed. |
| int componentSizeInBytes = |
| GetComponentSizeInBytes(static_cast<uint32_t>(componentType)); |
| if (componentSizeInBytes <= 0) { |
| return -1; |
| } |
| |
| int typeSizeInBytes = GetTypeSizeInBytes(static_cast<uint32_t>(type)); |
| if (typeSizeInBytes <= 0) { |
| return -1; |
| } |
| |
| return componentSizeInBytes * typeSizeInBytes; |
| } else { |
| // Check if byteStride is a mulple of the size of the accessor's component |
| // type. |
| int componentSizeInBytes = |
| GetComponentSizeInBytes(static_cast<uint32_t>(componentType)); |
| if (componentSizeInBytes <= 0) { |
| return -1; |
| } |
| |
| if ((bufferViewObject.byteStride % uint32_t(componentSizeInBytes)) != 0) { |
| return -1; |
| } |
| return static_cast<int>(bufferViewObject.byteStride); |
| } |
| |
| return 0; |
| } |
| |
| Accessor() { |
| bufferView = -1; |
| sparse.isSparse = false; |
| } |
| bool operator==(const tinygltf::Accessor &) const; |
| }; |
| |
| struct PerspectiveCamera { |
| double aspectRatio; // min > 0 |
| double yfov; // required. min > 0 |
| double zfar; // min > 0 |
| double znear; // required. min > 0 |
| |
| PerspectiveCamera() |
| : aspectRatio(0.0), |
| yfov(0.0), |
| zfar(0.0) // 0 = use infinite projecton matrix |
| , |
| znear(0.0) {} |
| bool operator==(const PerspectiveCamera &) const; |
| |
| ExtensionMap extensions; |
| Value extras; |
| }; |
| |
| struct OrthographicCamera { |
| double xmag; // required. must not be zero. |
| double ymag; // required. must not be zero. |
| double zfar; // required. `zfar` must be greater than `znear`. |
| double znear; // required |
| |
| OrthographicCamera() : xmag(0.0), ymag(0.0), zfar(0.0), znear(0.0) {} |
| bool operator==(const OrthographicCamera &) const; |
| |
| ExtensionMap extensions; |
| Value extras; |
| }; |
| |
| struct Camera { |
| std::string type; // required. "perspective" or "orthographic" |
| std::string name; |
| |
| PerspectiveCamera perspective; |
| OrthographicCamera orthographic; |
| |
| Camera() {} |
| bool operator==(const Camera &) const; |
| |
| ExtensionMap extensions; |
| Value extras; |
| }; |
| |
| struct Primitive { |
| std::map<std::string, int> attributes; // (required) A dictionary object of |
| // integer, where each integer |
| // is the index of the accessor |
| // containing an attribute. |
| int material; // The index of the material to apply to this primitive |
| // when rendering. |
| int indices; // The index of the accessor that contains the indices. |
| int mode; // one of TINYGLTF_MODE_*** |
| std::vector<std::map<std::string, int> > targets; // array of morph targets, |
| // where each target is a dict with attribues in ["POSITION, "NORMAL", |
| // "TANGENT"] pointing |
| // to their corresponding accessors |
| ExtensionMap extensions; |
| Value extras; |
| |
| Primitive() { |
| material = -1; |
| indices = -1; |
| } |
| bool operator==(const Primitive &) const; |
| }; |
| |
| struct Mesh { |
| std::string name; |
| std::vector<Primitive> primitives; |
| std::vector<double> weights; // weights to be applied to the Morph Targets |
| std::vector<std::map<std::string, int> > targets; |
| ExtensionMap extensions; |
| Value extras; |
| |
| bool operator==(const Mesh &) const; |
| }; |
| |
| class Node { |
| public: |
| Node() : camera(-1), skin(-1), mesh(-1) {} |
| |
| Node(const Node &rhs) { |
| camera = rhs.camera; |
| |
| name = rhs.name; |
| skin = rhs.skin; |
| mesh = rhs.mesh; |
| children = rhs.children; |
| rotation = rhs.rotation; |
| scale = rhs.scale; |
| translation = rhs.translation; |
| matrix = rhs.matrix; |
| weights = rhs.weights; |
| |
| extensions = rhs.extensions; |
| extras = rhs.extras; |
| } |
| ~Node() {} |
| bool operator==(const Node &) const; |
| |
| int camera; // the index of the camera referenced by this node |
| |
| std::string name; |
| int skin; |
| int mesh; |
| std::vector<int> children; |
| std::vector<double> rotation; // length must be 0 or 4 |
| std::vector<double> scale; // length must be 0 or 3 |
| std::vector<double> translation; // length must be 0 or 3 |
| std::vector<double> matrix; // length must be 0 or 16 |
| std::vector<double> weights; // The weights of the instantiated Morph Target |
| |
| ExtensionMap extensions; |
| Value extras; |
| }; |
| |
| struct Buffer { |
| std::string name; |
| std::vector<unsigned char> data; |
| std::string |
| uri; // considered as required here but not in the spec (need to clarify) |
| Value extras; |
| |
| bool operator==(const Buffer &) const; |
| }; |
| |
| struct Asset { |
| std::string version; // required |
| std::string generator; |
| std::string minVersion; |
| std::string copyright; |
| ExtensionMap extensions; |
| Value extras; |
| |
| bool operator==(const Asset &) const; |
| }; |
| |
| struct Scene { |
| std::string name; |
| std::vector<int> nodes; |
| |
| ExtensionMap extensions; |
| Value extras; |
| |
| bool operator==(const Scene &) const; |
| }; |
| |
| struct Light { |
| std::string name; |
| std::vector<double> color; |
| std::string type; |
| |
| bool operator==(const Light &) const; |
| }; |
| |
| class Model { |
| public: |
| Model() {} |
| ~Model() {} |
| bool operator==(const Model &) const; |
| |
| std::vector<Accessor> accessors; |
| std::vector<Animation> animations; |
| std::vector<Buffer> buffers; |
| std::vector<BufferView> bufferViews; |
| std::vector<Material> materials; |
| std::vector<Mesh> meshes; |
| std::vector<Node> nodes; |
| std::vector<Texture> textures; |
| std::vector<Image> images; |
| std::vector<Skin> skins; |
| std::vector<Sampler> samplers; |
| std::vector<Camera> cameras; |
| std::vector<Scene> scenes; |
| std::vector<Light> lights; |
| ExtensionMap extensions; |
| |
| int defaultScene; |
| std::vector<std::string> extensionsUsed; |
| std::vector<std::string> extensionsRequired; |
| |
| Asset asset; |
| |
| Value extras; |
| }; |
| |
| enum SectionCheck { |
| NO_REQUIRE = 0x00, |
| REQUIRE_SCENE = 0x01, |
| REQUIRE_SCENES = 0x02, |
| REQUIRE_NODES = 0x04, |
| REQUIRE_ACCESSORS = 0x08, |
| REQUIRE_BUFFERS = 0x10, |
| REQUIRE_BUFFER_VIEWS = 0x20, |
| REQUIRE_ALL = 0x3f |
| }; |
| |
| /// |
| /// LoadImageDataFunction type. Signature for custom image loading callbacks. |
| /// |
| typedef bool (*LoadImageDataFunction)(Image *, const int, std::string *, |
| std::string *, int, int, |
| const unsigned char *, int, void *); |
| |
| /// |
| /// WriteImageDataFunction type. Signature for custom image writing callbacks. |
| /// |
| typedef bool (*WriteImageDataFunction)(const std::string *, const std::string *, |
| Image *, bool, void *); |
| |
| #ifndef TINYGLTF_NO_STB_IMAGE |
| // Declaration of default image loader callback |
| bool LoadImageData(Image *image, const int image_idx, std::string *err, |
| std::string *warn, int req_width, int req_height, |
| const unsigned char *bytes, int size, void *); |
| #endif |
| |
| #ifndef TINYGLTF_NO_STB_IMAGE_WRITE |
| // Declaration of default image writer callback |
| bool WriteImageData(const std::string *basepath, const std::string *filename, |
| Image *image, bool embedImages, void *); |
| #endif |
| |
| /// |
| /// FilExistsFunction type. Signature for custom filesystem callbacks. |
| /// |
| typedef bool (*FileExistsFunction)(const std::string &abs_filename, void *); |
| |
| /// |
| /// ExpandFilePathFunction type. Signature for custom filesystem callbacks. |
| /// |
| typedef std::string (*ExpandFilePathFunction)(const std::string &, void *); |
| |
| /// |
| /// ReadWholeFileFunction type. Signature for custom filesystem callbacks. |
| /// |
| typedef bool (*ReadWholeFileFunction)(std::vector<unsigned char> *, |
| std::string *, const std::string &, |
| void *); |
| |
| /// |
| /// WriteWholeFileFunction type. Signature for custom filesystem callbacks. |
| /// |
| typedef bool (*WriteWholeFileFunction)(std::string *, const std::string &, |
| const std::vector<unsigned char> &, |
| void *); |
| |
| /// |
| /// A structure containing all required filesystem callbacks and a pointer to |
| /// their user data. |
| /// |
| struct FsCallbacks { |
| FileExistsFunction FileExists; |
| ExpandFilePathFunction ExpandFilePath; |
| ReadWholeFileFunction ReadWholeFile; |
| WriteWholeFileFunction WriteWholeFile; |
| |
| void *user_data; // An argument that is passed to all fs callbacks |
| }; |
| |
| #ifndef TINYGLTF_NO_FS |
| // Declaration of default filesystem callbacks |
| |
| bool FileExists(const std::string &abs_filename, void *); |
| |
| std::string ExpandFilePath(const std::string &filepath, void *); |
| |
| bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err, |
| const std::string &filepath, void *); |
| |
| bool WriteWholeFile(std::string *err, const std::string &filepath, |
| const std::vector<unsigned char> &contents, void *); |
| #endif |
| |
| class TinyGLTF { |
| public: |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wc++98-compat" |
| #endif |
| |
| TinyGLTF(); |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic pop |
| #endif |
| |
| ~TinyGLTF(); |
| |
| /// |
| /// Loads glTF ASCII asset from a file. |
| /// Set warning message to `warn` for example it fails to load asserts. |
| /// Returns false and set error string to `err` if there's an error. |
| /// |
| bool LoadASCIIFromFile(Model *model, std::string *err, std::string *warn, |
| const std::string &filename, |
| unsigned int check_sections = REQUIRE_ALL); |
| |
| /// |
| /// Loads glTF ASCII asset from string(memory). |
| /// `length` = strlen(str); |
| /// Set warning message to `warn` for example it fails to load asserts. |
| /// Returns false and set error string to `err` if there's an error. |
| /// |
| bool LoadASCIIFromString(Model *model, std::string *err, std::string *warn, |
| const char *str, const unsigned int length, |
| const std::string &base_dir, |
| unsigned int check_sections = REQUIRE_ALL); |
| |
| #if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR) |
| |
| bool LoadASCIIFromFileWithValidation( |
| Model *model, std::string *err, std::string *warn, |
| const std::string &filename, unsigned int check_sections = REQUIRE_ALL); |
| |
| bool LoadASCIIFromStringWithValidation( |
| Model *model, std::string *err, std::string *warn, const char *str, |
| const unsigned int length, const std::string &base_dir, |
| unsigned int check_sections = REQUIRE_ALL); |
| |
| #endif |
| |
| /// |
| /// Loads glTF binary asset from a file. |
| /// Set warning message to `warn` for example it fails to load asserts. |
| /// Returns false and set error string to `err` if there's an error. |
| /// |
| bool LoadBinaryFromFile(Model *model, std::string *err, std::string *warn, |
| const std::string &filename, |
| unsigned int check_sections = REQUIRE_ALL); |
| |
| /// |
| /// Loads glTF binary asset from memory. |
| /// `length` = strlen(str); |
| /// Set warning message to `warn` for example it fails to load asserts. |
| /// Returns false and set error string to `err` if there's an error. |
| /// |
| bool LoadBinaryFromMemory(Model *model, std::string *err, std::string *warn, |
| const unsigned char *bytes, |
| const unsigned int length, |
| const std::string &base_dir = "", |
| unsigned int check_sections = REQUIRE_ALL); |
| |
| /// |
| /// Write glTF to file. |
| /// |
| bool WriteGltfSceneToFile(Model *model, const std::string &filename, |
| bool embedImages, bool embedBuffers, |
| bool prettyPrint, bool writeBinary); |
| |
| /// |
| /// Set callback to use for loading image data |
| /// |
| void SetImageLoader(LoadImageDataFunction LoadImageData, void *user_data); |
| |
| /// |
| /// Set callback to use for writing image data |
| /// |
| void SetImageWriter(WriteImageDataFunction WriteImageData, void *user_data); |
| |
| /// |
| /// Set callbacks to use for filesystem (fs) access and their user data |
| /// |
| void SetFsCallbacks(FsCallbacks callbacks); |
| |
| private: |
| /// |
| /// Loads glTF asset from string(memory). |
| /// `length` = strlen(str); |
| /// Set warning message to `warn` for example it fails to load asserts |
| /// Returns false and set error string to `err` if there's an error. |
| /// |
| bool LoadFromString(Model *model, std::string *err, std::string *warn, |
| const char *str, const unsigned int length, |
| const std::string &base_dir, unsigned int check_sections); |
| |
| const unsigned char *bin_data_; |
| size_t bin_size_; |
| bool is_binary_; |
| |
| FsCallbacks fs = { |
| #ifndef TINYGLTF_NO_FS |
| &tinygltf::FileExists, &tinygltf::ExpandFilePath, |
| &tinygltf::ReadWholeFile, &tinygltf::WriteWholeFile, |
| |
| nullptr // Fs callback user data |
| #else |
| nullptr, nullptr, nullptr, nullptr, |
| |
| nullptr // Fs callback user data |
| #endif |
| }; |
| |
| LoadImageDataFunction LoadImageData = |
| #ifndef TINYGLTF_NO_STB_IMAGE |
| &tinygltf::LoadImageData; |
| #else |
| nullptr; |
| #endif |
| void *load_image_user_data_ = reinterpret_cast<void *>(&fs); |
| |
| WriteImageDataFunction WriteImageData = |
| #ifndef TINYGLTF_NO_STB_IMAGE_WRITE |
| &tinygltf::WriteImageData; |
| #else |
| nullptr; |
| #endif |
| void *write_image_user_data_ = reinterpret_cast<void *>(&fs); |
| |
| class PImpl; |
| PImpl *pimpl_; |
| }; |
| |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic pop // -Wpadded |
| #endif |
| |
| } // namespace tinygltf |
| |
| #endif // TINY_GLTF_H_ |
| |
| #if defined(TINYGLTF_IMPLEMENTATION) || defined(__INTELLISENSE__) |
| #include <algorithm> |
| //#include <cassert> |
| #ifndef TINYGLTF_NO_FS |
| #include <fstream> |
| #endif |
| #include <sstream> |
| |
| #ifdef __clang__ |
| // Disable some warnings for external files. |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wfloat-equal" |
| #pragma clang diagnostic ignored "-Wexit-time-destructors" |
| #pragma clang diagnostic ignored "-Wconversion" |
| #pragma clang diagnostic ignored "-Wold-style-cast" |
| #pragma clang diagnostic ignored "-Wglobal-constructors" |
| #pragma clang diagnostic ignored "-Wreserved-id-macro" |
| #pragma clang diagnostic ignored "-Wdisabled-macro-expansion" |
| #pragma clang diagnostic ignored "-Wpadded" |
| #pragma clang diagnostic ignored "-Wc++98-compat" |
| #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" |
| #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" |
| #pragma clang diagnostic ignored "-Wswitch-enum" |
| #pragma clang diagnostic ignored "-Wimplicit-fallthrough" |
| #pragma clang diagnostic ignored "-Wweak-vtables" |
| #pragma clang diagnostic ignored "-Wcovered-switch-default" |
| #if __has_warning("-Wdouble-promotion") |
| #pragma clang diagnostic ignored "-Wdouble-promotion" |
| #endif |
| #if __has_warning("-Wcomma") |
| #pragma clang diagnostic ignored "-Wcomma" |
| #endif |
| #if __has_warning("-Wzero-as-null-pointer-constant") |
| #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" |
| #endif |
| #if __has_warning("-Wcast-qual") |
| #pragma clang diagnostic ignored "-Wcast-qual" |
| #endif |
| #if __has_warning("-Wmissing-variable-declarations") |
| #pragma clang diagnostic ignored "-Wmissing-variable-declarations" |
| #endif |
| #if __has_warning("-Wmissing-prototypes") |
| #pragma clang diagnostic ignored "-Wmissing-prototypes" |
| #endif |
| #if __has_warning("-Wcast-align") |
| #pragma clang diagnostic ignored "-Wcast-align" |
| #endif |
| #if __has_warning("-Wnewline-eof") |
| #pragma clang diagnostic ignored "-Wnewline-eof" |
| #endif |
| #if __has_warning("-Wunused-parameter") |
| #pragma clang diagnostic ignored "-Wunused-parameter" |
| #endif |
| #if __has_warning("-Wmismatched-tags") |
| #pragma clang diagnostic ignored "-Wmismatched-tags" |
| #endif |
| #endif |
| |
| // Disable GCC warnigs |
| #ifdef __GNUC__ |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wtype-limits" |
| #endif // __GNUC__ |
| |
| #ifndef TINYGLTF_NO_INCLUDE_RAPIDJSON |
| #include "rapidjson-amalgamation.h" |
| #endif |
| |
| #ifdef TINYGLTF_ENABLE_DRACO |
| #include "draco/compression/decode.h" |
| #include "draco/core/decoder_buffer.h" |
| #endif |
| |
| #ifndef TINYGLTF_NO_STB_IMAGE |
| #ifndef TINYGLTF_NO_INCLUDE_STB_IMAGE |
| #include "stb_image.h" |
| #endif |
| #endif |
| |
| #ifndef TINYGLTF_NO_STB_IMAGE_WRITE |
| #ifndef TINYGLTF_NO_INCLUDE_STB_IMAGE_WRITE |
| #include "stb_image_write.h" |
| #endif |
| #endif |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic pop |
| #endif |
| |
| #ifdef __GNUC__ |
| #pragma GCC diagnostic pop |
| #endif |
| |
| #ifdef _WIN32 |
| |
| // issue 143. |
| // Define NOMINMAX to avoid min/max defines, |
| // but undef it after included windows.h |
| #ifndef NOMINMAX |
| #define TINYGLTF_INTERNAL_NOMINMAX |
| #define NOMINMAX |
| #endif |
| |
| #ifndef WIN32_LEAN_AND_MEAN |
| #define WIN32_LEAN_AND_MEAN |
| #define TINYGLTF_INTERNAL_WIN32_LEAN_AND_MEAN |
| #endif |
| #include <windows.h> // include API for expanding a file path |
| |
| #ifdef TINYGLTF_INTERNAL_WIN32_LEAN_AND_MEAN |
| #undef WIN32_LEAN_AND_MEAN |
| #endif |
| |
| #if defined(TINYGLTF_INTERNAL_NOMINMAX) |
| #undef NOMINMAX |
| #endif |
| |
| #elif !defined(__ANDROID__) |
| #include <wordexp.h> |
| #endif |
| |
| #if defined(__sparcv9) |
| // Big endian |
| #else |
| #if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU |
| #define TINYGLTF_LITTLE_ENDIAN 1 |
| #endif |
| #endif |
| |
| #ifdef __APPLE__ |
| #include "TargetConditionals.h" |
| #endif |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wc++98-compat" |
| #endif |
| |
| namespace tinygltf { |
| |
| #if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR) |
| // Include glTF Schema as embedded C string |
| #include "gltf.schema.resolved.inc" |
| #endif |
| |
| // Equals function for Value, for recursivity |
| static bool Equals(const tinygltf::Value &one, const tinygltf::Value &other) { |
| if (one.Type() != other.Type()) return false; |
| |
| switch (one.Type()) { |
| case NULL_TYPE: |
| return true; |
| case BOOL_TYPE: |
| return one.Get<bool>() == other.Get<bool>(); |
| case NUMBER_TYPE: |
| return TINYGLTF_DOUBLE_EQUAL(one.Get<double>(), other.Get<double>()); |
| case INT_TYPE: |
| return one.Get<int>() == other.Get<int>(); |
| case OBJECT_TYPE: { |
| auto oneObj = one.Get<tinygltf::Value::Object>(); |
| auto otherObj = other.Get<tinygltf::Value::Object>(); |
| if (oneObj.size() != otherObj.size()) return false; |
| for (auto &it : oneObj) { |
| auto otherIt = otherObj.find(it.first); |
| if (otherIt == otherObj.end()) return false; |
| |
| if (!Equals(it.second, otherIt->second)) return false; |
| } |
| return true; |
| } |
| case ARRAY_TYPE: { |
| if (one.Size() != other.Size()) return false; |
| for (int i = 0; i < int(one.Size()); ++i) |
| if (Equals(one.Get(i), other.Get(i))) return false; |
| return true; |
| } |
| case STRING_TYPE: |
| return one.Get<std::string>() == other.Get<std::string>(); |
| case BINARY_TYPE: |
| return one.Get<std::vector<unsigned char> >() == |
| other.Get<std::vector<unsigned char> >(); |
| default: { |
| // unhandled type |
| return false; |
| } |
| } |
| } |
| |
| // Equals function for std::vector<double> using TINYGLTF_DOUBLE_EPSILON |
| static bool Equals(const std::vector<double> &one, |
| const std::vector<double> &other) { |
| if (one.size() != other.size()) return false; |
| for (int i = 0; i < int(one.size()); ++i) { |
| if (!TINYGLTF_DOUBLE_EQUAL(one[size_t(i)], other[size_t(i)])) return false; |
| } |
| return true; |
| } |
| |
| bool Accessor::operator==(const Accessor &other) const { |
| return this->bufferView == other.bufferView && |
| this->byteOffset == other.byteOffset && |
| this->componentType == other.componentType && |
| this->count == other.count && this->extras == other.extras && |
| Equals(this->maxValues, other.maxValues) && |
| Equals(this->minValues, other.minValues) && this->name == other.name && |
| this->normalized == other.normalized && this->type == other.type; |
| } |
| bool Animation::operator==(const Animation &other) const { |
| return this->channels == other.channels && this->extras == other.extras && |
| this->name == other.name && this->samplers == other.samplers; |
| } |
| bool AnimationChannel::operator==(const AnimationChannel &other) const { |
| return this->extras == other.extras && |
| this->target_node == other.target_node && |
| this->target_path == other.target_path && |
| this->sampler == other.sampler; |
| } |
| bool AnimationSampler::operator==(const AnimationSampler &other) const { |
| return this->extras == other.extras && this->input == other.input && |
| this->interpolation == other.interpolation && |
| this->output == other.output; |
| } |
| bool Asset::operator==(const Asset &other) const { |
| return this->copyright == other.copyright && |
| this->extensions == other.extensions && this->extras == other.extras && |
| this->generator == other.generator && |
| this->minVersion == other.minVersion && this->version == other.version; |
| } |
| bool Buffer::operator==(const Buffer &other) const { |
| return this->data == other.data && this->extras == other.extras && |
| this->name == other.name && this->uri == other.uri; |
| } |
| bool BufferView::operator==(const BufferView &other) const { |
| return this->buffer == other.buffer && this->byteLength == other.byteLength && |
| this->byteOffset == other.byteOffset && |
| this->byteStride == other.byteStride && this->name == other.name && |
| this->target == other.target && this->extras == other.extras && |
| this->dracoDecoded == other.dracoDecoded; |
| } |
| bool Camera::operator==(const Camera &other) const { |
| return this->name == other.name && this->extensions == other.extensions && |
| this->extras == other.extras && |
| this->orthographic == other.orthographic && |
| this->perspective == other.perspective && this->type == other.type; |
| } |
| bool Image::operator==(const Image &other) const { |
| return this->bufferView == other.bufferView && |
| this->component == other.component && this->extras == other.extras && |
| this->height == other.height && this->image == other.image && |
| this->mimeType == other.mimeType && this->name == other.name && |
| this->uri == other.uri && this->width == other.width; |
| } |
| bool Light::operator==(const Light &other) const { |
| return Equals(this->color, other.color) && this->name == other.name && |
| this->type == other.type; |
| } |
| bool Material::operator==(const Material &other) const { |
| return this->additionalValues == other.additionalValues && |
| this->extensions == other.extensions && this->extras == other.extras && |
| this->name == other.name && this->values == other.values; |
| } |
| bool Mesh::operator==(const Mesh &other) const { |
| return this->extensions == other.extensions && this->extras == other.extras && |
| this->name == other.name && this->primitives == other.primitives && |
| this->targets == other.targets && Equals(this->weights, other.weights); |
| } |
| bool Model::operator==(const Model &other) const { |
| return this->accessors == other.accessors && |
| this->animations == other.animations && this->asset == other.asset && |
| this->buffers == other.buffers && |
| this->bufferViews == other.bufferViews && |
| this->cameras == other.cameras && |
| this->defaultScene == other.defaultScene && |
| this->extensions == other.extensions && |
| this->extensionsRequired == other.extensionsRequired && |
| this->extensionsUsed == other.extensionsUsed && |
| this->extras == other.extras && this->images == other.images && |
| this->lights == other.lights && this->materials == other.materials && |
| this->meshes == other.meshes && this->nodes == other.nodes && |
| this->samplers == other.samplers && this->scenes == other.scenes && |
| this->skins == other.skins && this->textures == other.textures; |
| } |
| bool Node::operator==(const Node &other) const { |
| return this->camera == other.camera && this->children == other.children && |
| this->extensions == other.extensions && this->extras == other.extras && |
| Equals(this->matrix, other.matrix) && this->mesh == other.mesh && |
| this->name == other.name && Equals(this->rotation, other.rotation) && |
| Equals(this->scale, other.scale) && this->skin == other.skin && |
| Equals(this->translation, other.translation) && |
| Equals(this->weights, other.weights); |
| } |
| bool OrthographicCamera::operator==(const OrthographicCamera &other) const { |
| return this->extensions == other.extensions && this->extras == other.extras && |
| TINYGLTF_DOUBLE_EQUAL(this->xmag, other.xmag) && |
| TINYGLTF_DOUBLE_EQUAL(this->ymag, other.ymag) && |
| TINYGLTF_DOUBLE_EQUAL(this->zfar, other.zfar) && |
| TINYGLTF_DOUBLE_EQUAL(this->znear, other.znear); |
| } |
| bool Parameter::operator==(const Parameter &other) const { |
| if (this->bool_value != other.bool_value || |
| this->has_number_value != other.has_number_value) |
| return false; |
| |
| if (!TINYGLTF_DOUBLE_EQUAL(this->number_value, other.number_value)) |
| return false; |
| |
| if (this->json_double_value.size() != other.json_double_value.size()) |
| return false; |
| for (auto &it : this->json_double_value) { |
| auto otherIt = other.json_double_value.find(it.first); |
| if (otherIt == other.json_double_value.end()) return false; |
| |
| if (!TINYGLTF_DOUBLE_EQUAL(it.second, otherIt->second)) return false; |
| } |
| |
| if (!Equals(this->number_array, other.number_array)) return false; |
| |
| if (this->string_value != other.string_value) return false; |
| |
| return true; |
| } |
| bool PerspectiveCamera::operator==(const PerspectiveCamera &other) const { |
| return TINYGLTF_DOUBLE_EQUAL(this->aspectRatio, other.aspectRatio) && |
| this->extensions == other.extensions && this->extras == other.extras && |
| TINYGLTF_DOUBLE_EQUAL(this->yfov, other.yfov) && |
| TINYGLTF_DOUBLE_EQUAL(this->zfar, other.zfar) && |
| TINYGLTF_DOUBLE_EQUAL(this->znear, other.znear); |
| } |
| bool Primitive::operator==(const Primitive &other) const { |
| return this->attributes == other.attributes && this->extras == other.extras && |
| this->indices == other.indices && this->material == other.material && |
| this->mode == other.mode && this->targets == other.targets; |
| } |
| bool Sampler::operator==(const Sampler &other) const { |
| return this->extras == other.extras && this->magFilter == other.magFilter && |
| this->minFilter == other.minFilter && this->name == other.name && |
| this->wrapR == other.wrapR && this->wrapS == other.wrapS && |
| this->wrapT == other.wrapT; |
| } |
| bool Scene::operator==(const Scene &other) const { |
| return this->extensions == other.extensions && this->extras == other.extras && |
| this->name == other.name && this->nodes == other.nodes; |
| ; |
| } |
| bool Skin::operator==(const Skin &other) const { |
| return this->inverseBindMatrices == other.inverseBindMatrices && |
| this->joints == other.joints && this->name == other.name && |
| this->skeleton == other.skeleton; |
| } |
| bool Texture::operator==(const Texture &other) const { |
| return this->extensions == other.extensions && this->extras == other.extras && |
| this->name == other.name && this->sampler == other.sampler && |
| this->source == other.source; |
| } |
| bool Value::operator==(const Value &other) const { |
| return Equals(*this, other); |
| } |
| |
| static void swap4(unsigned int *val) { |
| #ifdef TINYGLTF_LITTLE_ENDIAN |
| (void)val; |
| #else |
| unsigned int tmp = *val; |
| unsigned char *dst = reinterpret_cast<unsigned char *>(val); |
| unsigned char *src = reinterpret_cast<unsigned char *>(&tmp); |
| |
| dst[0] = src[3]; |
| dst[1] = src[2]; |
| dst[2] = src[1]; |
| dst[3] = src[0]; |
| #endif |
| } |
| |
| static std::string JoinPath(const std::string &path0, |
| const std::string &path1) { |
| if (path0.empty()) { |
| return path1; |
| } else { |
| // check '/' |
| char lastChar = *path0.rbegin(); |
| if (lastChar != '/') { |
| return path0 + std::string("/") + path1; |
| } else { |
| return path0 + path1; |
| } |
| } |
| } |
| |
| static std::string FindFile(const std::vector<std::string> &paths, |
| const std::string &filepath, FsCallbacks *fs) { |
| if (fs == nullptr || fs->ExpandFilePath == nullptr || |
| fs->FileExists == nullptr) { |
| // Error, fs callback[s] missing |
| return std::string(); |
| } |
| |
| for (size_t i = 0; i < paths.size(); i++) { |
| std::string absPath = |
| fs->ExpandFilePath(JoinPath(paths[i], filepath), fs->user_data); |
| if (fs->FileExists(absPath, fs->user_data)) { |
| return absPath; |
| } |
| } |
| |
| return std::string(); |
| } |
| |
| static std::string GetFilePathExtension(const std::string &FileName) { |
| if (FileName.find_last_of(".") != std::string::npos) |
| return FileName.substr(FileName.find_last_of(".") + 1); |
| return ""; |
| } |
| |
| static std::string GetBaseDir(const std::string &filepath) { |
| if (filepath.find_last_of("/\\") != std::string::npos) |
| return filepath.substr(0, filepath.find_last_of("/\\")); |
| return ""; |
| } |
| |
| // https://stackoverflow.com/questions/8520560/get-a-file-name-from-a-path |
| static std::string GetBaseFilename(const std::string &filepath) { |
| return filepath.substr(filepath.find_last_of("/\\") + 1); |
| } |
| |
| std::string base64_encode(unsigned char const *, unsigned int len); |
| std::string base64_decode(std::string const &s); |
| |
| /* |
| base64.cpp and base64.h |
| |
| Copyright (C) 2004-2008 René Nyffenegger |
| |
| This source code is provided 'as-is', without any express or implied |
| warranty. In no event will the author be held liable for any damages |
| arising from the use of this software. |
| |
| Permission is granted to anyone to use this software for any purpose, |
| including commercial applications, and to alter it and redistribute it |
| freely, subject to the following restrictions: |
| |
| 1. The origin of this source code must not be misrepresented; you must not |
| claim that you wrote the original source code. If you use this source code |
| in a product, an acknowledgment in the product documentation would be |
| appreciated but is not required. |
| |
| 2. Altered source versions must be plainly marked as such, and must not be |
| misrepresented as being the original source code. |
| |
| 3. This notice may not be removed or altered from any source distribution. |
| |
| René Nyffenegger rene.nyffenegger@adp-gmbh.ch |
| |
| */ |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wexit-time-destructors" |
| #pragma clang diagnostic ignored "-Wglobal-constructors" |
| #pragma clang diagnostic ignored "-Wsign-conversion" |
| #pragma clang diagnostic ignored "-Wconversion" |
| #endif |
| static const std::string base64_chars = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| "abcdefghijklmnopqrstuvwxyz" |
| "0123456789+/"; |
| |
| static inline bool is_base64(unsigned char c) { |
| return (isalnum(c) || (c == '+') || (c == '/')); |
| } |
| |
| std::string base64_encode(unsigned char const *bytes_to_encode, |
| unsigned int in_len) { |
| std::string ret; |
| int i = 0; |
| int j = 0; |
| unsigned char char_array_3[3]; |
| unsigned char char_array_4[4]; |
| |
| while (in_len--) { |
| char_array_3[i++] = *(bytes_to_encode++); |
| if (i == 3) { |
| char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; |
| char_array_4[1] = |
| ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); |
| char_array_4[2] = |
| ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); |
| char_array_4[3] = char_array_3[2] & 0x3f; |
| |
| for (i = 0; (i < 4); i++) ret += base64_chars[char_array_4[i]]; |
| i = 0; |
| } |
| } |
| |
| if (i) { |
| for (j = i; j < 3; j++) char_array_3[j] = '\0'; |
| |
| char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; |
| char_array_4[1] = |
| ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); |
| char_array_4[2] = |
| ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); |
| |
| for (j = 0; (j < i + 1); j++) ret += base64_chars[char_array_4[j]]; |
| |
| while ((i++ < 3)) ret += '='; |
| } |
| |
| return ret; |
| } |
| |
| std::string base64_decode(std::string const &encoded_string) { |
| int in_len = static_cast<int>(encoded_string.size()); |
| int i = 0; |
| int j = 0; |
| int in_ = 0; |
| unsigned char char_array_4[4], char_array_3[3]; |
| std::string ret; |
| |
| while (in_len-- && (encoded_string[in_] != '=') && |
| is_base64(encoded_string[in_])) { |
| char_array_4[i++] = encoded_string[in_]; |
| in_++; |
| if (i == 4) { |
| for (i = 0; i < 4; i++) |
| char_array_4[i] = |
| static_cast<unsigned char>(base64_chars.find(char_array_4[i])); |
| |
| char_array_3[0] = |
| (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); |
| char_array_3[1] = |
| ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); |
| char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; |
| |
| for (i = 0; (i < 3); i++) ret += char_array_3[i]; |
| i = 0; |
| } |
| } |
| |
| if (i) { |
| for (j = i; j < 4; j++) char_array_4[j] = 0; |
| |
| for (j = 0; j < 4; j++) |
| char_array_4[j] = |
| static_cast<unsigned char>(base64_chars.find(char_array_4[j])); |
| |
| char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); |
| char_array_3[1] = |
| ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); |
| char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; |
| |
| for (j = 0; (j < i - 1); j++) ret += char_array_3[j]; |
| } |
| |
| return ret; |
| } |
| #ifdef __clang__ |
| #pragma clang diagnostic pop |
| #endif |
| |
| class TinyGLTF::PImpl |
| { |
| public: |
| |
| PImpl() { |
| #if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR) |
| schema_doc_ = nullptr; |
| schema_ = nullptr; |
| validator_ = nullptr; |
| #endif |
| } |
| |
| ~PImpl() |
| { |
| #if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR) |
| if (schema_doc_) { |
| delete schema_doc_; |
| } |
| |
| if (schema_) { |
| delete schema_; |
| } |
| |
| if (validator_) { |
| delete validator_; |
| } |
| |
| #endif |
| } |
| |
| #if defined(TINYGLTF_ENABLE_SCHEMA_VALIDATOR) |
| |
| std::string schema_json_string_; |
| rapidjson::Document *schema_doc_ = nullptr; |
| rapidjson::SchemaDocument *schema_ = nullptr; |
| rapidjson::SchemaValidator *validator_ = nullptr; |
| #endif |
| }; |
| |
| |
| TinyGLTF::TinyGLTF() : bin_data_(nullptr), bin_size_(0), is_binary_(false) { |
| pimpl_ = new TinyGLTF::PImpl(); |
| } |
| |
| TinyGLTF::~TinyGLTF() |
| { |
| if (pimpl_) { |
| delete pimpl_; |
| } |
| } |
| |
| static bool LoadExternalFile(std::vector<unsigned char> *out, std::string *err, |
| std::string *warn, const std::string &filename, |
| const std::string &basedir, bool required, |
| size_t reqBytes, bool checkSize, FsCallbacks *fs) { |
| if (fs == nullptr || fs->FileExists == nullptr || |
| fs->ExpandFilePath == nullptr || fs->ReadWholeFile == nullptr) { |
| // This is a developer error, assert() ? |
| if (err) { |
| (*err) += "FS callback[s] not set\n"; |
| } |
| return false; |
| } |
| |
| std::string *failMsgOut = required ? err : warn; |
| |
| out->clear(); |
| |
| std::vector<std::string> paths; |
| paths.push_back(basedir); |
| paths.push_back("."); |
| |
| std::string filepath = FindFile(paths, filename, fs); |
| if (filepath.empty() || filename.empty()) { |
| if (failMsgOut) { |
| (*failMsgOut) += "File not found : " + filename + "\n"; |
| } |
| return false; |
| } |
| |
| std::vector<unsigned char> buf; |
| std::string fileReadErr; |
| bool fileRead = |
| fs->ReadWholeFile(&buf, &fileReadErr, filepath, fs->user_data); |
| if (!fileRead) { |
| if (failMsgOut) { |
| (*failMsgOut) += |
| "File read error : " + filepath + " : " + fileReadErr + "\n"; |
| } |
| return false; |
| } |
| |
| size_t sz = buf.size(); |
| if (sz == 0) { |
| if (failMsgOut) { |
| (*failMsgOut) += "File is empty : " + filepath + "\n"; |
| } |
| return false; |
| } |
| |
| if (checkSize) { |
| if (reqBytes == sz) { |
| out->swap(buf); |
| return true; |
| } else { |
| std::stringstream ss; |
| ss << "File size mismatch : " << filepath << ", requestedBytes " |
| << reqBytes << ", but got " << sz << std::endl; |
| if (failMsgOut) { |
| (*failMsgOut) += ss.str(); |
| } |
| return false; |
| } |
| } |
| |
| out->swap(buf); |
| return true; |
| } |
| |
| void TinyGLTF::SetImageLoader(LoadImageDataFunction func, void *user_data) { |
| LoadImageData = func; |
| load_image_user_data_ = user_data; |
| } |
| |
| #ifndef TINYGLTF_NO_STB_IMAGE |
| bool LoadImageData(Image *image, const int image_idx, std::string *err, |
| std::string *warn, int req_width, int req_height, |
| const unsigned char *bytes, int size, void *user_data) { |
| (void)user_data; |
| (void)warn; |
| |
| int w, h, comp, req_comp; |
| |
| unsigned char *data = nullptr; |
| |
| // force 32-bit textures for common Vulkan compatibility. It appears that |
| // some GPU drivers do not support 24-bit images for Vulkan |
| req_comp = 4; |
| int bits = 8; |
| int pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE; |
| |
| // It is possible that the image we want to load is a 16bit per channel image |
| // We are going to attempt to load it as 16bit per channel, and if it worked, |
| // set the image data accodingly. We are casting the returned pointer into |
| // unsigned char, because we are representing "bytes". But we are updating |
| // the Image metadata to signal that this image uses 2 bytes (16bits) per |
| // channel: |
| if (stbi_is_16_bit_from_memory(bytes, size)) { |
| data = (unsigned char *)stbi_load_16_from_memory(bytes, size, &w, &h, &comp, |
| req_comp); |
| if (data) { |
| bits = 16; |
| pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT; |
| } |
| } |
| |
| // at this point, if data is still NULL, it means that the image wasn't |
| // 16bit per channel, we are going to load it as a normal 8bit per channel |
| // mage as we used to do: |
| // if image cannot be decoded, ignore parsing and keep it by its path |
| // don't break in this case |
| // FIXME we should only enter this function if the image is embedded. If |
| // image->uri references |
| // an image file, it should be left as it is. Image loading should not be |
| // mandatory (to support other formats) |
| if (!data) data = stbi_load_from_memory(bytes, size, &w, &h, &comp, req_comp); |
| if (!data) { |
| // NOTE: you can use `warn` instead of `err` |
| if (err) { |
| (*err) += |
| "Unknown image format. STB cannot decode image data for image[" + |
| std::to_string(image_idx) + "] name = \"" + image->name + "\".\n"; |
| } |
| return false; |
| } |
| |
| if (w < 1 || h < 1) { |
| stbi_image_free(data); |
| if (err) { |
| (*err) += "Invalid image data for image[" + std::to_string(image_idx) + |
| "] name = \"" + image->name + "\"\n"; |
| } |
| return false; |
| } |
| |
| if (req_width > 0) { |
| if (req_width != w) { |
| stbi_image_free(data); |
| if (err) { |
| (*err) += "Image width mismatch for image[" + |
| std::to_string(image_idx) + "] name = \"" + image->name + |
| "\"\n"; |
| } |
| return false; |
| } |
| } |
| |
| if (req_height > 0) { |
| if (req_height != h) { |
| stbi_image_free(data); |
| if (err) { |
| (*err) += "Image height mismatch. for image[" + |
| std::to_string(image_idx) + "] name = \"" + image->name + |
| "\"\n"; |
| } |
| return false; |
| } |
| } |
| |
| image->width = w; |
| image->height = h; |
| image->component = req_comp; |
| image->bits = bits; |
| image->pixel_type = pixel_type; |
| image->image.resize(static_cast<size_t>(w * h * req_comp) * (bits / 8)); |
| std::copy(data, data + w * h * req_comp * (bits / 8), image->image.begin()); |
| stbi_image_free(data); |
| |
| return true; |
| } |
| #endif |
| |
| void TinyGLTF::SetImageWriter(WriteImageDataFunction func, void *user_data) { |
| WriteImageData = func; |
| write_image_user_data_ = user_data; |
| } |
| |
| #ifndef TINYGLTF_NO_STB_IMAGE_WRITE |
| static void WriteToMemory_stbi(void *context, void *data, int size) { |
| std::vector<unsigned char> *buffer = |
| reinterpret_cast<std::vector<unsigned char> *>(context); |
| |
| unsigned char *pData = reinterpret_cast<unsigned char *>(data); |
| |
| buffer->insert(buffer->end(), pData, pData + size); |
| } |
| |
| bool WriteImageData(const std::string *basepath, const std::string *filename, |
| Image *image, bool embedImages, void *fsPtr) { |
| const std::string ext = GetFilePathExtension(*filename); |
| |
| // Write image to temporary buffer |
| std::string header; |
| std::vector<unsigned char> data; |
| |
| if (ext == "png") { |
| if ((image->bits != 8) || |
| (image->pixel_type != TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE)) { |
| // Unsupported pixel format |
| return false; |
| } |
| |
| if (!stbi_write_png_to_func(WriteToMemory_stbi, &data, image->width, |
| image->height, image->component, |
| &image->image[0], 0)) { |
| return false; |
| } |
| header = "data:image/png;base64,"; |
| } else if (ext == "jpg") { |
| if (!stbi_write_jpg_to_func(WriteToMemory_stbi, &data, image->width, |
| image->height, image->component, |
| &image->image[0], 100)) { |
| return false; |
| } |
| header = "data:image/jpeg;base64,"; |
| } else if (ext == "bmp") { |
| if (!stbi_write_bmp_to_func(WriteToMemory_stbi, &data, image->width, |
| image->height, image->component, |
| &image->image[0])) { |
| return false; |
| } |
| header = "data:image/bmp;base64,"; |
| } else if (!embedImages) { |
| // Error: can't output requested format to file |
| return false; |
| } |
| |
| if (embedImages) { |
| // Embed base64-encoded image into URI |
| if (data.size()) { |
| image->uri = |
| header + |
| base64_encode(&data[0], static_cast<unsigned int>(data.size())); |
| } else { |
| // Throw error? |
| } |
| } else { |
| // Write image to disc |
| FsCallbacks *fs = reinterpret_cast<FsCallbacks *>(fsPtr); |
| if ((fs != nullptr) && (fs->WriteWholeFile != nullptr)) { |
| const std::string imagefilepath = JoinPath(*basepath, *filename); |
| std::string writeError; |
| if (!fs->WriteWholeFile(&writeError, imagefilepath, data, |
| fs->user_data)) { |
| // Could not write image file to disc; Throw error ? |
| return false; |
| } |
| } else { |
| // Throw error? |
| } |
| image->uri = *filename; |
| } |
| |
| return true; |
| } |
| #endif |
| |
| void TinyGLTF::SetFsCallbacks(FsCallbacks callbacks) { fs = callbacks; } |
| |
| #ifndef TINYGLTF_NO_FS |
| // Default implementations of filesystem functions |
| |
| bool FileExists(const std::string &abs_filename, void *) { |
| bool ret; |
| #ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS |
| if (asset_manager) { |
| AAsset *asset = AAssetManager_open(asset_manager, abs_filename.c_str(), |
| AASSET_MODE_STREAMING); |
| if (!asset) { |
| return false; |
| } |
| AAsset_close(asset); |
| ret = true; |
| } else { |
| return false; |
| } |
| #else |
| #ifdef _WIN32 |
| FILE *fp; |
| errno_t err = fopen_s(&fp, abs_filename.c_str(), "rb"); |
| if (err != 0) { |
| return false; |
| } |
| #else |
| FILE *fp = fopen(abs_filename.c_str(), "rb"); |
| #endif |
| if (fp) { |
| ret = true; |
| fclose(fp); |
| } else { |
| ret = false; |
| } |
| #endif |
| |
| return ret; |
| } |
| |
| std::string ExpandFilePath(const std::string &filepath, void *) { |
| #ifdef _WIN32 |
| DWORD len = ExpandEnvironmentStringsA(filepath.c_str(), NULL, 0); |
| char *str = new char[len]; |
| ExpandEnvironmentStringsA(filepath.c_str(), str, len); |
| |
| std::string s(str); |
| |
| delete[] str; |
| |
| return s; |
| #else |
| |
| #if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) || \ |
| defined(__ANDROID__) || defined(__EMSCRIPTEN__) |
| // no expansion |
| std::string s = filepath; |
| #else |
| std::string s; |
| wordexp_t p; |
| |
| if (filepath.empty()) { |
| return ""; |
| } |
| |
| // char** w; |
| int ret = wordexp(filepath.c_str(), &p, 0); |
| if (ret) { |
| // err |
| s = filepath; |
| return s; |
| } |
| |
| // Use first element only. |
| if (p.we_wordv) { |
| s = std::string(p.we_wordv[0]); |
| wordfree(&p); |
| } else { |
| s = filepath; |
| } |
| |
| #endif |
| |
| return s; |
| #endif |
| } |
| |
| bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err, |
| const std::string &filepath, void *) { |
| #ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS |
| if (asset_manager) { |
| AAsset *asset = AAssetManager_open(asset_manager, filepath.c_str(), |
| AASSET_MODE_STREAMING); |
| if (!asset) { |
| if (err) { |
| (*err) += "File open error : " + filepath + "\n"; |
| } |
| return false; |
| } |
| size_t size = AAsset_getLength(asset); |
| if (size <= 0) { |
| if (err) { |
| (*err) += "Invalid file size : " + filepath + |
| " (does the path point to a directory?)"; |
| } |
| } |
| out->resize(size); |
| AAsset_read(asset, reinterpret_cast<char *>(&out->at(0)), size); |
| AAsset_close(asset); |
| return true; |
| } else { |
| if (err) { |
| (*err) += "No asset manager specified : " + filepath + "\n"; |
| } |
| return false; |
| } |
| #else |
| std::ifstream f(filepath.c_str(), std::ifstream::binary); |
| if (!f) { |
| if (err) { |
| (*err) += "File open error : " + filepath + "\n"; |
| } |
| return false; |
| } |
| |
| f.seekg(0, f.end); |
| size_t sz = static_cast<size_t>(f.tellg()); |
| f.seekg(0, f.beg); |
| |
| if (int(sz) < 0) { |
| if (err) { |
| (*err) += "Invalid file size : " + filepath + |
| " (does the path point to a directory?)"; |
| } |
| return false; |
| } else if (sz == 0) { |
| if (err) { |
| (*err) += "File is empty : " + filepath + "\n"; |
| } |
| return false; |
| } |
| |
| out->resize(sz); |
| f.read(reinterpret_cast<char *>(&out->at(0)), |
| static_cast<std::streamsize>(sz)); |
| f.close(); |
| |
| return true; |
| #endif |
| } |
| |
| bool WriteWholeFile(std::string *err, const std::string &filepath, |
| const std::vector<unsigned char> &contents, void *) { |
| std::ofstream f(filepath.c_str(), std::ofstream::binary); |
| if (!f) { |
| if (err) { |
| (*err) += "File open error for writing : " + filepath + "\n"; |
| } |
| return false; |
| } |
| |
| f.write(reinterpret_cast<const char *>(&contents.at(0)), |
| static_cast<std::streamsize>(contents.size())); |
| if (!f) { |
| if (err) { |
| (*err) += "File write error: " + filepath + "\n"; |
| } |
| return false; |
| } |
| |
| f.close(); |
| return true; |
| } |
| |
| #endif // TINYGLTF_NO_FS |
| |
| static std::string MimeToExt(const std::string &mimeType) { |
| if (mimeType == "image/jpeg") { |
| return "jpg"; |
| } else if (mimeType == "image/png") { |
| return "png"; |
| } else if (mimeType == "image/bmp") { |
| return "bmp"; |
| } else if (mimeType == "image/gif") { |
| return "gif"; |
| } |
| |
| return ""; |
| } |
| |
| static void UpdateImageObject(Image &image, std::string &baseDir, int index, |
| bool embedImages, |
| WriteImageDataFunction *WriteImageData = nullptr, |
| void *user_data = nullptr) { |
| std::string filename; |
| std::string ext; |
| |
| // If image have uri. Use it it as a filename |
| if (image.uri.size()) { |
| filename = GetBaseFilename(image.uri); |
| ext = GetFilePathExtension(filename); |
| |
| } else if (image.name.size()) { |
| ext = MimeToExt(image.mimeType); |
| // Otherwise use name as filename |
| filename = image.name + "." + ext; |
| } else { |
| ext = MimeToExt(image.mimeType); |
| // Fallback to index of image as filename |
| filename = std::to_string(index) + "." + ext; |
| } |
| |
| // If callback is set, modify image data object |
| if (*WriteImageData != nullptr) { |
| std::string uri; |
| (*WriteImageData)(&baseDir, &filename, &image, embedImages, user_data); |
| } |
| } |
| |
| bool IsDataURI(const std::string &in) { |
| std::string header = "data:application/octet-stream;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| header = "data:image/jpeg;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| header = "data:image/png;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| header = "data:image/bmp;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| header = "data:image/gif;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| header = "data:text/plain;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| header = "data:application/gltf-buffer;base64,"; |
| if (in.find(header) == 0) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool DecodeDataURI(std::vector<unsigned char> *out, std::string &mime_type, |
| const std::string &in, size_t reqBytes, bool checkSize) { |
| std::string header = "data:application/octet-stream;base64,"; |
| std::string data; |
| if (in.find(header) == 0) { |
| data = base64_decode(in.substr(header.size())); // cut mime string. |
| } |
| |
| if (data.empty()) { |
| header = "data:image/jpeg;base64,"; |
| if (in.find(header) == 0) { |
| mime_type = "image/jpeg"; |
| data = base64_decode(in.substr(header.size())); // cut mime string. |
| } |
| } |
| |
| if (data.empty()) { |
| header = "data:image/png;base64,"; |
| if (in.find(header) == 0) { |
| mime_type = "image/png"; |
| data = base64_decode(in.substr(header.size())); // cut mime string. |
| } |
| } |
| |
| if (data.empty()) { |
| header = "data:image/bmp;base64,"; |
| if (in.find(header) == 0) { |
| mime_type = "image/bmp"; |
| data = base64_decode(in.substr(header.size())); // cut mime string. |
| } |
| } |
| |
| if (data.empty()) { |
| header = "data:image/gif;base64,"; |
| if (in.find(header) == 0) { |
| mime_type = "image/gif"; |
| data = base64_decode(in.substr(header.size())); // cut mime string. |
| } |
| } |
| |
| if (data.empty()) { |
| header = "data:text/plain;base64,"; |
| if (in.find(header) == 0) { |
| mime_type = "text/plain"; |
| data = base64_decode(in.substr(header.size())); |
| } |
| } |
| |
| if (data.empty()) { |
| header = "data:application/gltf-buffer;base64,"; |
| if (in.find(header) == 0) { |
| data = base64_decode(in.substr(header.size())); |
| } |
| } |
| |
| if (data.empty()) { |
| return false; |
| } |
| |
| if (checkSize) { |
| if (data.size() != reqBytes) { |
| return false; |
| } |
| out->resize(reqBytes); |
| } else { |
| out->resize(data.size()); |
| } |
| std::copy(data.begin(), data.end(), out->begin()); |
| return true; |
| } |
| |
| static bool ParseJsonAsValue(Value *ret, const rapidjson::Value &o) { |
| Value val{}; |
| if (o.IsObject()) { |
| Value::Object value_object; |
| for (auto it = o.MemberBegin(); it != o.MemberEnd(); it++) { |
| Value entry; |
| ParseJsonAsValue(&entry, it->value); |
| if (entry.Type() != NULL_TYPE) value_object[it->name.GetString()] = entry; |
| } |
| |
| if (value_object.size() > 0) { |
| val = Value(value_object); |
| } |
| |
| /* |
| } break; |
| case json::value_t::array: { |
| Value::Array value_array; |
| for (auto it = o.begin(); it != o.MemberEnd(); it++) { |
| Value entry; |
| ParseJsonAsValue(&entry, it.value()); |
| if (entry.Type() != NULL_TYPE) value_array.push_back(entry); |
| } |
| if (value_array.size() > 0) val = Value(value_array); |
| } break; |
| case json::value_t::string: |
| val = Value(o.get<std::string>()); |
| break; |
| case json::value_t::boolean: |
| val = Value(o.get<bool>()); |
| break; |
| case json::value_t::number_integer: |
| case json::value_t::number_unsigned: |
| val = Value(static_cast<int>(o.get<int64_t>())); |
| break; |
| case json::value_t::number_float: |
| val = Value(o.get<double>()); |
| break; |
| case json::value_t::null: |
| case json::value_t::discarded: |
| // default: |
| break; |
| } |
| */ |
| } else if (o.IsNull()) { |
| // Do nothing |
| } else { |
| // ??? |
| } |
| if (ret) *ret = val; |
| |
| return val.Type() != NULL_TYPE; |
| } |
| |
| static bool ParseExtrasProperty(Value *ret, const rapidjson::Value &o) { |
| auto it = o.FindMember("extras"); |
| if (it == o.MemberEnd()) { |
| return false; |
| } |
| |
| return ParseJsonAsValue(ret, it->value); |
| } |
| |
| static bool ParseBooleanProperty(bool *ret, std::string *err, |
| const rapidjson::Value &o, |
| const std::string &property, |
| const bool required, |
| const std::string &parent_node = "") { |
| auto it = o.FindMember(property.c_str()); |
| if (it == o.MemberEnd()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is missing"; |
| if (!parent_node.empty()) { |
| (*err) += " in " + parent_node; |
| } |
| (*err) += ".\n"; |
| } |
| } |
| return false; |
| } |
| |
| if (!it->value.IsBool()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not a bool type.\n"; |
| } |
| } |
| return false; |
| } |
| |
| if (ret) { |
| (*ret) = it->value.GetBool(); |
| } |
| |
| return true; |
| } |
| |
| static bool ParseNumberProperty(double *ret, std::string *err, |
| const rapidjson::Value &o, |
| const std::string &property, |
| const bool required, |
| const std::string &parent_node = "") { |
| auto it = o.FindMember(property.c_str()); |
| if (it == o.MemberEnd()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is missing"; |
| if (!parent_node.empty()) { |
| (*err) += " in " + parent_node; |
| } |
| (*err) += ".\n"; |
| } |
| } |
| return false; |
| } |
| |
| if (!it->value.IsNumber()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not a number type.\n"; |
| } |
| } |
| return false; |
| } |
| |
| if (ret) { |
| (*ret) = it->value.GetDouble(); |
| } |
| |
| return true; |
| } |
| |
| static bool ParseNumberArrayProperty(std::vector<double> *ret, std::string *err, |
| const rapidjson::Value &o, |
| const std::string &property, bool required, |
| const std::string &parent_node = "") { |
| auto it = o.FindMember(property.c_str()); |
| if (it == o.MemberEnd()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is missing"; |
| if (!parent_node.empty()) { |
| (*err) += " in " + parent_node; |
| } |
| (*err) += ".\n"; |
| } |
| } |
| return false; |
| } |
| |
| if (!it->value.IsArray()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not an array"; |
| if (!parent_node.empty()) { |
| (*err) += " in " + parent_node; |
| } |
| (*err) += ".\n"; |
| } |
| } |
| return false; |
| } |
| |
| ret->clear(); |
| for (auto i = it->value.Begin(); i != it->value.End(); i++) { |
| if (!i->IsNumber()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not a number.\n"; |
| if (!parent_node.empty()) { |
| (*err) += " in " + parent_node; |
| } |
| (*err) += ".\n"; |
| } |
| } |
| return false; |
| } |
| ret->push_back(i->GetDouble()); |
| } |
| |
| return true; |
| } |
| |
| static bool ParseStringProperty( |
| std::string *ret, std::string *err, const rapidjson::Value &o, |
| const std::string &property, bool required, |
| const std::string &parent_node = std::string()) { |
| auto it = o.FindMember(property.c_str()); |
| if (it == o.MemberEnd()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is missing"; |
| if (parent_node.empty()) { |
| (*err) += ".\n"; |
| } else { |
| (*err) += " in `" + parent_node + "'.\n"; |
| } |
| } |
| } |
| return false; |
| } |
| |
| if (!it->value.IsString()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not a string type.\n"; |
| } |
| } |
| return false; |
| } |
| |
| if (ret) { |
| (*ret) = it->value.GetString(); |
| } |
| |
| return true; |
| } |
| |
| static bool ParseStringIntProperty(std::map<std::string, int> *ret, |
| std::string *err, const rapidjson::Value &o, |
| const std::string &property, bool required, |
| const std::string &parent = "") { |
| auto it = o.FindMember(property.c_str()); |
| if (it == o.MemberEnd()) { |
| if (required) { |
| if (err) { |
| if (!parent.empty()) { |
| (*err) += |
| "'" + property + "' property is missing in " + parent + ".\n"; |
| } else { |
| (*err) += "'" + property + "' property is missing.\n"; |
| } |
| } |
| } |
| return false; |
| } |
| |
| // Make sure we are dealing with an object / dictionary. |
| if (!it->value.IsObject()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not an object.\n"; |
| } |
| } |
| return false; |
| } |
| |
| ret->clear(); |
| const rapidjson::Value &dict = it->value; |
| |
| auto dictIt(dict.MemberBegin()); |
| auto dictItEnd(dict.MemberEnd()); |
| |
| for (; dictIt != dictItEnd; ++dictIt) { |
| if (!dictIt->value.IsNumber()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' value is not an int.\n"; |
| } |
| } |
| return false; |
| } |
| |
| // Insert into the list. |
| (*ret)[dictIt->name.GetString()] = dictIt->value.GetInt(); |
| } |
| return true; |
| } |
| |
| static bool ParseJSONProperty(std::map<std::string, double> *ret, |
| std::string *err, const rapidjson::Value &o, |
| const std::string &property, bool required) { |
| auto it = o.FindMember(property.c_str()); |
| if (it == o.MemberEnd()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is missing. \n'"; |
| } |
| } |
| return false; |
| } |
| |
| if (!it->value.IsObject()) { |
| if (required) { |
| if (err) { |
| (*err) += "'" + property + "' property is not a JSON object.\n"; |
| } |
| } |
| return false; |
| } |
| |
| ret->clear(); |
| const rapidjson::Value &obj = it->value; |
| auto it2(obj.MemberBegin()); |
| auto itEnd(obj.MemberEnd()); |
| for (; it2 != itEnd; it2++) { |
| if (it2->value.IsNumber()) |
| ret->insert(std::pair<std::string, double>(it2->name.GetString(), |
| it2->value.GetDouble())); |
| } |
| |
| return true; |
| } |
| |
| static bool ParseParameterProperty(Parameter *param, std::string *err, |
| const rapidjson::Value &o, |
| const std::string &prop, bool required) { |
| // A parameter value can either be a string or an array of either a boolean or |
| // a number. Booleans of any kind aren't supported here. Granted, it |
| // complicates the Parameter structure and breaks it semantically in the sense |
| // that the client probably works off the assumption that if the string is |
| // empty the vector is used, etc. Would a tagged union work? |
| if (ParseStringProperty(¶m->string_value, err, o, prop, false)) { |
| // Found string property. |
| return true; |
| } else if (ParseNumberArrayProperty(¶m->number_array, err, o, prop, |
| false)) { |
| // Found a number array. |
| return true; |
| } else if (ParseNumberProperty(¶m->number_value, err, o, prop, false)) { |
| return param->has_number_value = true; |
| } else if (ParseJSONProperty(¶m->json_double_value, err, o, prop, |
| false)) { |
| return true; |
| } else if (ParseBooleanProperty(¶m->bool_value, err, o, prop, false)) { |
| return true; |
| } else { |
| if (required) { |
| if (err) { |
| (*err) += "parameter must be a string or number / number array.\n"; |
| } |
| } |
| return false; |
| } |
| } |
| |
| static bool ParseExtensionsProperty(ExtensionMap *ret, std::string *err, |
| const rapidjson::Value &o) { |
| (void)err; |
| |
| auto it = o.FindMember("extensions"); |
| if (it == o.MemberEnd()) { |
| return false; |
| } |
| if (!it->value.IsObject()) { |
| return false; |
| } |
| ExtensionMap extensions; |
| auto extIt = it->value.MemberBegin(); |
| for (; extIt != it->value.MemberEnd(); extIt++) { |
| if (!extIt->value.IsObject()) continue; |
| std::string ext_name = extIt->name.GetString(); |
| if (!ParseJsonAsValue(&extensions[ext_name], extIt->value)) { |
| if (!ext_name.empty()) { |
| // create empty object so that an extension object is still of type |
| // object |
| extensions[ext_name] = Value{Value::Object{}}; |
| } |
| } |
| } |
| if (ret) { |
| (*ret) = extensions; |
| } |
| return true; |
| } |
| |
| static bool ParseAsset(Asset *asset, std::string *err, |
| const rapidjson::Value &o) { |
| ParseStringProperty(&asset->version, err, o, "version", true, "Asset"); |
| ParseStringProperty(&asset->generator, err, o, "generator", false, "Asset"); |
| ParseStringProperty(&asset->minVersion, err, o, "minVersion", false, "Asset"); |
| |
| ParseExtensionsProperty(&asset->extensions, err, o); |
| |
| // Unity exporter version is added as extra here |
| ParseExtrasProperty(&(asset->extras), o); |
| |
| return true; |
| } |
| |
| static bool ParseImage(Image *image, const int image_idx, std::string *err, |
| std::string *warn, const rapidjson::Value &o, |
| const std::string &basedir, FsCallbacks *fs, |
| LoadImageDataFunction *LoadImageData = nullptr, |
| void *load_image_user_data = nullptr) { |
| // A glTF image must either reference a bufferView or an image uri |
| |
| // schema says oneOf [`bufferView`, `uri`] |
| // TODO(syoyo): Check the type of each parameters. |
| bool hasBufferView = (o.FindMember("bufferView") != o.MemberEnd()); |
| bool hasURI = (o.FindMember("uri") != o.MemberEnd()); |
| |
| ParseStringProperty(&image->name, err, o, "name", false); |
| |
| if (hasBufferView && hasURI) { |
| // Should not both defined. |
| if (err) { |
| (*err) += |
| "Only one of `bufferView` or `uri` should be defined, but both are " |
| "defined for image[" + |
| std::to_string(image_idx) + "] name = \"" + image->name + "\"\n"; |
| } |
| return false; |
| } |
| |
| if (!hasBufferView && !hasURI) { |
| if (err) { |
| (*err) += "Neither required `bufferView` nor `uri` defined for image[" + |
| std::to_string(image_idx) + "] name = \"" + image->name + |
| "\"\n"; |
| } |
| return false; |
| } |
| |
| ParseExtensionsProperty(&image->extensions, err, o); |
| ParseExtrasProperty(&image->extras, o); |
| |
| if (hasBufferView) { |
| double bufferView = -1; |
| if (!ParseNumberProperty(&bufferView, err, o, "bufferView", true)) { |
| if (err) { |
| (*err) += "Failed to parse `bufferView` for image[" + |
| std::to_string(image_idx) + "] name = \"" + image->name + |
| "\"\n"; |
| } |
| return false; |
| } |
| |
| std::string mime_type; |
| ParseStringProperty(&mime_type, err, o, "mimeType", false); |
| |
| double width = 0.0; |
| ParseNumberProperty(&width, err, o, "width", false); |
| |
| double height = 0.0; |
| ParseNumberProperty(&height, err, o, "height", false); |
| |
| // Just only save some information here. Loading actual image data from |
| // bufferView is done after this `ParseImage` function. |
| image->bufferView = static_cast<int>(bufferView); |
| image->mimeType = mime_type; |
| image->width = static_cast<int>(width); |
| image->height = static_cast<int>(height); |
| |
| return true; |
| } |
| |
| // Parse URI & Load image data. |
| |
| std::string uri; |
| std::string tmp_err; |
| if (!ParseStringProperty(&uri, &tmp_err, o, "uri", true)) { |
| if (err) { |
| (*err) += "Failed to parse `uri` for image[" + std::to_string(image_idx) + |
| "] name = \"" + image->name + "\".\n"; |
| } |
| return false; |
| } |
| |
| std::vector<unsigned char> img; |
| |
| if (IsDataURI(uri)) { |
| if (!DecodeDataURI(&img, image->mimeType, uri, 0, false)) { |
| if (err) { |
| (*err) += "Failed to decode 'uri' for image[" + |
| std::to_string(image_idx) + "] name = [" + image->name + |
| "]\n"; |
| } |
| return false; |
| } |
| } else { |
| // Assume external file |
| // Keep texture path (for textures that cannot be decoded) |
| image->uri = uri; |
| #ifdef TINYGLTF_NO_EXTERNAL_IMAGE |
| return true; |
| #endif |
| if (!LoadExternalFile(&img, err, warn, uri, basedir, false, 0, false, fs)) { |
| if (warn) { |
| (*warn) += "Failed to load external 'uri' for image[" + |
| std::to_string(image_idx) + "] name = [" + image->name + |
| "]\n"; |
| } |
| // If the image cannot be loaded, keep uri as image->uri. |
| return true; |
| } |
| |
| if (img.empty()) { |
| if (warn) { |
| (*warn) += "Image data is empty for image[" + |
| std::to_string(image_idx) + "] name = [" + image->name + |
| "] \n"; |
| } |
| return false; |
| } |
| } |
| |
| if (*LoadImageData == nullptr) { |
| if (err) { |
| (*err) += "No LoadImageData callback specified.\n"; |
| } |
| return false; |
| } |
| return (*LoadImageData)(image, image_idx, err, warn, 0, 0, &img.at(0), |
| static_cast<int>(img.size()), load_image_user_data); |
| } |
| |
| static bool ParseTexture(Texture *texture, std::string *err, |
| const rapidjson::Value &o, |
| const std::string &basedir) { |
| (void)basedir; |
| double sampler = -1.0; |
| double source = -1.0; |
| ParseNumberProperty(&sampler, err, o, "sampler", false); |
| |
| ParseNumberProperty(&source, err, o, "source", false); |
| |
| texture->sampler = static_cast<int>(sampler); |
| texture->source = static_cast<int>(source); |
| |
| ParseExtensionsProperty(&texture->extensions, err, o); |
| ParseExtrasProperty(&texture->extras, o); |
| |
| ParseStringProperty(&texture->name, err, o, "name", false); |
| |
| return true; |
| } |
| |
| static bool ParseBuffer(Buffer *buffer, std::string *err, |
| const rapidjson::Value &o, FsCallbacks *fs, |
| const std::string &basedir, bool is_binary = false, |
| const unsigned char *bin_data = nullptr, |
| size_t bin_size = 0) { |
| double byteLength; |
| if (!ParseNumberProperty(&byteLength, err, o, "byteLength", true, "Buffer")) { |
| return false; |
| } |
| |
| // In glTF 2.0, uri is not mandatory anymore |
| |