1081 lines
34 KiB
C++
1081 lines
34 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2020, 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_materials_pbrSpecularGlossiness full
|
|
* KHR_materials_unlit full
|
|
* KHR_lights_punctual full
|
|
*/
|
|
#ifndef GLTF2ASSET_H_INC
|
|
#define GLTF2ASSET_H_INC
|
|
|
|
#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
|
|
|
|
#include <assimp/Exceptional.h>
|
|
|
|
#include <algorithm>
|
|
#include <list>
|
|
#include <map>
|
|
#include <set>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#define RAPIDJSON_HAS_STDSTRING 1
|
|
#define RAPIDJSON_NOMEMBERITERATORCLASS
|
|
#include <rapidjson/document.h>
|
|
#include <rapidjson/error/en.h>
|
|
#include <rapidjson/rapidjson.h>
|
|
|
|
#ifdef ASSIMP_API
|
|
#include <assimp/ByteSwapper.h>
|
|
#include <assimp/DefaultIOSystem.h>
|
|
#include <memory>
|
|
#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
|
|
#define gltf_unordered_set set
|
|
#endif
|
|
|
|
#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#if _MSC_VER > 1600
|
|
#define gltf_unordered_map unordered_map
|
|
#define gltf_unordered_set unordered_set
|
|
#else
|
|
#define gltf_unordered_map tr1::unordered_map
|
|
#define gltf_unordered_set tr1::unordered_set
|
|
#endif
|
|
#endif
|
|
|
|
#include <assimp/StringUtils.h>
|
|
|
|
#include "AssetLib/glTF/glTFCommon.h"
|
|
|
|
namespace glTF2 {
|
|
|
|
using glTFCommon::IOStream;
|
|
using glTFCommon::IOSystem;
|
|
using glTFCommon::shared_ptr;
|
|
|
|
using rapidjson::Document;
|
|
using rapidjson::Value;
|
|
|
|
class Asset;
|
|
class AssetWriter;
|
|
|
|
struct BufferView; // here due to cross-reference
|
|
struct Texture;
|
|
struct Skin;
|
|
|
|
using glTFCommon::mat4;
|
|
using glTFCommon::vec3;
|
|
using glTFCommon::vec4;
|
|
|
|
//! Magic number for GLB files
|
|
#define AI_GLB_MAGIC_NUMBER "glTF"
|
|
#include <assimp/pbrmaterial.h>
|
|
|
|
#ifdef ASSIMP_API
|
|
#include <assimp/Compiler/pushpack1.h>
|
|
#endif
|
|
|
|
//! For binary .glb files
|
|
//! 12-byte header (+ the JSON + a "body" data section)
|
|
struct GLB_Header {
|
|
uint8_t magic[4]; //!< Magic number: "glTF"
|
|
uint32_t version; //!< Version number (always 2 as of the last update)
|
|
uint32_t length; //!< Total length of the Binary glTF, including header, scene, and body, in bytes
|
|
} PACK_STRUCT;
|
|
|
|
struct GLB_Chunk {
|
|
uint32_t chunkLength;
|
|
uint32_t chunkType;
|
|
} PACK_STRUCT;
|
|
|
|
#ifdef ASSIMP_API
|
|
#include <assimp/Compiler/poppack1.h>
|
|
#endif
|
|
|
|
//! Values for the GLB_Chunk::chunkType field
|
|
enum ChunkType {
|
|
ChunkType_JSON = 0x4E4F534A,
|
|
ChunkType_BIN = 0x004E4942
|
|
};
|
|
|
|
//! 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 " + to_string(t));
|
|
}
|
|
}
|
|
|
|
//! Values for the BufferView::target field
|
|
enum BufferViewTarget {
|
|
BufferViewTarget_NONE = 0,
|
|
BufferViewTarget_ARRAY_BUFFER = 34962,
|
|
BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
|
|
};
|
|
|
|
//! Values for the Sampler::magFilter field
|
|
enum class SamplerMagFilter : unsigned int {
|
|
UNSET = 0,
|
|
SamplerMagFilter_Nearest = 9728,
|
|
SamplerMagFilter_Linear = 9729
|
|
};
|
|
|
|
//! Values for the Sampler::minFilter field
|
|
enum class SamplerMinFilter : unsigned int {
|
|
UNSET = 0,
|
|
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 class SamplerWrap : unsigned int {
|
|
UNSET = 0,
|
|
Clamp_To_Edge = 33071,
|
|
Mirrored_Repeat = 33648,
|
|
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 Animation::Target::path field
|
|
enum AnimationPath {
|
|
AnimationPath_TRANSLATION,
|
|
AnimationPath_ROTATION,
|
|
AnimationPath_SCALE,
|
|
AnimationPath_WEIGHTS,
|
|
};
|
|
|
|
//! Values for the Animation::Sampler::interpolation field
|
|
enum Interpolation {
|
|
Interpolation_LINEAR,
|
|
Interpolation_STEP,
|
|
Interpolation_CUBICSPLINE,
|
|
};
|
|
|
|
//! 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 class 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 {
|
|
struct Sparse;
|
|
|
|
Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
|
|
size_t byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
|
|
ComponentType componentType; //!< The datatype of components in the attribute. (required)
|
|
size_t 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<double> max; //!< Maximum value of each component in this attribute.
|
|
std::vector<double> min; //!< Minimum value of each component in this attribute.
|
|
std::unique_ptr<Sparse> sparse;
|
|
|
|
unsigned int GetNumComponents();
|
|
unsigned int GetBytesPerComponent();
|
|
unsigned int GetElementSize();
|
|
|
|
inline uint8_t *GetPointer();
|
|
|
|
template <class T>
|
|
void ExtractData(T *&outData);
|
|
|
|
void WriteData(size_t count, const void *src_buffer, size_t src_stride);
|
|
void WriteSparseValues(size_t count, const void *src_data, size_t src_dataStride);
|
|
void WriteSparseIndices(size_t count, const void *src_idx, size_t src_idxStride);
|
|
|
|
//! Helper class to iterate the data
|
|
class Indexer {
|
|
friend struct Accessor;
|
|
|
|
// This field is reported as not used, making it protectd is the easiest way to work around it without going to the bottom of what the problem is:
|
|
// ../code/glTF2/glTF2Asset.h:392:19: error: private field 'accessor' is not used [-Werror,-Wunused-private-field]
|
|
protected:
|
|
Accessor &accessor;
|
|
|
|
private:
|
|
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);
|
|
|
|
//sparse
|
|
struct Sparse {
|
|
size_t count;
|
|
ComponentType indicesType;
|
|
Ref<BufferView> indices;
|
|
size_t indicesByteOffset;
|
|
Ref<BufferView> values;
|
|
size_t valuesByteOffset;
|
|
|
|
std::vector<uint8_t> data; //!< Actual data, which may be defaulted to an array of zeros or the original data, with the sparse buffer view applied on top of it.
|
|
|
|
void PopulateData(size_t numBytes, uint8_t *bytes);
|
|
void PatchData(unsigned int elementSize);
|
|
};
|
|
};
|
|
|
|
//! 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")
|
|
size_t capacity = 0; //!< The capacity of the buffer in bytes. (default: 0)
|
|
|
|
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 of course) 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);
|
|
bool ReplaceData_joint(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)
|
|
unsigned int byteStride; //!< The stride, in bytes, between attributes referenced by this accessor. (default: 0)
|
|
|
|
BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
|
|
|
|
void Read(Value &obj, Asset &r);
|
|
uint8_t *GetPointer(size_t accOffset);
|
|
};
|
|
|
|
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() :
|
|
type(Perspective),
|
|
cameraProperties() {
|
|
// empty
|
|
}
|
|
void Read(Value &obj, Asset &r);
|
|
};
|
|
|
|
//! A light (from KHR_lights_punctual extension)
|
|
struct Light : public Object {
|
|
enum Type {
|
|
Directional,
|
|
Point,
|
|
Spot
|
|
};
|
|
|
|
Type type;
|
|
|
|
vec3 color;
|
|
float intensity;
|
|
Nullable<float> range;
|
|
|
|
float innerConeAngle;
|
|
float outerConeAngle;
|
|
|
|
Light() {}
|
|
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:
|
|
std::unique_ptr<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.get(); }
|
|
|
|
inline uint8_t *StealData();
|
|
|
|
inline void SetData(uint8_t *data, size_t length, Asset &r);
|
|
};
|
|
|
|
const vec4 defaultBaseColor = { 1, 1, 1, 1 };
|
|
const vec3 defaultEmissiveFactor = { 0, 0, 0 };
|
|
const vec4 defaultDiffuseFactor = { 1, 1, 1, 1 };
|
|
const vec3 defaultSpecularFactor = { 1, 1, 1 };
|
|
|
|
struct TextureInfo {
|
|
Ref<Texture> texture;
|
|
unsigned int index;
|
|
unsigned int texCoord = 0;
|
|
|
|
bool textureTransformSupported = false;
|
|
struct TextureTransformExt {
|
|
float offset[2];
|
|
float rotation;
|
|
float scale[2];
|
|
} TextureTransformExt_t;
|
|
};
|
|
|
|
struct NormalTextureInfo : TextureInfo {
|
|
float scale = 1;
|
|
};
|
|
|
|
struct OcclusionTextureInfo : TextureInfo {
|
|
float strength = 1;
|
|
};
|
|
|
|
struct PbrMetallicRoughness {
|
|
vec4 baseColorFactor;
|
|
TextureInfo baseColorTexture;
|
|
TextureInfo metallicRoughnessTexture;
|
|
float metallicFactor;
|
|
float roughnessFactor;
|
|
};
|
|
|
|
struct PbrSpecularGlossiness {
|
|
vec4 diffuseFactor;
|
|
vec3 specularFactor;
|
|
float glossinessFactor;
|
|
TextureInfo diffuseTexture;
|
|
TextureInfo specularGlossinessTexture;
|
|
|
|
PbrSpecularGlossiness() { SetDefaults(); }
|
|
void SetDefaults();
|
|
};
|
|
|
|
//! The material appearance of a primitive.
|
|
struct Material : public Object {
|
|
//PBR metallic roughness properties
|
|
PbrMetallicRoughness pbrMetallicRoughness;
|
|
|
|
//other basic material properties
|
|
NormalTextureInfo normalTexture;
|
|
OcclusionTextureInfo occlusionTexture;
|
|
TextureInfo emissiveTexture;
|
|
vec3 emissiveFactor;
|
|
std::string alphaMode;
|
|
float alphaCutoff;
|
|
bool doubleSided;
|
|
|
|
//extension: KHR_materials_pbrSpecularGlossiness
|
|
Nullable<PbrSpecularGlossiness> pbrSpecularGlossiness;
|
|
|
|
//extension: KHR_materials_unlit
|
|
bool unlit;
|
|
|
|
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, tangent, texcoord, color, joint, jointmatrix, weight;
|
|
} attributes;
|
|
|
|
Ref<Accessor> indices;
|
|
|
|
Ref<Material> material;
|
|
|
|
struct Target {
|
|
AccessorList position, normal, tangent;
|
|
};
|
|
std::vector<Target> targets;
|
|
};
|
|
|
|
std::vector<Primitive> primitives;
|
|
|
|
std::vector<float> weights;
|
|
std::vector<std::string> targetNames;
|
|
|
|
Mesh() {}
|
|
|
|
/// \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 asset where data will be stored.
|
|
void Read(Value &pJSON_Object, Asset &pAsset_Root);
|
|
};
|
|
|
|
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.
|
|
SamplerMinFilter minFilter; //!< The texture minification filter.
|
|
SamplerWrap wrapS; //!< The texture wrapping in the S direction.
|
|
SamplerWrap wrapT; //!< The texture wrapping in the T direction.
|
|
|
|
Sampler() { SetDefaults(); }
|
|
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);
|
|
};
|
|
|
|
//! 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);
|
|
};
|
|
|
|
struct Animation : public Object {
|
|
struct Sampler {
|
|
Sampler() :
|
|
interpolation(Interpolation_LINEAR) {}
|
|
|
|
Ref<Accessor> input; //!< Accessor reference to the buffer storing the key-frame times.
|
|
Ref<Accessor> output; //!< Accessor reference to the buffer storing the key-frame values.
|
|
Interpolation interpolation; //!< Type of interpolation algorithm to use between key-frames.
|
|
};
|
|
|
|
struct Target {
|
|
Target() :
|
|
path(AnimationPath_TRANSLATION) {}
|
|
|
|
Ref<Node> node; //!< The node to animate.
|
|
AnimationPath path; //!< The property of the node to animate.
|
|
};
|
|
|
|
struct Channel {
|
|
Channel() :
|
|
sampler(-1) {}
|
|
|
|
int sampler; //!< The sampler index containing the animation data.
|
|
Target target; //!< The node and property to animate.
|
|
};
|
|
|
|
std::vector<Sampler> samplers; //!< All the key-frame data for this animation.
|
|
std::vector<Channel> channels; //!< Data to connect nodes to key-frames.
|
|
|
|
Animation() {}
|
|
void Read(Value &obj, Asset &r);
|
|
};
|
|
|
|
//! 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;
|
|
typedef typename std::gltf_unordered_map<std::string, unsigned int> IdDict;
|
|
|
|
std::vector<T *> mObjs; //! The read objects
|
|
Dict mObjsByOIndex; //! The read objects accessible by original index
|
|
IdDict mObjsById; //! The read objects accessible by id
|
|
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
|
|
|
|
std::gltf_unordered_set<unsigned int> mRecursiveReferenceCheck; //! Used by Retrieve to prevent recursive lookups
|
|
|
|
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> Get(const char *id);
|
|
|
|
Ref<T> Create(const char *id);
|
|
Ref<T> Create(const std::string &id) { return Create(id.c_str()); }
|
|
|
|
unsigned int Remove(const char *id);
|
|
|
|
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.
|
|
|
|
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: {})
|
|
|
|
std::string version; //!< The glTF format version
|
|
|
|
void Read(Document &doc);
|
|
|
|
AssetMetadata() :
|
|
version("") {}
|
|
};
|
|
|
|
//
|
|
// 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_materials_pbrSpecularGlossiness;
|
|
bool KHR_materials_unlit;
|
|
bool KHR_lights_punctual;
|
|
bool KHR_texture_transform;
|
|
} extensionsUsed;
|
|
|
|
//! Keeps info about the required extensions
|
|
struct RequiredExtensions {
|
|
bool KHR_draco_mesh_compression;
|
|
} extensionsRequired;
|
|
|
|
AssetMetadata asset;
|
|
|
|
// Dictionaries for each type of object
|
|
|
|
LazyDict<Accessor> accessors;
|
|
LazyDict<Animation> animations;
|
|
LazyDict<Buffer> buffers;
|
|
LazyDict<BufferView> bufferViews;
|
|
LazyDict<Camera> cameras;
|
|
LazyDict<Light> lights;
|
|
LazyDict<Image> images;
|
|
LazyDict<Material> materials;
|
|
LazyDict<Mesh> meshes;
|
|
LazyDict<Node> nodes;
|
|
LazyDict<Sampler> samplers;
|
|
LazyDict<Scene> scenes;
|
|
LazyDict<Skin> skins;
|
|
LazyDict<Texture> textures;
|
|
|
|
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"),
|
|
lights(*this, "lights", "KHR_lights_punctual"),
|
|
images(*this, "images"),
|
|
materials(*this, "materials"),
|
|
meshes(*this, "meshes"),
|
|
nodes(*this, "nodes"),
|
|
samplers(*this, "samplers"),
|
|
scenes(*this, "scenes"),
|
|
skins(*this, "skins"),
|
|
textures(*this, "textures") {
|
|
memset(&extensionsUsed, 0, sizeof(extensionsUsed));
|
|
memset(&extensionsRequired, 0, sizeof(extensionsRequired));
|
|
}
|
|
|
|
//! Main function
|
|
void Load(const std::string &file, bool isBinary = false);
|
|
|
|
//! Enables binary encoding 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, std::vector<char> &sceneData);
|
|
|
|
void ReadExtensionsUsed(Document &doc);
|
|
void ReadExtensionsRequired(Document &doc);
|
|
|
|
IOStream *OpenFile(std::string path, const char *mode, bool absolute = false);
|
|
};
|
|
|
|
} // namespace glTF2
|
|
|
|
// Include the implementation of the methods
|
|
#include "glTF2Asset.inl"
|
|
|
|
#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
|
|
|
|
#endif // GLTF2ASSET_H_INC
|