1230 lines
40 KiB
C++
1230 lines
40 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, assimp team
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the
|
|
following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* 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.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
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
|
|
OWNER 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.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file glTFAsset.h
|
|
* Declares a glTF class to handle gltf/glb files
|
|
*
|
|
* glTF Extensions Support:
|
|
* KHR_binary_glTF: full
|
|
* KHR_materials_common: full
|
|
*/
|
|
#ifndef GLTF2ASSET_H_INC
|
|
#define GLTF2ASSET_H_INC
|
|
|
|
#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <list>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <stdexcept>
|
|
|
|
#define RAPIDJSON_HAS_STDSTRING 1
|
|
#include <rapidjson/rapidjson.h>
|
|
#include <rapidjson/document.h>
|
|
#include <rapidjson/error/en.h>
|
|
|
|
#ifdef ASSIMP_API
|
|
# include <memory>
|
|
# include <assimp/DefaultIOSystem.h>
|
|
# include "ByteSwapper.h"
|
|
#else
|
|
# include <memory>
|
|
# define AI_SWAP4(p)
|
|
# define ai_assert
|
|
#endif
|
|
|
|
|
|
#if _MSC_VER > 1500 || (defined __GNUC___)
|
|
# define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
|
|
# else
|
|
# define gltf_unordered_map map
|
|
#endif
|
|
|
|
#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
|
|
# include <unordered_map>
|
|
# if _MSC_VER > 1600
|
|
# define gltf_unordered_map unordered_map
|
|
# else
|
|
# define gltf_unordered_map tr1::unordered_map
|
|
# endif
|
|
#endif
|
|
|
|
namespace glTF2
|
|
{
|
|
#ifdef ASSIMP_API
|
|
using Assimp::IOStream;
|
|
using Assimp::IOSystem;
|
|
using std::shared_ptr;
|
|
#else
|
|
using std::shared_ptr;
|
|
|
|
typedef std::runtime_error DeadlyImportError;
|
|
typedef std::runtime_error DeadlyExportError;
|
|
|
|
enum aiOrigin { aiOrigin_SET = 0, aiOrigin_CUR = 1, aiOrigin_END = 2 };
|
|
class IOSystem;
|
|
class IOStream
|
|
{
|
|
FILE* f;
|
|
public:
|
|
IOStream(FILE* file) : f(file) {}
|
|
~IOStream() { fclose(f); f = 0; }
|
|
|
|
size_t Read(void* b, size_t sz, size_t n) { return fread(b, sz, n, f); }
|
|
size_t Write(const void* b, size_t sz, size_t n) { return fwrite(b, sz, n, f); }
|
|
int Seek(size_t off, aiOrigin orig) { return fseek(f, off, int(orig)); }
|
|
size_t Tell() const { return ftell(f); }
|
|
|
|
size_t FileSize() {
|
|
long p = Tell(), len = (Seek(0, aiOrigin_END), Tell());
|
|
return size_t((Seek(p, aiOrigin_SET), len));
|
|
}
|
|
};
|
|
#endif
|
|
|
|
using rapidjson::Value;
|
|
using rapidjson::Document;
|
|
|
|
class Asset;
|
|
class AssetWriter;
|
|
|
|
struct BufferView; // here due to cross-reference
|
|
struct Texture;
|
|
struct Light;
|
|
struct Skin;
|
|
|
|
|
|
// Vec/matrix types, as raw float arrays
|
|
typedef float (vec3)[3];
|
|
typedef float (vec4)[4];
|
|
typedef float (mat4)[16];
|
|
|
|
|
|
namespace Util
|
|
{
|
|
void EncodeBase64(const uint8_t* in, size_t inLength, std::string& out);
|
|
|
|
size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out);
|
|
|
|
inline size_t DecodeBase64(const char* in, uint8_t*& out)
|
|
{
|
|
return DecodeBase64(in, strlen(in), out);
|
|
}
|
|
|
|
struct DataURI
|
|
{
|
|
const char* mediaType;
|
|
const char* charset;
|
|
bool base64;
|
|
const char* data;
|
|
size_t dataLength;
|
|
};
|
|
|
|
//! Check if a uri is a data URI
|
|
inline bool ParseDataURI(const char* uri, size_t uriLen, DataURI& out);
|
|
}
|
|
|
|
|
|
//! Magic number for GLB files
|
|
#define AI_GLB_MAGIC_NUMBER "glTF"
|
|
|
|
#ifdef ASSIMP_API
|
|
#include "./../include/assimp/Compiler/pushpack1.h"
|
|
#endif
|
|
|
|
//! For the KHR_binary_glTF extension (binary .glb file)
|
|
//! 20-byte header (+ the JSON + a "body" data section)
|
|
struct GLB_Header
|
|
{
|
|
uint8_t magic[4]; //!< Magic number: "glTF"
|
|
uint32_t version; //!< Version number
|
|
uint32_t length; //!< Total length of the Binary glTF, including header, scene, and body, in bytes
|
|
uint32_t sceneLength; //!< Length, in bytes, of the glTF scene
|
|
uint32_t sceneFormat; //!< Specifies the format of the glTF scene (see the SceneFormat enum)
|
|
} PACK_STRUCT;
|
|
|
|
#ifdef ASSIMP_API
|
|
#include "./../include/assimp/Compiler/poppack1.h"
|
|
#endif
|
|
|
|
|
|
//! Values for the GLB_Header::sceneFormat field
|
|
enum SceneFormat
|
|
{
|
|
SceneFormat_JSON = 0
|
|
};
|
|
|
|
//! Values for the mesh primitive modes
|
|
enum PrimitiveMode
|
|
{
|
|
PrimitiveMode_POINTS = 0,
|
|
PrimitiveMode_LINES = 1,
|
|
PrimitiveMode_LINE_LOOP = 2,
|
|
PrimitiveMode_LINE_STRIP = 3,
|
|
PrimitiveMode_TRIANGLES = 4,
|
|
PrimitiveMode_TRIANGLE_STRIP = 5,
|
|
PrimitiveMode_TRIANGLE_FAN = 6
|
|
};
|
|
|
|
//! Values for the Accessor::componentType field
|
|
enum ComponentType
|
|
{
|
|
ComponentType_BYTE = 5120,
|
|
ComponentType_UNSIGNED_BYTE = 5121,
|
|
ComponentType_SHORT = 5122,
|
|
ComponentType_UNSIGNED_SHORT = 5123,
|
|
ComponentType_UNSIGNED_INT = 5125,
|
|
ComponentType_FLOAT = 5126
|
|
};
|
|
|
|
inline unsigned int ComponentTypeSize(ComponentType t)
|
|
{
|
|
switch (t) {
|
|
case ComponentType_SHORT:
|
|
case ComponentType_UNSIGNED_SHORT:
|
|
return 2;
|
|
|
|
case ComponentType_UNSIGNED_INT:
|
|
case ComponentType_FLOAT:
|
|
return 4;
|
|
|
|
case ComponentType_BYTE:
|
|
case ComponentType_UNSIGNED_BYTE:
|
|
return 1;
|
|
default:
|
|
throw DeadlyImportError("GLTF: Unsupported Component Type " + std::to_string(t));
|
|
}
|
|
}
|
|
|
|
//! Values for the BufferView::target field
|
|
enum BufferViewTarget
|
|
{
|
|
BufferViewTarget_ARRAY_BUFFER = 34962,
|
|
BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
|
|
};
|
|
|
|
//! Values for the Sampler::magFilter field
|
|
enum SamplerMagFilter
|
|
{
|
|
SamplerMagFilter_Nearest = 9728,
|
|
SamplerMagFilter_Linear = 9729
|
|
};
|
|
|
|
//! Values for the Sampler::minFilter field
|
|
enum SamplerMinFilter
|
|
{
|
|
SamplerMinFilter_Nearest = 9728,
|
|
SamplerMinFilter_Linear = 9729,
|
|
SamplerMinFilter_Nearest_Mipmap_Nearest = 9984,
|
|
SamplerMinFilter_Linear_Mipmap_Nearest = 9985,
|
|
SamplerMinFilter_Nearest_Mipmap_Linear = 9986,
|
|
SamplerMinFilter_Linear_Mipmap_Linear = 9987
|
|
};
|
|
|
|
//! Values for the Sampler::wrapS and Sampler::wrapT field
|
|
enum SamplerWrap
|
|
{
|
|
SamplerWrap_Clamp_To_Edge = 33071,
|
|
SamplerWrap_Mirrored_Repeat = 33648,
|
|
SamplerWrap_Repeat = 10497
|
|
};
|
|
|
|
//! Values for the Texture::format and Texture::internalFormat fields
|
|
enum TextureFormat
|
|
{
|
|
TextureFormat_ALPHA = 6406,
|
|
TextureFormat_RGB = 6407,
|
|
TextureFormat_RGBA = 6408,
|
|
TextureFormat_LUMINANCE = 6409,
|
|
TextureFormat_LUMINANCE_ALPHA = 6410
|
|
};
|
|
|
|
//! Values for the Texture::target field
|
|
enum TextureTarget
|
|
{
|
|
TextureTarget_TEXTURE_2D = 3553
|
|
};
|
|
|
|
//! Values for the Texture::type field
|
|
enum TextureType
|
|
{
|
|
TextureType_UNSIGNED_BYTE = 5121,
|
|
TextureType_UNSIGNED_SHORT_5_6_5 = 33635,
|
|
TextureType_UNSIGNED_SHORT_4_4_4_4 = 32819,
|
|
TextureType_UNSIGNED_SHORT_5_5_5_1 = 32820
|
|
};
|
|
|
|
|
|
//! Values for the Accessor::type field (helper class)
|
|
class AttribType
|
|
{
|
|
public:
|
|
enum Value
|
|
{ SCALAR, VEC2, VEC3, VEC4, MAT2, MAT3, MAT4 };
|
|
|
|
private:
|
|
static const size_t NUM_VALUES = static_cast<size_t>(MAT4)+1;
|
|
|
|
struct Info
|
|
{ const char* name; unsigned int numComponents; };
|
|
|
|
template<int N> struct data
|
|
{ static const Info infos[NUM_VALUES]; };
|
|
|
|
public:
|
|
inline static Value FromString(const char* str)
|
|
{
|
|
for (size_t i = 0; i < NUM_VALUES; ++i) {
|
|
if (strcmp(data<0>::infos[i].name, str) == 0) {
|
|
return static_cast<Value>(i);
|
|
}
|
|
}
|
|
return SCALAR;
|
|
}
|
|
|
|
inline static const char* ToString(Value type)
|
|
{
|
|
return data<0>::infos[static_cast<size_t>(type)].name;
|
|
}
|
|
|
|
inline static unsigned int GetNumComponents(Value type)
|
|
{
|
|
return data<0>::infos[static_cast<size_t>(type)].numComponents;
|
|
}
|
|
};
|
|
|
|
// must match the order of the AttribTypeTraits::Value enum!
|
|
template<int N> const AttribType::Info
|
|
AttribType::data<N>::infos[AttribType::NUM_VALUES] = {
|
|
{ "SCALAR", 1 }, { "VEC2", 2 }, { "VEC3", 3 }, { "VEC4", 4 }, { "MAT2", 4 }, { "MAT3", 9 }, { "MAT4", 16 }
|
|
};
|
|
|
|
|
|
|
|
//! A reference to one top-level object, which is valid
|
|
//! until the Asset instance is destroyed
|
|
template<class T>
|
|
class Ref
|
|
{
|
|
std::vector<T*>* vector;
|
|
unsigned int index;
|
|
|
|
public:
|
|
Ref() : vector(0), index(0) {}
|
|
Ref(std::vector<T*>& vec, unsigned int idx) : vector(&vec), index(idx) {}
|
|
|
|
inline unsigned int GetIndex() const
|
|
{ return index; }
|
|
|
|
operator bool() const
|
|
{ return vector != 0; }
|
|
|
|
T* operator->()
|
|
{ return (*vector)[index]; }
|
|
|
|
T& operator*()
|
|
{ return *((*vector)[index]); }
|
|
};
|
|
|
|
//! Helper struct to represent values that might not be present
|
|
template<class T>
|
|
struct Nullable
|
|
{
|
|
T value;
|
|
bool isPresent;
|
|
|
|
Nullable() : isPresent(false) {}
|
|
Nullable(T& val) : value(val), isPresent(true) {}
|
|
};
|
|
|
|
|
|
//! Base classe for all glTF top-level objects
|
|
struct Object
|
|
{
|
|
int index; //!< The index of this object within its property container
|
|
int oIndex; //!< The original index of this object defined in the JSON
|
|
std::string id; //!< The globally unique ID used to reference this object
|
|
std::string name; //!< The user-defined name of this object
|
|
|
|
//! Objects marked as special are not exported (used to emulate the binary body buffer)
|
|
virtual bool IsSpecial() const
|
|
{ return false; }
|
|
|
|
virtual ~Object() {}
|
|
|
|
//! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
|
|
static const char* TranslateId(Asset& r, const char* id)
|
|
{ return id; }
|
|
};
|
|
|
|
//
|
|
// Classes for each glTF top-level object type
|
|
//
|
|
|
|
//! A typed view into a BufferView. A BufferView contains raw binary data.
|
|
//! An accessor provides a typed view into a BufferView or a subset of a BufferView
|
|
//! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
|
|
struct Accessor : public Object
|
|
{
|
|
Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
|
|
unsigned int byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
|
|
unsigned int byteStride; //!< The stride, in bytes, between attributes referenced by this accessor. (default: 0)
|
|
ComponentType componentType; //!< The datatype of components in the attribute. (required)
|
|
unsigned int count; //!< The number of attributes referenced by this accessor. (required)
|
|
AttribType::Value type; //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
|
|
std::vector<float> max; //!< Maximum value of each component in this attribute.
|
|
std::vector<float> min; //!< Minimum value of each component in this attribute.
|
|
|
|
unsigned int GetNumComponents();
|
|
unsigned int GetBytesPerComponent();
|
|
unsigned int GetElementSize();
|
|
|
|
inline uint8_t* GetPointer();
|
|
|
|
template<class T>
|
|
bool ExtractData(T*& outData);
|
|
|
|
void WriteData(size_t count, const void* src_buffer, size_t src_stride);
|
|
|
|
//! Helper class to iterate the data
|
|
class Indexer
|
|
{
|
|
friend struct Accessor;
|
|
|
|
Accessor& accessor;
|
|
uint8_t* data;
|
|
size_t elemSize, stride;
|
|
|
|
Indexer(Accessor& acc);
|
|
|
|
public:
|
|
|
|
//! Accesses the i-th value as defined by the accessor
|
|
template<class T>
|
|
T GetValue(int i);
|
|
|
|
//! Accesses the i-th value as defined by the accessor
|
|
inline unsigned int GetUInt(int i)
|
|
{
|
|
return GetValue<unsigned int>(i);
|
|
}
|
|
|
|
inline bool IsValid() const
|
|
{
|
|
return data != 0;
|
|
}
|
|
};
|
|
|
|
inline Indexer GetIndexer()
|
|
{
|
|
return Indexer(*this);
|
|
}
|
|
|
|
Accessor() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
//! A buffer points to binary geometry, animation, or skins.
|
|
struct Buffer : public Object
|
|
{
|
|
/********************* Types *********************/
|
|
public:
|
|
|
|
enum Type
|
|
{
|
|
Type_arraybuffer,
|
|
Type_text
|
|
};
|
|
|
|
/// \struct SEncodedRegion
|
|
/// Descriptor of encoded region in "bufferView".
|
|
struct SEncodedRegion
|
|
{
|
|
const size_t Offset;///< Offset from begin of "bufferView" to encoded region, in bytes.
|
|
const size_t EncodedData_Length;///< Size of encoded region, in bytes.
|
|
uint8_t* const DecodedData;///< Cached encoded data.
|
|
const size_t DecodedData_Length;///< Size of decoded region, in bytes.
|
|
const std::string ID;///< ID of the region.
|
|
|
|
/// \fn SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
|
|
/// Constructor.
|
|
/// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
|
|
/// \param [in] pEncodedData_Length - size of encoded region, in bytes.
|
|
/// \param [in] pDecodedData - pointer to decoded data array.
|
|
/// \param [in] pDecodedData_Length - size of encoded region, in bytes.
|
|
/// \param [in] pID - ID of the region.
|
|
SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
|
|
: Offset(pOffset), EncodedData_Length(pEncodedData_Length), DecodedData(pDecodedData), DecodedData_Length(pDecodedData_Length), ID(pID)
|
|
{}
|
|
|
|
/// \fn ~SEncodedRegion()
|
|
/// Destructor.
|
|
~SEncodedRegion() { delete [] DecodedData; }
|
|
};
|
|
|
|
/******************* Variables *******************/
|
|
|
|
//std::string uri; //!< The uri of the buffer. Can be a filepath, a data uri, etc. (required)
|
|
size_t byteLength; //!< The length of the buffer in bytes. (default: 0)
|
|
//std::string type; //!< XMLHttpRequest responseType (default: "arraybuffer")
|
|
|
|
Type type;
|
|
|
|
/// \var EncodedRegion_Current
|
|
/// Pointer to currently active encoded region.
|
|
/// Why not decoding all regions at once and not to set one buffer with decoded data?
|
|
/// Yes, why not? Even "accessor" point to decoded data. I mean that fields "byteOffset", "byteStride" and "count" has values which describes decoded
|
|
/// data array. But only in range of mesh while is active parameters from "compressedData". For another mesh accessors point to decoded data too. But
|
|
/// offset is counted for another regions is encoded.
|
|
/// Example. You have two meshes. For every of it you have 4 bytes of data. That data compressed to 2 bytes. So, you have buffer with encoded data:
|
|
/// M1_E0, M1_E1, M2_E0, M2_E1.
|
|
/// After decoding you'll get:
|
|
/// M1_D0, M1_D1, M1_D2, M1_D3, M2_D0, M2_D1, M2_D2, M2_D3.
|
|
/// "accessors" must to use values that point to decoded data - obviously. So, you'll expect "accessors" like
|
|
/// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 4, byteLength: 4}
|
|
/// but in real life you'll get:
|
|
/// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 2, byteLength: 4}
|
|
/// Yes, accessor of next mesh has offset and length which mean: current mesh data is decoded, all other data is encoded.
|
|
/// And when before you start to read data of current mesh (with encoded data ofcourse) you must decode region of "bufferView", after read finished
|
|
/// delete encoding mark. And after that you can repeat process: decode data of mesh, read, delete decoded data.
|
|
///
|
|
/// Remark. Encoding all data at once is good in world with computers which do not has RAM limitation. So, you must use step by step encoding in
|
|
/// exporter and importer. And, thanks to such way, there is no need to load whole file into memory.
|
|
SEncodedRegion* EncodedRegion_Current;
|
|
|
|
private:
|
|
|
|
shared_ptr<uint8_t> mData; //!< Pointer to the data
|
|
bool mIsSpecial; //!< Set to true for special cases (e.g. the body buffer)
|
|
|
|
/// \var EncodedRegion_List
|
|
/// List of encoded regions.
|
|
std::list<SEncodedRegion*> EncodedRegion_List;
|
|
|
|
/******************* Functions *******************/
|
|
|
|
public:
|
|
|
|
Buffer();
|
|
~Buffer();
|
|
|
|
void Read(Value& obj, Asset& r);
|
|
|
|
bool LoadFromStream(IOStream& stream, size_t length = 0, size_t baseOffset = 0);
|
|
|
|
/// \fn void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
|
|
/// Mark region of "bufferView" as encoded. When data is request from such region then "bufferView" use decoded data.
|
|
/// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
|
|
/// \param [in] pEncodedData_Length - size of encoded region, in bytes.
|
|
/// \param [in] pDecodedData - pointer to decoded data array.
|
|
/// \param [in] pDecodedData_Length - size of encoded region, in bytes.
|
|
/// \param [in] pID - ID of the region.
|
|
void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID);
|
|
|
|
/// \fn void EncodedRegion_SetCurrent(const std::string& pID)
|
|
/// Select current encoded region by ID. \sa EncodedRegion_Current.
|
|
/// \param [in] pID - ID of the region.
|
|
void EncodedRegion_SetCurrent(const std::string& pID);
|
|
|
|
/// \fn bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
|
|
/// Replace part of buffer data. Pay attention that function work with original array of data (\ref mData) not with encoded regions.
|
|
/// \param [in] pBufferData_Offset - index of first element in buffer from which new data will be placed.
|
|
/// \param [in] pBufferData_Count - count of bytes in buffer which will be replaced.
|
|
/// \param [in] pReplace_Data - pointer to array with new data for buffer.
|
|
/// \param [in] pReplace_Count - count of bytes in new data.
|
|
/// \return true - if successfully replaced, false if input arguments is out of range.
|
|
bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count);
|
|
|
|
size_t AppendData(uint8_t* data, size_t length);
|
|
void Grow(size_t amount);
|
|
|
|
uint8_t* GetPointer()
|
|
{ return mData.get(); }
|
|
|
|
void MarkAsSpecial()
|
|
{ mIsSpecial = true; }
|
|
|
|
bool IsSpecial() const
|
|
{ return mIsSpecial; }
|
|
|
|
std::string GetURI()
|
|
{ return std::string(this->id) + ".bin"; }
|
|
|
|
static const char* TranslateId(Asset& r, const char* id);
|
|
};
|
|
|
|
//! A view into a buffer generally representing a subset of the buffer.
|
|
struct BufferView : public Object
|
|
{
|
|
Ref<Buffer> buffer; //! The ID of the buffer. (required)
|
|
size_t byteOffset; //! The offset into the buffer in bytes. (required)
|
|
size_t byteLength; //! The length of the bufferView in bytes. (default: 0)
|
|
|
|
BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
|
|
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
struct Camera : public Object
|
|
{
|
|
enum Type
|
|
{
|
|
Perspective,
|
|
Orthographic
|
|
};
|
|
|
|
Type type;
|
|
|
|
union
|
|
{
|
|
struct {
|
|
float aspectRatio; //!<The floating - point aspect ratio of the field of view. (0 = undefined = use the canvas one)
|
|
float yfov; //!<The floating - point vertical field of view in radians. (required)
|
|
float zfar; //!<The floating - point distance to the far clipping plane. (required)
|
|
float znear; //!< The floating - point distance to the near clipping plane. (required)
|
|
} perspective;
|
|
|
|
struct {
|
|
float xmag; //! The floating-point horizontal magnification of the view. (required)
|
|
float ymag; //! The floating-point vertical magnification of the view. (required)
|
|
float zfar; //! The floating-point distance to the far clipping plane. (required)
|
|
float znear; //! The floating-point distance to the near clipping plane. (required)
|
|
} ortographic;
|
|
} cameraProperties;
|
|
|
|
Camera() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
|
|
//! Image data used to create a texture.
|
|
struct Image : public Object
|
|
{
|
|
std::string uri; //! The uri of the image, that can be a file path, a data URI, etc.. (required)
|
|
|
|
Ref<BufferView> bufferView;
|
|
|
|
std::string mimeType;
|
|
|
|
int width, height;
|
|
|
|
private:
|
|
uint8_t* mData;
|
|
size_t mDataLength;
|
|
|
|
public:
|
|
|
|
Image();
|
|
void Read(Value& obj, Asset& r);
|
|
|
|
inline bool HasData() const
|
|
{ return mDataLength > 0; }
|
|
|
|
inline size_t GetDataLength() const
|
|
{ return mDataLength; }
|
|
|
|
inline const uint8_t* GetData() const
|
|
{ return mData; }
|
|
|
|
inline uint8_t* StealData();
|
|
|
|
inline void SetData(uint8_t* data, size_t length, Asset& r);
|
|
};
|
|
|
|
struct ColorProperty
|
|
{
|
|
union {
|
|
vec4, vec3
|
|
} color;
|
|
}
|
|
|
|
//! Holds a material property that can be a texture or a color (fallback for glTF 1)
|
|
struct FallbackTexProperty
|
|
{
|
|
Ref<Texture> texture;
|
|
ColorProperty color;
|
|
};
|
|
|
|
//! The material appearance of a primitive.
|
|
struct Material : public Object
|
|
{
|
|
//Ref<Sampler> source; //!< The ID of the technique.
|
|
//std::gltf_unordered_map<std::string, std::string> values; //!< A dictionary object of parameter values.
|
|
|
|
//! Techniques defined by KHR_materials_common
|
|
enum Technique
|
|
{
|
|
Technique_undefined = 0,
|
|
Technique_BLINN,
|
|
Technique_PHONG,
|
|
Technique_LAMBERT,
|
|
Technique_CONSTANT
|
|
};
|
|
|
|
//PBR metallic roughness properties
|
|
ColorProperty baseColor;
|
|
Ref<Texture> baseColorTexture;
|
|
Ref<Texture> metallicRoughnessTexture;
|
|
float metallicFactor;
|
|
float roughnessFactor;
|
|
|
|
//other basic material properties
|
|
Ref<Texture> normalTexture;
|
|
Ref<Texture> occlusionTexture;
|
|
Ref<Texture> emissiveTexture;
|
|
ColorProperty emissiveFactor;
|
|
std::string alphaMode;
|
|
float alphaCutoff;
|
|
bool doubleSided;
|
|
|
|
//fallback material properties (compatible with non-pbr defintions)
|
|
FallbackTexProperty diffuse;
|
|
FallbackTexProperty emissive;
|
|
FallbackTexProperty specular;
|
|
Ref<Texture> normal;
|
|
|
|
Technique technique;
|
|
|
|
Material() { SetDefaults(); }
|
|
void Read(Value& obj, Asset& r);
|
|
void SetDefaults();
|
|
};
|
|
|
|
//! A set of primitives to be rendered. A node can contain one or more meshes. A node's transform places the mesh in the scene.
|
|
struct Mesh : public Object
|
|
{
|
|
typedef std::vector< Ref<Accessor> > AccessorList;
|
|
|
|
struct Primitive
|
|
{
|
|
PrimitiveMode mode;
|
|
|
|
struct Attributes {
|
|
AccessorList position, normal, texcoord, color, joint, jointmatrix, weight;
|
|
} attributes;
|
|
|
|
Ref<Accessor> indices;
|
|
|
|
Ref<Material> material;
|
|
};
|
|
|
|
/// \struct SExtension
|
|
/// Extension used for mesh.
|
|
struct SExtension
|
|
{
|
|
/// \enum EType
|
|
/// Type of extension.
|
|
enum EType
|
|
{
|
|
#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
|
|
Compression_Open3DGC,///< Compression of mesh data using Open3DGC algorithm.
|
|
#endif
|
|
|
|
Unknown
|
|
};
|
|
|
|
EType Type;///< Type of extension.
|
|
|
|
/// \fn SExtension
|
|
/// Constructor.
|
|
/// \param [in] pType - type of extension.
|
|
SExtension(const EType pType)
|
|
: Type(pType)
|
|
{}
|
|
|
|
virtual ~SExtension() {
|
|
// empty
|
|
}
|
|
};
|
|
|
|
#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
|
|
/// \struct SCompression_Open3DGC
|
|
/// Compression of mesh data using Open3DGC algorithm.
|
|
struct SCompression_Open3DGC : public SExtension
|
|
{
|
|
using SExtension::Type;
|
|
|
|
std::string Buffer;///< ID of "buffer" used for storing compressed data.
|
|
size_t Offset;///< Offset in "bufferView" where compressed data are stored.
|
|
size_t Count;///< Count of elements in compressed data. Is always equivalent to size in bytes: look comments for "Type" and "Component_Type".
|
|
bool Binary;///< If true then "binary" mode is used for coding, if false - "ascii" mode.
|
|
size_t IndicesCount;///< Count of indices in mesh.
|
|
size_t VerticesCount;///< Count of vertices in mesh.
|
|
// AttribType::Value Type;///< Is always "SCALAR".
|
|
// ComponentType Component_Type;///< Is always "ComponentType_UNSIGNED_BYTE" (5121).
|
|
|
|
/// \fn SCompression_Open3DGC
|
|
/// Constructor.
|
|
SCompression_Open3DGC()
|
|
: SExtension(Compression_Open3DGC) {
|
|
// empty
|
|
}
|
|
|
|
virtual ~SCompression_Open3DGC() {
|
|
// empty
|
|
}
|
|
};
|
|
#endif
|
|
|
|
std::vector<Primitive> primitives;
|
|
std::list<SExtension*> Extension;///< List of extensions used in mesh.
|
|
|
|
Mesh() {}
|
|
|
|
/// \fn ~Mesh()
|
|
/// Destructor.
|
|
~Mesh() { for(std::list<SExtension*>::iterator it = Extension.begin(), it_end = Extension.end(); it != it_end; it++) { delete *it; }; }
|
|
|
|
/// \fn void Read(Value& pJSON_Object, Asset& pAsset_Root)
|
|
/// Get mesh data from JSON-object and place them to root asset.
|
|
/// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
|
|
/// \param [out] pAsset_Root - reference to root assed where data will be stored.
|
|
void Read(Value& pJSON_Object, Asset& pAsset_Root);
|
|
|
|
#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
|
|
/// \fn void Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root)
|
|
/// Decode part of "buffer" which encoded with Open3DGC algorithm.
|
|
/// \param [in] pCompression_Open3DGC - reference to structure which describe encoded region.
|
|
/// \param [out] pAsset_Root - reference to root assed where data will be stored.
|
|
void Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root);
|
|
#endif
|
|
};
|
|
|
|
struct Node : public Object
|
|
{
|
|
std::vector< Ref<Node> > children;
|
|
std::vector< Ref<Mesh> > meshes;
|
|
|
|
Nullable<mat4> matrix;
|
|
Nullable<vec3> translation;
|
|
Nullable<vec4> rotation;
|
|
Nullable<vec3> scale;
|
|
|
|
Ref<Camera> camera;
|
|
Ref<Light> light;
|
|
|
|
std::vector< Ref<Node> > skeletons; //!< The ID of skeleton nodes. Each of which is the root of a node hierarchy.
|
|
Ref<Skin> skin; //!< The ID of the skin referenced by this node.
|
|
std::string jointName; //!< Name used when this node is a joint in a skin.
|
|
|
|
Ref<Node> parent; //!< This is not part of the glTF specification. Used as a helper.
|
|
|
|
Node() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
struct Program : public Object
|
|
{
|
|
Program() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
|
|
struct Sampler : public Object
|
|
{
|
|
SamplerMagFilter magFilter; //!< The texture magnification filter. (required)
|
|
SamplerMinFilter minFilter; //!< The texture minification filter. (required)
|
|
SamplerWrap wrapS; //!< The texture wrapping in the S direction. (required)
|
|
SamplerWrap wrapT; //!< The texture wrapping in the T direction. (required)
|
|
|
|
Sampler() {}
|
|
void Read(Value& obj, Asset& r);
|
|
void SetDefaults();
|
|
};
|
|
|
|
struct Scene : public Object
|
|
{
|
|
std::vector< Ref<Node> > nodes;
|
|
|
|
Scene() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
struct Shader : public Object
|
|
{
|
|
Shader() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
struct Skin : public Object
|
|
{
|
|
Nullable<mat4> bindShapeMatrix; //!< Floating-point 4x4 transformation matrix stored in column-major order.
|
|
Ref<Accessor> inverseBindMatrices; //!< The ID of the accessor containing the floating-point 4x4 inverse-bind matrices.
|
|
std::vector<Ref<Node>> jointNames; //!< Joint names of the joints (nodes with a jointName property) in this skin.
|
|
std::string name; //!< The user-defined name of this object.
|
|
|
|
Skin() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
struct Technique : public Object
|
|
{
|
|
struct Parameters
|
|
{
|
|
|
|
};
|
|
|
|
struct States
|
|
{
|
|
|
|
};
|
|
|
|
struct Functions
|
|
{
|
|
|
|
};
|
|
|
|
Technique() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
//! A texture and its sampler.
|
|
struct Texture : public Object
|
|
{
|
|
Ref<Sampler> sampler; //!< The ID of the sampler used by this texture. (required)
|
|
Ref<Image> source; //!< The ID of the image used by this texture. (required)
|
|
|
|
//TextureFormat format; //!< The texture's format. (default: TextureFormat_RGBA)
|
|
//TextureFormat internalFormat; //!< The texture's internal format. (default: TextureFormat_RGBA)
|
|
|
|
//TextureTarget target; //!< The target that the WebGL texture should be bound to. (default: TextureTarget_TEXTURE_2D)
|
|
//TextureType type; //!< Texel datatype. (default: TextureType_UNSIGNED_BYTE)
|
|
|
|
Texture() {}
|
|
void Read(Value& obj, Asset& r);
|
|
};
|
|
|
|
|
|
//! A light (from KHR_materials_common extension)
|
|
struct Light : public Object
|
|
{
|
|
enum Type
|
|
{
|
|
Type_undefined,
|
|
Type_ambient,
|
|
Type_directional,
|
|
Type_point,
|
|
Type_spot
|
|
};
|
|
|
|
Type type;
|
|
|
|
vec4 color;
|
|
float distance;
|
|
float constantAttenuation;
|
|
float linearAttenuation;
|
|
float quadraticAttenuation;
|
|
float falloffAngle;
|
|
float falloffExponent;
|
|
|
|
Light() {}
|
|
void Read(Value& obj, Asset& r);
|
|
|
|
void SetDefaults();
|
|
};
|
|
|
|
struct Animation : public Object
|
|
{
|
|
struct AnimSampler {
|
|
std::string id; //!< The ID of this sampler.
|
|
std::string input; //!< The ID of a parameter in this animation to use as key-frame input.
|
|
std::string interpolation; //!< Type of interpolation algorithm to use between key-frames.
|
|
std::string output; //!< The ID of a parameter in this animation to use as key-frame output.
|
|
};
|
|
|
|
struct AnimChannel {
|
|
int sampler; //!< The index of a sampler in the containing animation's samplers property.
|
|
|
|
struct AnimTarget {
|
|
Ref<Node> node; //!< The node to animate.
|
|
std::string path; //!< The name of property of the node to animate ("translation", "rotation", or "scale").
|
|
} target;
|
|
};
|
|
|
|
struct AnimParameters {
|
|
Ref<Accessor> TIME; //!< Accessor reference to a buffer storing a array of floating point scalar values.
|
|
Ref<Accessor> rotation; //!< Accessor reference to a buffer storing a array of four-component floating-point vectors.
|
|
Ref<Accessor> scale; //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
|
|
Ref<Accessor> translation; //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
|
|
};
|
|
|
|
// AnimChannel Channels[3]; //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
|
|
// AnimParameters Parameters; //!< The samplers that interpolate between the key-frames.
|
|
// AnimSampler Samplers[3]; //!< The parameterized inputs representing the key-frame data.
|
|
|
|
std::vector<AnimChannel> Channels; //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
|
|
AnimParameters Parameters; //!< The samplers that interpolate between the key-frames.
|
|
std::vector<AnimSampler> Samplers; //!< The parameterized inputs representing the key-frame data.
|
|
|
|
Animation() {}
|
|
void Read(Value& obj, Asset& r);
|
|
|
|
//! Get accessor given an animation parameter name.
|
|
Ref<Accessor> GetAccessor(std::string name) {
|
|
if (name == "TIME") {
|
|
return Parameters.TIME;
|
|
} else if (name == "rotation") {
|
|
return Parameters.rotation;
|
|
} else if (name == "scale") {
|
|
return Parameters.scale;
|
|
} else if (name == "translation") {
|
|
return Parameters.translation;
|
|
}
|
|
return Ref<Accessor>();
|
|
}
|
|
};
|
|
|
|
|
|
//! Base class for LazyDict that acts as an interface
|
|
class LazyDictBase
|
|
{
|
|
public:
|
|
virtual ~LazyDictBase() {}
|
|
|
|
virtual void AttachToDocument(Document& doc) = 0;
|
|
virtual void DetachFromDocument() = 0;
|
|
|
|
virtual void WriteObjects(AssetWriter& writer) = 0;
|
|
};
|
|
|
|
|
|
template<class T>
|
|
class LazyDict;
|
|
|
|
//! (Implemented in glTFAssetWriter.h)
|
|
template<class T>
|
|
void WriteLazyDict(LazyDict<T>& d, AssetWriter& w);
|
|
|
|
|
|
//! Manages lazy loading of the glTF top-level objects, and keeps a reference to them by ID
|
|
//! It is the owner the loaded objects, so when it is destroyed it also deletes them
|
|
template<class T>
|
|
class LazyDict : public LazyDictBase
|
|
{
|
|
friend class Asset;
|
|
friend class AssetWriter;
|
|
|
|
typedef typename std::gltf_unordered_map< unsigned int, unsigned int > Dict;
|
|
|
|
std::vector<T*> mObjs; //! The read objects
|
|
Dict mObjsByOIndex; //! The read objects accessible by original index
|
|
const char* mDictId; //! ID of the dictionary object
|
|
const char* mExtId; //! ID of the extension defining the dictionary
|
|
Value* mDict; //! JSON dictionary object
|
|
Asset& mAsset; //! The asset instance
|
|
|
|
void AttachToDocument(Document& doc);
|
|
void DetachFromDocument();
|
|
|
|
void WriteObjects(AssetWriter& writer)
|
|
{ WriteLazyDict<T>(*this, writer); }
|
|
|
|
Ref<T> Add(T* obj);
|
|
|
|
public:
|
|
LazyDict(Asset& asset, const char* dictId, const char* extId = 0);
|
|
~LazyDict();
|
|
|
|
Ref<T> Retrieve(unsigned int i);
|
|
|
|
Ref<T> Get(unsigned int i);
|
|
|
|
Ref<T> Create(const char* id);
|
|
Ref<T> Create(const std::string& id)
|
|
{ return Create(id.c_str()); }
|
|
|
|
inline unsigned int Size() const
|
|
{ return unsigned(mObjs.size()); }
|
|
|
|
inline T& operator[](size_t i)
|
|
{ return *mObjs[i]; }
|
|
|
|
};
|
|
|
|
|
|
struct AssetMetadata
|
|
{
|
|
std::string copyright; //!< A copyright message suitable for display to credit the content creator.
|
|
std::string generator; //!< Tool that generated this glTF model.Useful for debugging.
|
|
bool premultipliedAlpha; //!< Specifies if the shaders were generated with premultiplied alpha. (default: false)
|
|
|
|
struct {
|
|
std::string api; //!< Specifies the target rendering API (default: "WebGL")
|
|
std::string version; //!< Specifies the target rendering API (default: "1.0.3")
|
|
} profile; //!< Specifies the target rendering API and version, e.g., WebGL 1.0.3. (default: {})
|
|
|
|
float version; //!< The glTF format version
|
|
|
|
void Read(Document& doc);
|
|
|
|
AssetMetadata()
|
|
: premultipliedAlpha(false)
|
|
, version(0)
|
|
{
|
|
}
|
|
};
|
|
|
|
//
|
|
// glTF Asset class
|
|
//
|
|
|
|
//! Root object for a glTF asset
|
|
class Asset
|
|
{
|
|
typedef std::gltf_unordered_map<std::string, int> IdMap;
|
|
|
|
template<class T>
|
|
friend class LazyDict;
|
|
|
|
friend struct Buffer; // To access OpenFile
|
|
|
|
friend class AssetWriter;
|
|
|
|
private:
|
|
IOSystem* mIOSystem;
|
|
|
|
std::string mCurrentAssetDir;
|
|
|
|
size_t mSceneLength;
|
|
size_t mBodyOffset, mBodyLength;
|
|
|
|
std::vector<LazyDictBase*> mDicts;
|
|
|
|
IdMap mUsedIds;
|
|
|
|
Ref<Buffer> mBodyBuffer;
|
|
|
|
Asset(Asset&);
|
|
Asset& operator=(const Asset&);
|
|
|
|
public:
|
|
|
|
//! Keeps info about the enabled extensions
|
|
struct Extensions
|
|
{
|
|
bool KHR_binary_glTF;
|
|
bool KHR_materials_common;
|
|
|
|
} extensionsUsed;
|
|
|
|
AssetMetadata asset;
|
|
|
|
|
|
// Dictionaries for each type of object
|
|
|
|
LazyDict<Accessor> accessors;
|
|
LazyDict<Animation> animations;
|
|
LazyDict<Buffer> buffers;
|
|
LazyDict<BufferView> bufferViews;
|
|
LazyDict<Camera> cameras;
|
|
LazyDict<Image> images;
|
|
LazyDict<Material> materials;
|
|
LazyDict<Mesh> meshes;
|
|
LazyDict<Node> nodes;
|
|
//LazyDict<Program> programs;
|
|
LazyDict<Sampler> samplers;
|
|
LazyDict<Scene> scenes;
|
|
//LazyDict<Shader> shaders;
|
|
LazyDict<Skin> skins;
|
|
//LazyDict<Technique> techniques;
|
|
LazyDict<Texture> textures;
|
|
|
|
LazyDict<Light> lights; // KHR_materials_common ext
|
|
|
|
Ref<Scene> scene;
|
|
|
|
public:
|
|
Asset(IOSystem* io = 0)
|
|
: mIOSystem(io)
|
|
, asset()
|
|
, accessors (*this, "accessors")
|
|
, animations (*this, "animations")
|
|
, buffers (*this, "buffers")
|
|
, bufferViews (*this, "bufferViews")
|
|
, cameras (*this, "cameras")
|
|
, images (*this, "images")
|
|
, materials (*this, "materials")
|
|
, meshes (*this, "meshes")
|
|
, nodes (*this, "nodes")
|
|
//, programs (*this, "programs")
|
|
, samplers (*this, "samplers")
|
|
, scenes (*this, "scenes")
|
|
//, shaders (*this, "shaders")
|
|
, skins (*this, "skins")
|
|
//, techniques (*this, "techniques")
|
|
, textures (*this, "textures")
|
|
, lights (*this, "lights", "KHR_materials_common")
|
|
{
|
|
memset(&extensionsUsed, 0, sizeof(extensionsUsed));
|
|
}
|
|
|
|
//! Main function
|
|
void Load(const std::string& file, bool isBinary = false);
|
|
|
|
//! Enables the "KHR_binary_glTF" extension on the asset
|
|
void SetAsBinary();
|
|
|
|
//! Search for an available name, starting from the given strings
|
|
std::string FindUniqueID(const std::string& str, const char* suffix);
|
|
|
|
Ref<Buffer> GetBodyBuffer()
|
|
{ return mBodyBuffer; }
|
|
|
|
private:
|
|
void ReadBinaryHeader(IOStream& stream);
|
|
|
|
void ReadExtensionsUsed(Document& doc);
|
|
|
|
|
|
IOStream* OpenFile(std::string path, const char* mode, bool absolute = false);
|
|
};
|
|
|
|
}
|
|
|
|
// Include the implementation of the methods
|
|
#include "glTF2Asset.inl"
|
|
|
|
#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
|
|
|
|
#endif // GLTF2ASSET_H_INC
|