diff --git a/code/glTFAsset.h b/code/glTFAsset.h index 860ba8df0..3b3c513a2 100644 --- a/code/glTFAsset.h +++ b/code/glTFAsset.h @@ -543,6 +543,9 @@ namespace glTF /// 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; /// \var EncodedRegion_List diff --git a/code/glTFAsset.inl b/code/glTFAsset.inl index b9e5c6e13..40740bacc 100644 --- a/code/glTFAsset.inl +++ b/code/glTFAsset.inl @@ -820,6 +820,11 @@ uint32_t byte_offset, count, count_indices, count_vertices; const char* mode_str; const char* type_str; ComponentType component_type; +std::list float_attributes_indices;// See above about "floatAttributesIndexes". + + /**********************************************************/ + /************** 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 + "\"."); } @@ -835,6 +840,40 @@ ComponentType component_type; #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 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."); @@ -843,6 +882,10 @@ ComponentType component_type; 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 bufview = pAsset_Root.bufferViews.Get(bufview_id); @@ -851,10 +894,11 @@ ComponentType component_type; // // void testDecode(shared_ptr mesh, BinaryStream &bstream) o3dgc::SC3DMCDecoder decoder; - o3dgc::IndexedFaceSet ifs; + o3dgc::IndexedFaceSet ifs; uint8_t* output_data; - size_t size_vertex, size_normal, size_texcoord, size_indices, output_data_size; + size_t size_vertex, size_normal, size_indices, output_data_size; o3dgc::BinaryStream bstream; + float* tarrays[6]; // Read data from buffer and place it in BinaryStream for decoder. bstream.LoadFromBuffer(&bufview->buffer->GetPointer()[bufview->byteOffset + byte_offset], count); @@ -862,12 +906,43 @@ ComponentType component_type; // 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); - size_texcoord = ifs.GetNFloatAttribute(0) * 2 * sizeof(float); - size_indices = ifs.GetNCoordIndex() * 3 * sizeof(unsigned short); - output_data_size = size_vertex + size_normal + size_texcoord + size_indices; + for(size_t idx_attr = 0, idx_attr_end = ifs.GetNumFloatAttributes(); idx_attr < idx_attr_end; idx_attr++) + { + size_t qty_attr = ifs.GetNFloatAttribute(idx_attr); + + 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)) + { + // 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 + break; + default: + throw DeadlyImportError("GLTF: Unknown type of float attribute (" + std::to_string(idx_attr) + ") for Open3DGC encoding."); + }*/ + } + + //size_texcoord = ifs.GetNFloatAttribute(0) * 2 * sizeof(float); + + output_data_size = size_vertex + size_normal + /*size_texcoord*/ + size_indices; output_data = new uint8_t[output_data_size]; float* uncompressed_vertices = (float* const)(output_data + size_indices);// size_indices => vertex offset @@ -877,7 +952,7 @@ ComponentType component_type; if(ifs.GetNNormal() > 0) ifs.SetNormal((float* const)(output_data + size_indices + size_vertex)); - if(ifs.GetNFloatAttribute(0)) ifs.SetFloatAttribute(0, (float* const)(output_data + size_indices + size_vertex + size_normal)); + //if(ifs.GetNFloatAttribute(0)) ifs.SetFloatAttribute(0, (float* const)(output_data + size_indices + size_vertex + size_normal)); // Decode data if(decoder.DecodePlayload(ifs, bstream) != o3dgc::O3DGC_OK) throw DeadlyImportError("GLTF: can not decode Open3DGC data."); diff --git a/code/glTFExporter.cpp b/code/glTFExporter.cpp index 7f0c086cf..ff5c25675 100644 --- a/code/glTFExporter.cpp +++ b/code/glTFExporter.cpp @@ -1,4 +1,4 @@ -/* +/* Open Asset Import Library (assimp) ---------------------------------------------------------------------- @@ -55,10 +55,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include +// Header files, standart library. #include +#include #include "glTFAssetWriter.h" +// Header files, Open3DGC. +#include + using namespace rapidjson; using namespace Assimp; @@ -252,9 +257,36 @@ void glTFExporter::ExportMaterials() void glTFExporter::ExportMeshes() { +// Not for +// 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. +using IndicesType = unsigned short; + +// Variables needed for compression. BEGIN. +// Indices, not pointers - because pointer to buffer is changin while writing to it. +size_t idx_srcdata_begin;// Index of buffer before writing mesh data. Also, index of begin of coordinates array in buffer. +size_t idx_srcdata_normal = SIZE_MAX;// Index of begin of normals array in buffer. SIZE_MAX - mean that mesh has no normals. +std::vector idx_srcdata_tc;// Array of indices. Every index point to begin of texture coordinates array in buffer. +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]; + // 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 = true; + idx_srcdata_tc.reserve(AI_MAX_NUMBER_OF_TEXTURECOORDS); + } + else + { + comp_allow = false; + } + std::string meshId = mAsset->FindUniqueID(aim->mName.C_Str(), "mesh"); Ref m = mAsset->meshes.Create(meshId); m->primitives.resize(1); @@ -269,31 +301,46 @@ void glTFExporter::ExportMeshes() b = mAsset->buffers.Create(bufferId); } + /******************* Vertices ********************/ + // If compression is used then you need parameters of uncompressed region: begin and size. At this step "begin" is stored. + if(comp_allow) idx_srcdata_begin = b->byteLength; + Ref v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); - if (v) p.attributes.position.push_back(v); + if (v) p.attributes.position.push_back(v); - Ref n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); - if (n) p.attributes.normal.push_back(n); + /******************** Normals ********************/ + if(comp_allow && (aim->mNormals > 0)) idx_srcdata_normal = b->byteLength;// Store index of normals array. + Ref n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); + if (n) p.attributes.normal.push_back(n); + + /************** Texture coordinates **************/ for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { if (aim->mNumUVComponents[i] > 0) { AttribType::Value type = (aim->mNumUVComponents[i] == 2) ? AttribType::VEC2 : AttribType::VEC3; - Ref tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, true); - if (tc) p.attributes.texcoord.push_back(tc); - } - } - if (aim->mNumFaces > 0) { - unsigned int nIndicesPerFace = aim->mFaces[0].mNumIndices; - std::vector indices; + if(comp_allow) idx_srcdata_tc.push_back(b->byteLength);// Store index of texture coordinates array. + + Ref tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, true); + if (tc) p.attributes.texcoord.push_back(tc); + } + } + + /*************** Vertices indices ****************/ + idx_srcdata_ind = b->byteLength;// Store index of indices array. + + if (aim->mNumFaces > 0) { + std::vector indices; + unsigned int nIndicesPerFace = aim->mFaces[0].mNumIndices; indices.resize(aim->mNumFaces * nIndicesPerFace); for (size_t i = 0; i < aim->mNumFaces; ++i) { for (size_t j = 0; j < nIndicesPerFace; ++j) { indices[i*nIndicesPerFace + j] = uint16_t(aim->mFaces[i].mIndices[j]); } } - p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, true); - } + + p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, true); + } switch (aim->mPrimitiveTypes) { case aiPrimitiveType_POLYGON: @@ -305,7 +352,69 @@ void glTFExporter::ExportMeshes() default: // aiPrimitiveType_TRIANGLE p.mode = PrimitiveMode_TRIANGLES; } - } + + /****************** Compression ******************/ + ///TODO: animation: weights, joints. + if(comp_allow) + { + o3dgc::BinaryStream bs; + o3dgc::SC3DMCEncoder encoder; + o3dgc::IndexedFaceSet comp_o3dgc_ifs; + o3dgc::SC3DMCEncodeParams comp_o3dgc_params; + unsigned qcoord = 12;///TODO: dbg + unsigned qnormal = 10;///TODO: dbg + unsigned qtexCoord = 10;///TODO: dbg + + 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 + + // 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_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_ifs.SetNNormal(aim->mNumVertices); + comp_o3dgc_ifs.SetNormal((o3dgc::Real* const)&b->GetPointer()[idx_srcdata_normal]); + } + + // Texture coordinates + for(size_t num_tc = 0; num_tc < idx_srcdata_tc.size(); num_tc++) + { + 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_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.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); + } + + // Coordinates indices + comp_o3dgc_ifs.SetNCoordIndex(aim->mNumFaces); + 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 + // Encoding + encoder.Encode(comp_o3dgc_params, comp_o3dgc_ifs, bs); + + ///TODO: replace data in buffer + }// 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)