[+] glTF import/export. Support for Open3DGC-compression of mesh primitives.
Alexandr Arutjunov
parent
0dcf4dcd16
commit
0ad2f2247a
179
code/glTFAsset.h
179
code/glTFAsset.h
|
|
@ -450,88 +450,49 @@ namespace glTF
|
|||
|
||||
//! A buffer points to binary geometry, animation, or skins.
|
||||
struct Buffer : public Object
|
||||
{
|
||||
public:
|
||||
|
||||
enum Type
|
||||
{
|
||||
Type_arraybuffer,
|
||||
Type_text
|
||||
};
|
||||
|
||||
//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;
|
||||
|
||||
private:
|
||||
shared_ptr<uint8_t> mData; //!< Pointer to the data
|
||||
bool mIsSpecial; //!< Set to true for special cases (e.g. the body buffer)
|
||||
|
||||
public:
|
||||
Buffer();
|
||||
|
||||
void Read(Value& obj, Asset& r);
|
||||
|
||||
bool LoadFromStream(IOStream& stream, size_t length = 0, size_t baseOffset = 0);
|
||||
|
||||
/// \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. For example: decoded/encoded data.
|
||||
/// \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; }
|
||||
|
||||
static const char* TranslateId(Asset& r, const char* id);
|
||||
};
|
||||
|
||||
/// \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.
|
||||
/********************* Types *********************/
|
||||
public:
|
||||
|
||||
/// \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)
|
||||
{}
|
||||
enum Type
|
||||
{
|
||||
Type_arraybuffer,
|
||||
Type_text
|
||||
};
|
||||
|
||||
/// \fn ~SEncodedRegion()
|
||||
/// Destructor.
|
||||
~SEncodedRegion() { delete [] DecodedData; }
|
||||
};
|
||||
/// \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.
|
||||
|
||||
//! 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)
|
||||
/// \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.
|
||||
|
|
@ -555,19 +516,25 @@ namespace glTF
|
|||
/// 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;
|
||||
|
||||
BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
|
||||
/******************* Functions *******************/
|
||||
|
||||
BufferView()
|
||||
: EncodedRegion_Current(nullptr)
|
||||
{}
|
||||
public:
|
||||
|
||||
~BufferView() { for(SEncodedRegion* reg : EncodedRegion_List) delete reg; }
|
||||
Buffer();
|
||||
~Buffer();
|
||||
|
||||
void Read(Value& obj, Asset& r);
|
||||
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.
|
||||
|
|
@ -582,8 +549,42 @@ namespace glTF
|
|||
/// 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; }
|
||||
|
||||
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
|
||||
{
|
||||
|
|
@ -739,6 +740,7 @@ namespace glTF
|
|||
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".
|
||||
|
|
@ -766,11 +768,11 @@ namespace glTF
|
|||
/// \param [out] pAsset_Root - reference to root assed where data will be stored.
|
||||
void Read(Value& pJSON_Object, Asset& pAsset_Root);
|
||||
|
||||
/// \fn void Decode_O3DGC(Value& pJSON_Object_CompressedData, Asset& pAsset_Root)
|
||||
/// Decode part of "bufferView" which encoded with Open3DGC algorythm.
|
||||
/// \param [in] pJSON_Object_CompressedData - reference to JSON-object which is "compressedData" block.
|
||||
/// \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(Value& pJSON_Object_CompressedData, Asset& pAsset_Root);
|
||||
void Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root);
|
||||
};
|
||||
|
||||
struct Node : public Object
|
||||
|
|
@ -941,6 +943,7 @@ namespace glTF
|
|||
|
||||
Ref<T> Get(const char* id);
|
||||
Ref<T> Get(unsigned int i);
|
||||
Ref<T> Get(const std::string& pID) { return Get(pID.c_str()); }
|
||||
|
||||
Ref<T> Create(const char* id);
|
||||
Ref<T> Create(const std::string& id)
|
||||
|
|
|
|||
|
|
@ -247,9 +247,14 @@ Ref<T> LazyDict<T>::Create(const char* id)
|
|||
|
||||
|
||||
inline Buffer::Buffer()
|
||||
: byteLength(0), type(Type_arraybuffer), mIsSpecial(false)
|
||||
: byteLength(0), type(Type_arraybuffer), EncodedRegion_Current(nullptr), mIsSpecial(false)
|
||||
{ }
|
||||
|
||||
inline Buffer::~Buffer()
|
||||
{
|
||||
for(SEncodedRegion* reg : EncodedRegion_List) delete reg;
|
||||
}
|
||||
|
||||
inline const char* Buffer::TranslateId(Asset& r, const char* id)
|
||||
{
|
||||
// Compatibility with old spec
|
||||
|
|
@ -330,6 +335,57 @@ inline bool Buffer::LoadFromStream(IOStream& stream, size_t length, size_t baseO
|
|||
return true;
|
||||
}
|
||||
|
||||
inline void Buffer::EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
|
||||
{
|
||||
// Check pointer to data
|
||||
if(pDecodedData == nullptr) throw DeadlyImportError("GLTF: for marking encoded region pointer to decoded data must be provided.");
|
||||
|
||||
// Check offset
|
||||
if(pOffset > byteLength)
|
||||
{
|
||||
constexpr uint8_t val_size = 32;
|
||||
|
||||
char val[val_size];
|
||||
|
||||
ai_snprintf(val, val_size, "%llu", (long long)pOffset);
|
||||
throw DeadlyImportError(std::string("GLTF: incorrect offset value (") + val + ") for marking encoded region.");
|
||||
}
|
||||
|
||||
// Check length
|
||||
if((pOffset + pEncodedData_Length) > byteLength)
|
||||
{
|
||||
constexpr uint8_t val_size = 64;
|
||||
|
||||
char val[val_size];
|
||||
|
||||
ai_snprintf(val, val_size, "%llu, %llu", (long long)pOffset, (long long)pEncodedData_Length);
|
||||
throw DeadlyImportError(std::string("GLTF: encoded region with offset/length (") + val + ") is out of range.");
|
||||
}
|
||||
|
||||
// Add new region
|
||||
EncodedRegion_List.push_back(new SEncodedRegion(pOffset, pEncodedData_Length, pDecodedData, pDecodedData_Length, pID));
|
||||
// And set new value for "byteLength"
|
||||
byteLength += (pDecodedData_Length - pEncodedData_Length);
|
||||
}
|
||||
|
||||
inline void Buffer::EncodedRegion_SetCurrent(const std::string& pID)
|
||||
{
|
||||
if((EncodedRegion_Current != nullptr) && (EncodedRegion_Current->ID == pID)) return;
|
||||
|
||||
for(SEncodedRegion* reg : EncodedRegion_List)
|
||||
{
|
||||
if(reg->ID == pID)
|
||||
{
|
||||
EncodedRegion_Current = reg;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
throw DeadlyImportError("GLTF: EncodedRegion with ID: \"" + pID + "\" not found.");
|
||||
}
|
||||
|
||||
inline bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
|
||||
{
|
||||
const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
|
||||
|
|
@ -384,58 +440,9 @@ inline void BufferView::Read(Value& obj, Asset& r)
|
|||
byteLength = MemberOrDefault(obj, "byteLength", 0u);
|
||||
}
|
||||
|
||||
inline void BufferView::EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
|
||||
{
|
||||
const size_t last = byteOffset + byteLength;
|
||||
|
||||
// Check pointer to data
|
||||
if(pDecodedData == nullptr) throw DeadlyImportError("GLTF: for marking encoded region pointer to decoded data must be provided.");
|
||||
|
||||
// Check offset
|
||||
if((pOffset < byteOffset) || (pOffset > last))
|
||||
{
|
||||
constexpr uint8_t val_size = 32;
|
||||
|
||||
char val[val_size];
|
||||
|
||||
ai_snprintf(val, val_size, "%llu", (long long)pOffset);
|
||||
throw DeadlyImportError(std::string("GLTF: incorrect offset value (") + val + ") for marking encoded region.");
|
||||
}
|
||||
|
||||
// Check length
|
||||
if((pOffset + pEncodedData_Length) > last)
|
||||
{
|
||||
constexpr uint8_t val_size = 64;
|
||||
|
||||
char val[val_size];
|
||||
|
||||
ai_snprintf(val, val_size, "%llu, %llu", (long long)pOffset, (long long)pEncodedData_Length);
|
||||
throw DeadlyImportError(std::string("GLTF: encoded region with offset/length (") + val + ") is out of range.");
|
||||
}
|
||||
|
||||
// Add new region
|
||||
EncodedRegion_List.push_back(new SEncodedRegion(pOffset, pEncodedData_Length, pDecodedData, pDecodedData_Length, pID));
|
||||
// And set new value for "byteLength"
|
||||
byteLength += (pDecodedData_Length - pEncodedData_Length);
|
||||
}
|
||||
|
||||
inline void BufferView::EncodedRegion_SetCurrent(const std::string& pID)
|
||||
{
|
||||
if((EncodedRegion_Current != nullptr) && (EncodedRegion_Current->ID == pID)) return;
|
||||
|
||||
for(SEncodedRegion* reg : EncodedRegion_List)
|
||||
{
|
||||
if(reg->ID == pID)
|
||||
{
|
||||
EncodedRegion_Current = reg;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
throw DeadlyImportError("GLTF: EncodedRegion with ID: \"" + pID + "\" not found.");
|
||||
}
|
||||
//
|
||||
// struct Accessor
|
||||
//
|
||||
|
||||
inline void Accessor::Read(Value& obj, Asset& r)
|
||||
{
|
||||
|
|
@ -477,12 +484,12 @@ inline uint8_t* Accessor::GetPointer()
|
|||
size_t offset = byteOffset + bufferView->byteOffset;
|
||||
|
||||
// Check if region is encoded.
|
||||
if(bufferView->EncodedRegion_Current != nullptr)
|
||||
if(bufferView->buffer->EncodedRegion_Current != nullptr)
|
||||
{
|
||||
const size_t begin = bufferView->EncodedRegion_Current->Offset;
|
||||
const size_t end = bufferView->EncodedRegion_Current->Offset + bufferView->EncodedRegion_Current->DecodedData_Length;
|
||||
const size_t begin = bufferView->buffer->EncodedRegion_Current->Offset;
|
||||
const size_t end = bufferView->buffer->EncodedRegion_Current->Offset + bufferView->buffer->EncodedRegion_Current->DecodedData_Length;
|
||||
|
||||
if((offset >= begin) && (offset < end)) return &bufferView->EncodedRegion_Current->DecodedData[offset - begin];
|
||||
if((offset >= begin) && (offset < end)) return &bufferView->buffer->EncodedRegion_Current->DecodedData[offset - begin];
|
||||
}
|
||||
|
||||
return basePtr + offset;
|
||||
|
|
@ -770,33 +777,7 @@ namespace {
|
|||
|
||||
inline void Mesh::Read(Value& pJSON_Object, Asset& pAsset_Root)
|
||||
{
|
||||
//
|
||||
// Mesh extensions
|
||||
//
|
||||
// At first check for extensions. They can affect on interpretaion of mesh data.
|
||||
Value* extensions = FindObject(pJSON_Object, "extensions");
|
||||
|
||||
if(extensions != nullptr)
|
||||
{
|
||||
// At first check if data of mesh is compressed. Because buffer data must be decoded before another get data from it.
|
||||
// Only Open3DGC supported at now.
|
||||
Value* o3dgc = FindObject(*extensions, "Open3DGC-compression");
|
||||
|
||||
if(o3dgc != nullptr)
|
||||
{
|
||||
// Search compressed data
|
||||
Value* comp_data = FindObject(*o3dgc, "compressedData");
|
||||
|
||||
if(comp_data == nullptr) throw DeadlyImportError("GLTF: \"Open3DGC-compression\" must has \"compressedData\".");
|
||||
|
||||
Assimp::DefaultLogger::get()->info("GLTF: Decompressing Open3DGC data.");
|
||||
Decode_O3DGC(*comp_data, pAsset_Root);
|
||||
}// if(o3dgc == nullptr)
|
||||
}// if(extensions != nullptr)
|
||||
|
||||
//
|
||||
// Mesh primitives.
|
||||
//
|
||||
/****************** Mesh primitives ******************/
|
||||
if (Value* primitives = FindArray(pJSON_Object, "primitives")) {
|
||||
this->primitives.resize(primitives->Size());
|
||||
for (unsigned int i = 0; i < primitives->Size(); ++i) {
|
||||
|
|
@ -831,158 +812,229 @@ inline void Mesh::Read(Value& pJSON_Object, Asset& pAsset_Root)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/****************** Mesh extensions ******************/
|
||||
Value* json_extensions = FindObject(pJSON_Object, "extensions");
|
||||
|
||||
if(json_extensions == nullptr) goto mr_skip_extensions;
|
||||
|
||||
for(Value::MemberIterator it_memb = json_extensions->MemberBegin(); it_memb != json_extensions->MemberEnd(); it_memb++)
|
||||
{
|
||||
if(it_memb->name.GetString() == std::string("Open3DGC-compression"))
|
||||
{
|
||||
// Search for compressed data.
|
||||
// Compressed data contain description of part of "buffer" which is encoded. This part must be decoded and
|
||||
// new data will replace old encoded part by request. In fact \"compressedData\" is kind of "accessor" structure.
|
||||
Value* comp_data = FindObject(it_memb->value, "compressedData");
|
||||
|
||||
if(comp_data == nullptr) throw DeadlyImportError("GLTF: \"Open3DGC-compression\" must has \"compressedData\".");
|
||||
|
||||
Assimp::DefaultLogger::get()->info("GLTF: Decompressing Open3DGC data.");
|
||||
|
||||
/************** Read data from JSON-document **************/
|
||||
#define MESH_READ_COMPRESSEDDATA_MEMBER(pFieldName, pOut) \
|
||||
if(!ReadMember(*comp_data, pFieldName, pOut)) \
|
||||
{ \
|
||||
throw DeadlyImportError(std::string("GLTF: \"compressedData\" must has \"") + pFieldName + "\"."); \
|
||||
}
|
||||
|
||||
const char* mode_str;
|
||||
const char* type_str;
|
||||
ComponentType component_type;
|
||||
SCompression_Open3DGC* ext_o3dgc = new SCompression_Open3DGC;
|
||||
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("buffer", ext_o3dgc->Buffer);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("byteOffset", ext_o3dgc->Offset);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("componentType", component_type);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("type", type_str);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("count", ext_o3dgc->Count);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("mode", mode_str);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("indicesCount", ext_o3dgc->IndicesCount);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("verticesCount", ext_o3dgc->VerticesCount);
|
||||
|
||||
#undef MESH_READ_COMPRESSEDDATA_MEMBER
|
||||
|
||||
// Check some values
|
||||
if(strcmp(type_str, "SCALAR")) throw DeadlyImportError("GLTF: only \"SCALAR\" type is supported for compressed data.");
|
||||
if(component_type != ComponentType_UNSIGNED_BYTE) throw DeadlyImportError("GLTF: only \"UNSIGNED_BYTE\" component type is supported for compressed data.");
|
||||
|
||||
// Set read/write data mode.
|
||||
if(strcmp(mode_str, "binary") == 0)
|
||||
ext_o3dgc->Binary = true;
|
||||
else if(strcmp(mode_str, "ascii") == 0)
|
||||
ext_o3dgc->Binary = false;
|
||||
else
|
||||
throw DeadlyImportError(std::string("GLTF: for compressed data supported modes is: \"ascii\", \"binary\". Not the: \"") + mode_str + "\".");
|
||||
|
||||
/************************ Decoding ************************/
|
||||
Decode_O3DGC(*ext_o3dgc, pAsset_Root);
|
||||
Extension.push_back(ext_o3dgc);// store info in mesh extensions list.
|
||||
}// if(it_memb->name.GetString() == "Open3DGC-compression")
|
||||
else
|
||||
{
|
||||
throw DeadlyImportError(std::string("GLTF: Unknown mesh extension: \"") + it_memb->name.GetString() + "\".");
|
||||
}
|
||||
}// for(Value::MemberIterator it_memb = json_extensions->MemberBegin(); it_memb != json_extensions->MemberEnd(); json_extensions++)
|
||||
|
||||
mr_skip_extensions:
|
||||
|
||||
return;// After label some operators must be present.
|
||||
}
|
||||
|
||||
inline void Mesh::Decode_O3DGC(Value& pJSON_Object_CompressedData, Asset& pAsset_Root)
|
||||
inline void Mesh::Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root)
|
||||
{
|
||||
// Compressed data contain description of part of "bufferView" which is encoded. This part must be decoded and
|
||||
// new data must replace old encoded part. In fact \"compressedData\" is similar to "accessor" structure.
|
||||
const char* bufview_id;
|
||||
uint32_t byte_offset, count, count_indices, count_vertices;
|
||||
const char* mode_str;
|
||||
const char* type_str;
|
||||
ComponentType component_type;
|
||||
std::list<o3dgc::Real*> float_attributes_indices;// See above about "floatAttributesIndexes".
|
||||
using IndicesType = unsigned short;///< \sa glTFExporter::ExportMeshes.
|
||||
|
||||
/**********************************************************/
|
||||
/************** Read data from JSON-document **************/
|
||||
/**********************************************************/
|
||||
|
||||
#define MESH_READ_COMPRESSEDDATA_MEMBER(pFieldName, pOut) \
|
||||
if(!ReadMember(pJSON_Object_CompressedData, pFieldName, pOut)) { throw DeadlyImportError(std::string("GLTF: \"compressedData\" must has \"") + pFieldName + "\"."); }
|
||||
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("bufferView", bufview_id);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("byteOffset", byte_offset);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("componentType", component_type);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("count", count);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("indicesCount", count_indices);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("verticesCount", count_vertices);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("mode", mode_str);
|
||||
MESH_READ_COMPRESSEDDATA_MEMBER("type", type_str);
|
||||
|
||||
#undef MESH_READ_COMPRESSEDDATA_MEMBER
|
||||
|
||||
//
|
||||
// Check for float attributes
|
||||
//
|
||||
// Object example:
|
||||
// "floatAttributesIndexes": {
|
||||
// "accessor_1356": 0,
|
||||
// "accessor_1358": 1,
|
||||
// "accessor_1360": 2
|
||||
// },
|
||||
//
|
||||
// Find object "floatAttributesIndexes"
|
||||
Value* float_attr_ind = FindObject(pJSON_Object_CompressedData, "floatAttributesIndexes");
|
||||
|
||||
if(float_attr_ind != nullptr)
|
||||
{
|
||||
size_t attr_num = 0;
|
||||
|
||||
// Walk thru children and get accessors and numbers of attributes.
|
||||
for(Value::MemberIterator memb_it = float_attr_ind->MemberBegin(); memb_it != float_attr_ind->MemberEnd(); ++memb_it)
|
||||
{
|
||||
if(!memb_it->name.IsString()) throw DeadlyImportError("GLTF: name of the member of \"floatAttributesIndexes\" must be a string.");
|
||||
if(!memb_it->value.IsUint()) throw DeadlyImportError(std::string("GLTF: value of the member (\"") + memb_it->name.GetString() + \
|
||||
"\") in \"floatAttributesIndexes\" must be an unsigned integer.");
|
||||
/*if(attr_num != memb_it->value.GetUint()) throw DeadlyImportError(std::string("GLTF: invalid number of float attribute index. Member (\"") + \
|
||||
memb_it->name.GetString() + "\".");*/
|
||||
|
||||
attr_num++;
|
||||
// Checks passed, extract data.
|
||||
Ref<Accessor> attr_cur_acc = pAsset_Root.accessors.Get(memb_it->name.GetString());
|
||||
|
||||
float_attributes_indices.push_back((float*)attr_cur_acc->GetPointer());
|
||||
}
|
||||
}// if(float_attr_ind != nullptr)
|
||||
|
||||
// Check some values
|
||||
if(strcmp(type_str, "SCALAR")) throw DeadlyImportError("GLTF: only \"SCALAR\" type is supported for compressed data.");
|
||||
if(component_type != ComponentType_UNSIGNED_BYTE) throw DeadlyImportError("GLTF: only \"UNSIGNED_BYTE\" component type is supported for compressed data.");
|
||||
if((strcmp(mode_str, "binary") != 0) && (strcmp(mode_str, "ascii") != 0))
|
||||
{
|
||||
throw DeadlyImportError(std::string("GLTF: for compressed data supported modes is: \"ascii\", \"binary\". Not the: \"") + mode_str + "\".");
|
||||
}
|
||||
|
||||
/**********************************************************/
|
||||
/********************* Decoding data **********************/
|
||||
/**********************************************************/
|
||||
|
||||
// Search for "bufferView" by ID.
|
||||
Ref<BufferView> bufview = pAsset_Root.bufferViews.Get(bufview_id);
|
||||
|
||||
//
|
||||
// Decode data. Adapted piece of code from COLLADA2GLTF converter.
|
||||
//
|
||||
// void testDecode(shared_ptr <GLTFMesh> mesh, BinaryStream &bstream)
|
||||
o3dgc::SC3DMCDecoder<uint16_t> decoder;
|
||||
o3dgc::IndexedFaceSet<uint16_t> ifs;
|
||||
uint8_t* output_data;
|
||||
size_t size_vertex, size_normal, size_indices, output_data_size;
|
||||
o3dgc::BinaryStream bstream;
|
||||
float* tarrays[6];
|
||||
o3dgc::SC3DMCDecoder<IndicesType> decoder;
|
||||
o3dgc::IndexedFaceSet<IndicesType> ifs;
|
||||
o3dgc::BinaryStream bstream;
|
||||
uint8_t* decoded_data;
|
||||
size_t decoded_data_size = 0;
|
||||
Ref<Buffer> buf = pAsset_Root.buffers.Get(pCompression_Open3DGC.Buffer);
|
||||
|
||||
// Read data from buffer and place it in BinaryStream for decoder.
|
||||
bstream.LoadFromBuffer(&bufview->buffer->GetPointer()[bufview->byteOffset + byte_offset], count);
|
||||
// Just "Count" because always is used type equivalent to uint8_t.
|
||||
bstream.LoadFromBuffer(&buf->GetPointer()[pCompression_Open3DGC.Offset], pCompression_Open3DGC.Count);
|
||||
|
||||
// After decoding header we can get size of primitives
|
||||
// After decoding header we can get size of primitives.
|
||||
if(decoder.DecodeHeader(ifs, bstream) != o3dgc::O3DGC_OK) throw DeadlyImportError("GLTF: can not decode Open3DGC header.");
|
||||
|
||||
size_indices = ifs.GetNCoordIndex() * 3 * sizeof(unsigned short);
|
||||
size_vertex = ifs.GetNCoord() * 3 * sizeof(float);
|
||||
size_normal = ifs.GetNNormal() * 3 * sizeof(float);
|
||||
/****************** Get sizes of arrays and check sizes ******************/
|
||||
// Note. See "Limitations for meshes when using Open3DGC-compression".
|
||||
|
||||
for(size_t idx_attr = 0, idx_attr_end = ifs.GetNumFloatAttributes(); idx_attr < idx_attr_end; idx_attr++)
|
||||
// Indices
|
||||
size_t size_coordindex = ifs.GetNCoordIndex() * 3;// See float attributes note.
|
||||
|
||||
if(primitives[0].indices->count != size_coordindex)
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Compressed indices count (" + std::to_string(size_coordindex) +
|
||||
") not equal to uncompressed (" + std::to_string(primitives[0].indices->count) + ").");
|
||||
|
||||
size_coordindex *= sizeof(IndicesType);
|
||||
// Coordinates
|
||||
size_t size_coord = ifs.GetNCoord();// See float attributes note.
|
||||
|
||||
if(primitives[0].attributes.position[0]->count != size_coord)
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Compressed positions count (" + std::to_string(size_coord) +
|
||||
") not equal to uncompressed (" + std::to_string(primitives[0].attributes.position[0]->count) + ").");
|
||||
|
||||
size_coord *= 3 * sizeof(float);
|
||||
// Normals
|
||||
size_t size_normal = ifs.GetNNormal();// See float attributes note.
|
||||
|
||||
if(primitives[0].attributes.normal[0]->count != size_normal)
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Compressed normals count (" + std::to_string(size_normal) +
|
||||
") not equal to uncompressed (" + std::to_string(primitives[0].attributes.normal[0]->count) + ").");
|
||||
|
||||
size_normal *= 3 * sizeof(float);
|
||||
// Additional attributes.
|
||||
std::vector<size_t> size_floatattr;
|
||||
std::vector<size_t> size_intattr;
|
||||
|
||||
size_floatattr.resize(ifs.GetNumFloatAttributes());
|
||||
size_intattr.resize(ifs.GetNumIntAttributes());
|
||||
|
||||
decoded_data_size = size_coordindex + size_coord + size_normal;
|
||||
for(size_t idx = 0, idx_end = size_floatattr.size(), idx_texcoord = 0; idx < idx_end; idx++)
|
||||
{
|
||||
size_t qty_attr = ifs.GetNFloatAttribute(idx_attr);
|
||||
// size = number_of_elements * components_per_element * size_of_component.
|
||||
// Note. But as you can see above, at first we are use this variable in meaning "count". After checking count of objects...
|
||||
size_t tval = ifs.GetNFloatAttribute(idx);
|
||||
|
||||
if(qty_attr == 0) continue;
|
||||
|
||||
tarrays[idx_attr] = new float[qty_attr * ifs.GetFloatAttributeDim(idx_attr)];
|
||||
ifs.SetFloatAttribute(idx_attr, tarrays[idx_attr]);
|
||||
/*
|
||||
switch(ifs.GetFloatAttributeType(idx_attr))
|
||||
switch(ifs.GetFloatAttributeType(idx))
|
||||
{
|
||||
// Unknown for Open3DGC,
|
||||
// but not for COLLADA2GLTF - GLTF::Semantic::JOINT. What's mean "JOINT"? Good question, but lim(comments in COLLADA2GLTF) = 0.
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_UNKOWN:// 0
|
||||
break;
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_POSITION:// 1
|
||||
break;
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_NORMAL:// 2
|
||||
break;
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_COLOR:// 3
|
||||
break;
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:// 4
|
||||
break;
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_WEIGHT:// 5
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:
|
||||
// Check situation when encoded data contain texture coordinates but primitive not.
|
||||
if(idx_texcoord < primitives[0].attributes.texcoord.size())
|
||||
{
|
||||
if(primitives[0].attributes.texcoord[idx]->count != tval)
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Compressed texture coordinates count (" + std::to_string(tval) +
|
||||
") not equal to uncompressed (" + std::to_string(primitives[0].attributes.texcoord[idx]->count) + ").");
|
||||
|
||||
idx_texcoord++;
|
||||
}
|
||||
else
|
||||
{
|
||||
ifs.SetNFloatAttribute(idx, 0);// Disable decoding this attribute.
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
throw DeadlyImportError("GLTF: Unknown type of float attribute (" + std::to_string(idx_attr) + ") for Open3DGC encoding.");
|
||||
}*/
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of float attribute: " + std::to_string(ifs.GetFloatAttributeType(idx)));
|
||||
}
|
||||
|
||||
tval *= ifs.GetFloatAttributeDim(idx) * sizeof(o3dgc::Real);// After checking count of objects we can get size of array.
|
||||
size_floatattr[idx] = tval;
|
||||
decoded_data_size += tval;
|
||||
}
|
||||
|
||||
//size_texcoord = ifs.GetNFloatAttribute(0) * 2 * sizeof(float);
|
||||
for(size_t idx = 0, idx_end = size_intattr.size(); idx < idx_end; idx++)
|
||||
{
|
||||
// size = number_of_elements * components_per_element * size_of_component. See float attributes note.
|
||||
size_t tval = ifs.GetNIntAttribute(idx);
|
||||
|
||||
output_data_size = size_vertex + size_normal + /*size_texcoord*/ + size_indices;
|
||||
output_data = new uint8_t[output_data_size];
|
||||
switch(ifs.GetIntAttributeType(idx))
|
||||
{
|
||||
default:
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of int attribute: " + std::to_string(ifs.GetIntAttributeType(idx)));
|
||||
}
|
||||
|
||||
float* uncompressed_vertices = (float* const)(output_data + size_indices);// size_indices => vertex offset
|
||||
tval *= ifs.GetIntAttributeDim(idx) * sizeof(long);// See float attributes note.
|
||||
size_intattr[idx] = tval;
|
||||
decoded_data_size += tval;
|
||||
}
|
||||
|
||||
ifs.SetCoordIndex((uint16_t* const)output_data);
|
||||
ifs.SetCoord((float* const)uncompressed_vertices);
|
||||
// Create array for decoded data.
|
||||
decoded_data = new uint8_t[decoded_data_size];
|
||||
|
||||
if(ifs.GetNNormal() > 0) ifs.SetNormal((float* const)(output_data + size_indices + size_vertex));
|
||||
/****************** Set right array regions for decoder ******************/
|
||||
|
||||
//if(ifs.GetNFloatAttribute(0)) ifs.SetFloatAttribute(0, (float* const)(output_data + size_indices + size_vertex + size_normal));
|
||||
auto get_buf_offset = [](Ref<Accessor>& pAccessor) -> size_t { return pAccessor->byteOffset + pAccessor->bufferView->byteOffset; };
|
||||
|
||||
// Indices
|
||||
ifs.SetCoordIndex((IndicesType* const)(decoded_data + get_buf_offset(primitives[0].indices)));
|
||||
// Coordinates
|
||||
ifs.SetCoord((o3dgc::Real* const)(decoded_data + get_buf_offset(primitives[0].attributes.position[0])));
|
||||
// Normals
|
||||
if(size_normal)
|
||||
{
|
||||
ifs.SetNormal((o3dgc::Real* const)(decoded_data + get_buf_offset(primitives[0].attributes.normal[0])));
|
||||
}
|
||||
|
||||
for(size_t idx = 0, idx_end = size_floatattr.size(), idx_texcoord = 0; idx < idx_end; idx++)
|
||||
{
|
||||
switch(ifs.GetFloatAttributeType(idx))
|
||||
{
|
||||
case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:
|
||||
if(idx_texcoord < primitives[0].attributes.texcoord.size())
|
||||
{
|
||||
// See above about absent attributes.
|
||||
ifs.SetFloatAttribute(idx, (o3dgc::Real* const)(decoded_data + get_buf_offset(primitives[0].attributes.texcoord[idx])));
|
||||
idx_texcoord++;
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of float attribute: " + std::to_string(ifs.GetFloatAttributeType(idx)));
|
||||
}
|
||||
}
|
||||
|
||||
for(size_t idx = 0, idx_end = size_intattr.size(); idx < idx_end; idx++)
|
||||
{
|
||||
switch(ifs.GetIntAttributeType(idx))
|
||||
{
|
||||
// ifs.SetIntAttribute(idx, (long* const)(decoded_data + get_buf_offset(primitives[0].attributes.joint)));
|
||||
default:
|
||||
throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of int attribute: " + std::to_string(ifs.GetIntAttributeType(idx)));
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Decode data
|
||||
if(decoder.DecodePlayload(ifs, bstream) != o3dgc::O3DGC_OK) throw DeadlyImportError("GLTF: can not decode Open3DGC data.");
|
||||
//
|
||||
if(decoder.DecodePayload(ifs, bstream) != o3dgc::O3DGC_OK) throw DeadlyImportError("GLTF: can not decode Open3DGC data.");
|
||||
|
||||
// Set encoded region for bufferView.
|
||||
bufview->EncodedRegion_Mark(byte_offset, count, output_data, output_data_size, name);
|
||||
// Ans set is current
|
||||
bufview->EncodedRegion_SetCurrent(name);
|
||||
// Set encoded region for "buffer".
|
||||
buf->EncodedRegion_Mark(pCompression_Open3DGC.Offset, pCompression_Open3DGC.Count, decoded_data, decoded_data_size, id);
|
||||
// No. Do not delete "output_data". After calling "EncodedRegion_Mark" bufferView is owner of "output_data".
|
||||
// "delete [] output_data;"
|
||||
}
|
||||
|
|
|
|||
|
|
@ -224,6 +224,11 @@ namespace glTF {
|
|||
json_comp_data.AddMember("componentType", 5121, w.mAl);
|
||||
json_comp_data.AddMember("type", "SCALAR", w.mAl);
|
||||
json_comp_data.AddMember("count", ptr_ext_comp->Count, w.mAl);
|
||||
if(ptr_ext_comp->Binary)
|
||||
json_comp_data.AddMember("mode", "binary", w.mAl);
|
||||
else
|
||||
json_comp_data.AddMember("mode", "ascii", w.mAl);
|
||||
|
||||
json_comp_data.AddMember("indicesCount", ptr_ext_comp->IndicesCount, w.mAl);
|
||||
json_comp_data.AddMember("verticesCount", ptr_ext_comp->VerticesCount, w.mAl);
|
||||
// filling object "Open3DGC-compression"
|
||||
|
|
@ -237,7 +242,7 @@ namespace glTF {
|
|||
|
||||
break;
|
||||
default:
|
||||
throw DeadlyImportError("GLTF: Unknown mesh extension, Only Open3DGC is supported.");
|
||||
throw DeadlyImportError("GLTF: Can not write mesh: unknown mesh extension, only Open3DGC is supported.");
|
||||
}// switch(ptr_ext->Type)
|
||||
}// for(Mesh::SExtension* ptr_ext : m.Extension)
|
||||
|
||||
|
|
|
|||
|
|
@ -261,7 +261,7 @@ void glTFExporter::ExportMeshes()
|
|||
// using IndicesType = decltype(aiFace::mNumIndices);
|
||||
// But yes for
|
||||
// using IndicesType = unsigned short;
|
||||
// because "ComponentType_UNSIGNED_SHORT" used for indices. And its maximal type according to glTF specification.
|
||||
// because "ComponentType_UNSIGNED_SHORT" used for indices. And it's a maximal type according to glTF specification.
|
||||
using IndicesType = unsigned short;
|
||||
|
||||
// Variables needed for compression. BEGIN.
|
||||
|
|
@ -273,18 +273,26 @@ size_t idx_srcdata_ind;// Index of begin of coordinates indices array in buffer.
|
|||
bool comp_allow;// Point that data of current mesh can be compressed.
|
||||
// Variables needed for compression. END.
|
||||
|
||||
for (unsigned int i = 0; i < mScene->mNumMeshes; ++i) {
|
||||
const aiMesh* aim = mScene->mMeshes[i];
|
||||
for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) {
|
||||
const aiMesh* aim = mScene->mMeshes[idx_mesh];
|
||||
|
||||
// Check if compressing requested and mesh can be encoded.
|
||||
if((aim->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) && (aim->mNumVertices > 0))///TODO: export properties if(compression is needed)
|
||||
comp_allow = mProperties->GetPropertyBool("extensions.Open3DGC.use", false);
|
||||
if(comp_allow && (aim->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) && (aim->mNumVertices > 0) && (aim->mNumFaces > 0))
|
||||
{
|
||||
comp_allow = true;
|
||||
idx_srcdata_tc.clear();
|
||||
idx_srcdata_tc.reserve(AI_MAX_NUMBER_OF_TEXTURECOORDS);
|
||||
}
|
||||
else
|
||||
{
|
||||
comp_allow = false;
|
||||
std::string msg;
|
||||
|
||||
if(aim->mPrimitiveTypes != aiPrimitiveType_TRIANGLE)
|
||||
msg = "all primitives of the mesh must be a triangles.";
|
||||
else
|
||||
msg = "mesh must has vertices and faces.";
|
||||
|
||||
DefaultLogger::get()->warn("GLTF: can not use Open3DGC-compression: " + msg);
|
||||
}
|
||||
|
||||
std::string meshId = mAsset->FindUniqueID(aim->mName.C_Str(), "mesh");
|
||||
|
|
@ -367,28 +375,30 @@ bool comp_allow;// Point that data of current mesh can be compressed.
|
|||
//
|
||||
// Fill data for encoder.
|
||||
//
|
||||
unsigned qcoord = 12;///TODO: dbg
|
||||
unsigned qnormal = 10;///TODO: dbg
|
||||
unsigned qtexCoord = 10;///TODO: dbg
|
||||
// Quantization
|
||||
unsigned quant_coord = mProperties->GetPropertyInteger("extensions.Open3DGC.quantization.POSITION", 12);
|
||||
unsigned quant_normal = mProperties->GetPropertyInteger("extensions.Open3DGC.quantization.NORMAL", 10);
|
||||
unsigned quant_texcoord = mProperties->GetPropertyInteger("extensions.Open3DGC.quantization.TEXCOORD", 10);
|
||||
|
||||
o3dgc::O3DGCSC3DMCPredictionMode positionPrediction = o3dgc::O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION;///TODO: dbg
|
||||
o3dgc::O3DGCSC3DMCPredictionMode normalPrediction = o3dgc::O3DGC_SC3DMC_SURF_NORMALS_PREDICTION;///TODO: dbg
|
||||
o3dgc::O3DGCSC3DMCPredictionMode texcoordPrediction = o3dgc::O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION;///TODO: dbg
|
||||
// Prediction
|
||||
o3dgc::O3DGCSC3DMCPredictionMode prediction_position = o3dgc::O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION;
|
||||
o3dgc::O3DGCSC3DMCPredictionMode prediction_normal = o3dgc::O3DGC_SC3DMC_SURF_NORMALS_PREDICTION;
|
||||
o3dgc::O3DGCSC3DMCPredictionMode prediction_texcoord = o3dgc::O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION;
|
||||
|
||||
// IndexedFacesSet: "Crease angle", "solid", "convex" are set to default.
|
||||
comp_o3dgc_ifs.SetCCW(true);
|
||||
comp_o3dgc_ifs.SetIsTriangularMesh(true);
|
||||
comp_o3dgc_ifs.SetNumFloatAttributes(0);
|
||||
// Coordinates
|
||||
comp_o3dgc_params.SetCoordQuantBits(qcoord);///TODO: IME
|
||||
comp_o3dgc_params.SetCoordPredMode(positionPrediction);///TODO: IME
|
||||
comp_o3dgc_params.SetCoordQuantBits(quant_coord);
|
||||
comp_o3dgc_params.SetCoordPredMode(prediction_position);
|
||||
comp_o3dgc_ifs.SetNCoord(aim->mNumVertices);
|
||||
comp_o3dgc_ifs.SetCoord((o3dgc::Real* const)&b->GetPointer()[idx_srcdata_begin]);
|
||||
// Normals
|
||||
if(idx_srcdata_normal != SIZE_MAX)
|
||||
{
|
||||
comp_o3dgc_params.SetNormalQuantBits(qnormal);///TODO: IME
|
||||
comp_o3dgc_params.SetNormalPredMode(normalPrediction);///TODO: IME
|
||||
comp_o3dgc_params.SetNormalQuantBits(quant_normal);
|
||||
comp_o3dgc_params.SetNormalPredMode(prediction_normal);
|
||||
comp_o3dgc_ifs.SetNNormal(aim->mNumVertices);
|
||||
comp_o3dgc_ifs.SetNormal((o3dgc::Real* const)&b->GetPointer()[idx_srcdata_normal]);
|
||||
}
|
||||
|
|
@ -398,10 +408,10 @@ bool comp_allow;// Point that data of current mesh can be compressed.
|
|||
{
|
||||
size_t num = comp_o3dgc_ifs.GetNumFloatAttributes();
|
||||
|
||||
comp_o3dgc_params.SetFloatAttributeQuantBits(num, qtexCoord);///TODO: IME
|
||||
comp_o3dgc_params.SetFloatAttributePredMode(num, texcoordPrediction);///TODO: IME
|
||||
comp_o3dgc_params.SetFloatAttributeQuantBits(num, quant_texcoord);
|
||||
comp_o3dgc_params.SetFloatAttributePredMode(num, prediction_texcoord);
|
||||
comp_o3dgc_ifs.SetNFloatAttribute(num, aim->mNumVertices);// number of elements.
|
||||
comp_o3dgc_ifs.SetFloatAttributeDim(num, aim->mNumUVComponents[i]);// components per element: aiVector3D => x * float
|
||||
comp_o3dgc_ifs.SetFloatAttributeDim(num, aim->mNumUVComponents[num_tc]);// components per element: aiVector3D => x * float
|
||||
comp_o3dgc_ifs.SetFloatAttributeType(num, o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD);
|
||||
comp_o3dgc_ifs.SetFloatAttribute(num, (o3dgc::Real* const)&b->GetPointer()[idx_srcdata_tc[num_tc]]);
|
||||
comp_o3dgc_ifs.SetNumFloatAttributes(num + 1);
|
||||
|
|
@ -412,7 +422,12 @@ bool comp_allow;// Point that data of current mesh can be compressed.
|
|||
comp_o3dgc_ifs.SetCoordIndex((IndicesType* const)&b->GetPointer()[idx_srcdata_ind]);
|
||||
// Prepare to enconding
|
||||
comp_o3dgc_params.SetNumFloatAttributes(comp_o3dgc_ifs.GetNumFloatAttributes());
|
||||
comp_o3dgc_params.SetStreamType(o3dgc::O3DGC_STREAM_TYPE_BINARY);///TODO: exporter params
|
||||
if(mProperties->GetPropertyBool("extensions.Open3DGC.binary", true))
|
||||
comp_o3dgc_params.SetStreamType(o3dgc::O3DGC_STREAM_TYPE_BINARY);
|
||||
else
|
||||
comp_o3dgc_params.SetStreamType(o3dgc::O3DGC_STREAM_TYPE_ASCII);
|
||||
|
||||
comp_o3dgc_ifs.ComputeMinMax(o3dgc::O3DGC_SC3DMC_MAX_ALL_DIMS);
|
||||
//
|
||||
// Encoding
|
||||
//
|
||||
|
|
@ -429,14 +444,13 @@ bool comp_allow;// Point that data of current mesh can be compressed.
|
|||
ext->Buffer = b->id;
|
||||
ext->Offset = idx_srcdata_begin;
|
||||
ext->Count = b->byteLength - idx_srcdata_begin;
|
||||
ext->IndicesCount = comp_o3dgc_ifs.GetNCoordIndex();
|
||||
ext->Binary = mProperties->GetPropertyBool("extensions.Open3DGC.binary");
|
||||
ext->IndicesCount = comp_o3dgc_ifs.GetNCoordIndex() * 3;
|
||||
ext->VerticesCount = comp_o3dgc_ifs.GetNCoord();
|
||||
// And assign to mesh.
|
||||
m->Extension.push_back(ext);
|
||||
}// if(comp_allow)
|
||||
}// for (unsigned int i = 0; i < mScene->mNumMeshes; ++i) {
|
||||
|
||||
///TODO: export properties if(compression is used)
|
||||
}
|
||||
|
||||
unsigned int glTFExporter::ExportNode(const aiNode* n)
|
||||
|
|
|
|||
|
|
@ -259,7 +259,36 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
|
|||
for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
|
||||
Mesh& mesh = r.meshes[m];
|
||||
|
||||
meshOffsets.push_back(k);
|
||||
// Check if mesh extensions is used
|
||||
if(mesh.Extension.size() > 0)
|
||||
{
|
||||
for(Mesh::SExtension* cur_ext : mesh.Extension)
|
||||
{
|
||||
if(cur_ext->Type == Mesh::SExtension::EType::Compression_Open3DGC)
|
||||
{
|
||||
// Limitations for meshes when using Open3DGC-compression.
|
||||
// It's a current limitation of sp... Specification have not this part still - about mesh compression. Why only one primitive?
|
||||
// Because glTF is very flexibly. But in fact it ugly flexible. Every primitive can has own set of accessors and accessors can
|
||||
// point to a-a-a-a-any part of buffer (thru bufferview ofcourse) and even to another buffer. We know that "Open3DGC-compression"
|
||||
// is applicable only to part of buffer. As we can't guaranty continuity of the data for decoder, we will limit quantity of primitives.
|
||||
// Yes indices, coordinates etc. still can br stored in different buffers, but with current specification it's a exporter problem.
|
||||
// Also primitive can has only one of "POSITION", "NORMAL" and less then "AI_MAX_NUMBER_OF_TEXTURECOORDS" of "TEXCOORD". All accessor
|
||||
// of primitive must point to one continuous region of the buffer.
|
||||
if(mesh.primitives.size() > 2) throw DeadlyImportError("GLTF: When using Open3DGC compression then only one primitive per mesh are allowed.");
|
||||
|
||||
Mesh::SCompression_Open3DGC* o3dgc_ext = (Mesh::SCompression_Open3DGC*)cur_ext;
|
||||
Ref<Buffer> buf = r.buffers.Get(o3dgc_ext->Buffer);
|
||||
|
||||
buf->EncodedRegion_SetCurrent(mesh.id);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw DeadlyImportError("GLTF: Can not import mesh: unknown mesh extension, only Open3DGC is supported.");
|
||||
}
|
||||
}
|
||||
}// if(mesh.Extension.size() > 0)
|
||||
|
||||
meshOffsets.push_back(k);
|
||||
k += unsigned(mesh.primitives.size());
|
||||
|
||||
for (unsigned int p = 0; p < mesh.primitives.size(); ++p) {
|
||||
|
|
@ -295,25 +324,13 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
|
|||
|
||||
Mesh::Primitive::Attributes& attr = prim.attributes;
|
||||
|
||||
// if "bufferView" of current accessor is containing encoded data then set ID of region.
|
||||
if(attr.position[0]->bufferView->EncodedRegion_List.size() > 0) attr.position[0]->bufferView->EncodedRegion_SetCurrent(mesh.name);
|
||||
|
||||
if (attr.position.size() > 0 && attr.position[0]) {
|
||||
aim->mNumVertices = attr.position[0]->count;
|
||||
attr.position[0]->ExtractData(aim->mVertices);
|
||||
}
|
||||
|
||||
// if "bufferView" of current accessor is containing encoded data then set ID of region.
|
||||
if(attr.normal[0]->bufferView->EncodedRegion_List.size() > 0) attr.normal[0]->bufferView->EncodedRegion_SetCurrent(mesh.name);
|
||||
|
||||
if (attr.normal.size() > 0 && attr.normal[0]) attr.normal[0]->ExtractData(aim->mNormals);
|
||||
|
||||
// if "bufferView" of current accessor is containing encoded data then set ID of region.
|
||||
if((attr.texcoord.size() > 0) && (attr.texcoord[0]->bufferView->EncodedRegion_List.size() > 0))
|
||||
{
|
||||
attr.texcoord[0]->bufferView->EncodedRegion_SetCurrent(mesh.name);
|
||||
}
|
||||
|
||||
for (size_t tc = 0; tc < attr.texcoord.size() && tc <= AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
|
||||
attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
|
||||
aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
|
||||
|
|
@ -326,9 +343,6 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
|
|||
|
||||
|
||||
if (prim.indices) {
|
||||
// if "bufferView" of current accessor is containing encoded data then set ID of region.
|
||||
if(prim.indices->bufferView->EncodedRegion_List.size() > 0) prim.indices->bufferView->EncodedRegion_SetCurrent(mesh.name);
|
||||
|
||||
aiFace* faces = 0;
|
||||
unsigned int nFaces = 0;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue