From 2fe07994d15fd3292fde5e58b9525e8372c3c74c Mon Sep 17 00:00:00 2001 From: Mayank Nagpal Date: Mon, 5 Jul 2021 13:57:56 +0530 Subject: [PATCH] Add Sparse Accessor Support --- src/FBX2glTF.cpp | 19 ++- src/FBX2glTF.h | 36 +++--- src/gltf/GltfModel.hpp | 55 +++++++-- src/gltf/Raw2Gltf.cpp | 155 +++++++++++++++++++++---- src/gltf/properties/AccessorData.cpp | 31 ++++- src/gltf/properties/AccessorData.hpp | 45 ++++--- src/gltf/properties/BufferViewData.hpp | 16 +++ 7 files changed, 275 insertions(+), 82 deletions(-) diff --git a/src/FBX2glTF.cpp b/src/FBX2glTF.cpp index 3cdfecf..0b85ff1 100644 --- a/src/FBX2glTF.cpp +++ b/src/FBX2glTF.cpp @@ -142,6 +142,11 @@ int main(int argc, char* argv[]) { gltfOptions.enableUserProperties, "Transcribe FBX User Properties into glTF node and material 'extras'."); + app.add_flag( + "--blend-shape-no-sparse", + gltfOptions.disableSparseBlendShapes, + "Don't use sparse accessors to store blend shapes"); + app.add_flag( "--blend-shape-normals", gltfOptions.useBlendShapeNormals, @@ -159,17 +164,17 @@ int main(int argc, char* argv[]) { true); app.add_option( - "--skinning-weights", - gltfOptions.maxSkinningWeights, - "The number of joint influences per vertex.", - true) + "--skinning-weights", + gltfOptions.maxSkinningWeights, + "The number of joint influences per vertex.", + true) ->check(CLI::Range(0, 512)); app.add_option( "-k,--keep-attribute", [&](std::vector attributes) -> bool { gltfOptions.keepAttribs = - RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS; + RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS; for (std::string attribute : attributes) { if (attribute == "position") { gltfOptions.keepAttribs |= RAW_VERTEX_ATTRIBUTE_POSITION; @@ -250,7 +255,9 @@ int main(int argc, char* argv[]) { ->check(CLI::Range(1, 32)) ->group("Draco"); - app.add_option("--fbx-temp-dir", gltfOptions.fbxTempDir, "Temporary directory to be used by FBX SDK.")->check(CLI::ExistingDirectory); + app.add_option( + "--fbx-temp-dir", gltfOptions.fbxTempDir, "Temporary directory to be used by FBX SDK.") + ->check(CLI::ExistingDirectory); CLI11_PARSE(app, argc, argv); diff --git a/src/FBX2glTF.h b/src/FBX2glTF.h index f034790..abdcab3 100644 --- a/src/FBX2glTF.h +++ b/src/FBX2glTF.h @@ -112,21 +112,23 @@ struct GltfOptions { /** Whether to include lights through the KHR_punctual_lights extension. */ bool useKHRLightsPunctual{true}; - /** Whether to include blend shape normals, if present according to the SDK. */ - bool useBlendShapeNormals { false }; - /** Whether to include blend shape tangents, if present according to the SDK. */ - bool useBlendShapeTangents { false }; - /** Whether to normalized skinning weights. */ - bool normalizeSkinningWeights { true }; - /** Maximum number of bone influences per vertex. */ - int maxSkinningWeights { 8 }; - /** When to compute vertex normals from geometry. */ - ComputeNormalsOption computeNormals = ComputeNormalsOption::BROKEN; - /** When to use 32-bit indices. */ - UseLongIndicesOptions useLongIndices = UseLongIndicesOptions::AUTO; - /** Select baked animation framerate. */ - AnimationFramerateOptions animationFramerate = AnimationFramerateOptions::BAKE30; - - /** Temporary directory used by FBX SDK. */ - std::string fbxTempDir; + /** Whether to not use sparse accessors in blend shapes */ + bool disableSparseBlendShapes{false}; + /** Whether to include blend shape normals, if present according to the SDK. */ + bool useBlendShapeNormals{false}; + /** Whether to include blend shape tangents, if present according to the SDK. */ + bool useBlendShapeTangents{false}; + /** Whether to normalized skinning weights. */ + bool normalizeSkinningWeights{true}; + /** Maximum number of bone influences per vertex. */ + int maxSkinningWeights{8}; + /** When to compute vertex normals from geometry. */ + ComputeNormalsOption computeNormals = ComputeNormalsOption::BROKEN; + /** When to use 32-bit indices. */ + UseLongIndicesOptions useLongIndices = UseLongIndicesOptions::AUTO; + /** Select baked animation framerate. */ + AnimationFramerateOptions animationFramerate = AnimationFramerateOptions::BAKE30; + + /** Temporary directory used by FBX SDK. */ + std::string fbxTempDir; }; diff --git a/src/gltf/GltfModel.hpp b/src/gltf/GltfModel.hpp index 48939db..0c4f40e 100644 --- a/src/gltf/GltfModel.hpp +++ b/src/gltf/GltfModel.hpp @@ -69,6 +69,12 @@ class GltfModel { BufferData& buffer, const std::string& filename); + template + void + CopyToBufferView(BufferViewData& bufferView, const std::vector& source, const GLType& type) { + bufferView.appendAsBinaryArray(source, *binary, type); + } + template std::shared_ptr AddAccessorWithView( BufferViewData& bufferView, @@ -76,8 +82,42 @@ class GltfModel { const std::vector& source, std::string name) { auto accessor = accessors.hold(new AccessorData(bufferView, type, name)); - accessor->appendAsBinaryArray(source, *binary); - bufferView.byteLength = accessor->byteLength(); + bufferView.appendAsBinaryArray(source, *binary, type); + accessor->count = bufferView.count; + return accessor; + } + + template + std::shared_ptr AddSparseAccessorWithView( + AccessorData& baseAccessor, + BufferViewData& indexBufferView, + const GLType& indexBufferViewType, + BufferViewData& bufferView, + const GLType& type, + const std::vector& source, + std::string name) { + auto accessor = + accessors.hold(new AccessorData(baseAccessor, indexBufferView, bufferView, type, name)); + bufferView.appendAsBinaryArray(source, *binary, type); + accessor->count = baseAccessor.count; + accessor->sparseIdxBufferViewType = indexBufferViewType.componentType.glType; + return accessor; + } + + // template + std::shared_ptr AddSparseAccessor( + AccessorData& baseAccessor, + BufferViewData& indexBufferView, + const GLType& indexBufferViewType, + BufferViewData& bufferView, + const GLType& type, + // const std::vector& source, + std::string name) { + auto accessor = + accessors.hold(new AccessorData(baseAccessor, indexBufferView, bufferView, type, name)); + // bufferView.appendAsBinaryArray(source, *binary, type); + accessor->count = baseAccessor.count; + accessor->sparseIdxBufferViewType = indexBufferViewType.componentType.glType; return accessor; } @@ -124,10 +164,10 @@ class GltfModel { template std::shared_ptr AddAttributeArrayToPrimitive( - BufferData& buffer, - const RawModel& surfaceModel, - PrimitiveData& primitive, - const AttributeArrayDefinition& attrDef) { + BufferData& buffer, + const RawModel& surfaceModel, + PrimitiveData& primitive, + const AttributeArrayDefinition& attrDef) { // copy attribute data into vector std::vector attribArr; surfaceModel.GetArrayAttributeArray(attribArr, attrDef.rawAttributeIx, attrDef.arrayOffset); @@ -138,8 +178,7 @@ class GltfModel { accessor = accessors.hold(new AccessorData(attrDef.glType)); accessor->count = attribArr.size(); - } - else { + } else { auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER); accessor = AddAccessorWithView(*bufferView, attrDef.glType, attribArr, std::string("")); } diff --git a/src/gltf/Raw2Gltf.cpp b/src/gltf/Raw2Gltf.cpp index 2d3ddf2..a6cc579 100644 --- a/src/gltf/Raw2Gltf.cpp +++ b/src/gltf/Raw2Gltf.cpp @@ -470,6 +470,9 @@ ModelData* Raw2Gltf( surfaceModel.GetMaterial(surfaceModel.GetTriangle(0).materialIndex); const MaterialData& mData = require(materialsById, rawMaterial.id); + if (verboseOutput) + fmt::printf("\rMaterial Name: %s\n", mData.name); + MeshData* mesh = nullptr; auto meshIter = meshBySurfaceId.find(surfaceId); if (meshIter != meshBySurfaceId.end()) { @@ -522,6 +525,16 @@ ModelData* Raw2Gltf( // // surface vertices // + // Base Accessors needed for Sparse Accessors + std::shared_ptr pAccBase; + std::shared_ptr nAccBase; + std::shared_ptr tAccBase; + + // Sparse accessors cannot be zero length, but morph targets can easily have + // no modified vertices in multiprim meshes. In order to utilise sparse accessors + // in this case, we need a couple of single element dummy buffer views to reference. + std::shared_ptr dummyIdxView; + std::shared_ptr dummyDataView; { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_POSITION) != 0) { const AttributeDefinition ATTR_POSITION( @@ -535,6 +548,8 @@ ModelData* Raw2Gltf( accessor->min = toStdVec(rawSurface.bounds.min); accessor->max = toStdVec(rawSurface.bounds.max); + + pAccBase = accessor; } if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_NORMAL) != 0) { const AttributeDefinition ATTR_NORMAL( @@ -545,11 +560,13 @@ ModelData* Raw2Gltf( draco::DT_FLOAT32); const auto _ = gltf->AddAttributeToPrimitive(buffer, surfaceModel, *primitive, ATTR_NORMAL); + nAccBase = _; } if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_TANGENT) != 0) { const AttributeDefinition ATTR_TANGENT("TANGENT", &RawVertex::tangent, GLT_VEC4F); const auto _ = gltf->AddAttributeToPrimitive(buffer, surfaceModel, *primitive, ATTR_TANGENT); + tAccBase = _; } if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_COLOR) != 0) { const AttributeDefinition ATTR_COLOR( @@ -617,43 +634,133 @@ ModelData* Raw2Gltf( std::vector positions, normals; std::vector tangents; + + std::vector sparseIndices; + for (int jj = 0; jj < surfaceModel.GetVertexCount(); jj++) { auto blendVertex = surfaceModel.GetVertex(jj).blends[channelIx]; shapeBounds.AddPoint(blendVertex.position); - positions.push_back(blendVertex.position); - if (options.useBlendShapeTangents && channel.hasNormals) { - normals.push_back(blendVertex.normal); + bool isSparseVertex = options.disableSparseBlendShapes; // If sparse is off, add all vertices + // Check to see whether position, normal or tangent deviates from base mesh and flag as + // sparse. + if (blendVertex.position.Length() > 0.00) { + isSparseVertex = true; } - if (options.useBlendShapeTangents && channel.hasTangents) { - tangents.push_back(blendVertex.tangent); +// if (options.useBlendShapeNormals && channel.hasNormals && +// blendVertex.normal.Length() > 0.00) { +// isSparseVertex = true; +// } +// if (options.useBlendShapeTangents && channel.hasTangents && +// blendVertex.tangent.Length() > 0.00) { +// isSparseVertex = true; +// } + if (isSparseVertex == true) { + sparseIndices.push_back(jj); + positions.push_back(blendVertex.position); + if (options.useBlendShapeNormals && channel.hasNormals) { + normals.push_back(blendVertex.normal); + } + if (options.useBlendShapeTangents && channel.hasTangents) { + tangents.push_back(blendVertex.tangent); + } } } - std::shared_ptr pAcc = gltf->AddAccessorWithView( - *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), - GLT_VEC3F, - positions, - channel.name); - pAcc->min = toStdVec(shapeBounds.min); - pAcc->max = toStdVec(shapeBounds.max); + std::shared_ptr pAcc; std::shared_ptr nAcc; - if (!normals.empty()) { - nAcc = gltf->AddAccessorWithView( + std::shared_ptr tAcc; + if (!options.disableSparseBlendShapes) { + if (verboseOutput) + fmt::printf( + "\rChannel Name: %-50s Sparse Count: %d\n", channel.name, sparseIndices.size()); + + if (sparseIndices.size() == 0) { + // Initalize dummy bufferviews if needed + if (!dummyIdxView) { + std::vector dummyIndices; + dummyIndices.push_back(int(0)); + + dummyIdxView = gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE); + gltf->CopyToBufferView( + *dummyIdxView, dummyIndices, useLongIndices ? GLT_UINT : GLT_USHORT); + } + + if (!dummyDataView) { + std::vector dummyData; + dummyData.push_back(Vec3f(0.0)); + + dummyDataView = gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE); + dummyDataView->appendAsBinaryArray(dummyData, *gltf->binary, GLT_VEC3F); + } + + // Set up sparse accessor with dummy buffer views + pAcc = gltf->AddSparseAccessor( + *pAccBase, + *dummyIdxView, + useLongIndices ? GLT_UINT : GLT_USHORT, + *dummyDataView, + GLT_VEC3F, + channel.name); + } else { + // Build Orphan Bufferview for Sparse Indices + std::shared_ptr indexBufferView = + gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE); + gltf->CopyToBufferView( + *indexBufferView, sparseIndices, useLongIndices ? GLT_UINT : GLT_USHORT); + + pAcc = gltf->AddSparseAccessorWithView( + *pAccBase, + *indexBufferView, + useLongIndices ? GLT_UINT : GLT_USHORT, + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE), + GLT_VEC3F, + positions, + channel.name); + if (!normals.empty()) { + nAcc = gltf->AddSparseAccessorWithView( + *nAccBase, + *indexBufferView, + useLongIndices ? GLT_UINT : GLT_USHORT, + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE), + GLT_VEC3F, + normals, + channel.name); + } + if (!tangents.empty()) { + tAcc = gltf->AddSparseAccessorWithView( + *nAccBase, + *indexBufferView, + useLongIndices ? GLT_UINT : GLT_USHORT, + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE), + GLT_VEC4F, + tangents, + channel.name); + } + } + } else { + pAcc = gltf->AddAccessorWithView( *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), GLT_VEC3F, - normals, - channel.name); - } - - std::shared_ptr tAcc; - if (!tangents.empty()) { - nAcc = gltf->AddAccessorWithView( - *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), - GLT_VEC4F, - tangents, + positions, channel.name); + if (!normals.empty()) { + nAcc = gltf->AddAccessorWithView( + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), + GLT_VEC3F, + normals, + channel.name); + } + if (!tangents.empty()) { + nAcc = gltf->AddAccessorWithView( + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), + GLT_VEC4F, + tangents, + channel.name); + } } + pAcc->min = toStdVec(shapeBounds.min); + pAcc->max = toStdVec(shapeBounds.max); primitive->AddTarget(pAcc.get(), nAcc.get(), tAcc.get()); } } diff --git a/src/gltf/properties/AccessorData.cpp b/src/gltf/properties/AccessorData.cpp index 3626c4e..4dcf1c6 100644 --- a/src/gltf/properties/AccessorData.cpp +++ b/src/gltf/properties/AccessorData.cpp @@ -15,7 +15,23 @@ AccessorData::AccessorData(const BufferViewData& bufferView, GLType type, std::s type(std::move(type)), byteOffset(0), count(0), - name(name) {} + name(name), + sparse(false) {} + +AccessorData::AccessorData(const AccessorData& baseAccessor, const BufferViewData& sparseIdxBufferView, const BufferViewData& sparseDataBufferView, GLType type, std::string name) + : Holdable(), + bufferView(baseAccessor.bufferView), + type(std::move(type)), + byteOffset(baseAccessor.byteOffset), + count(baseAccessor.count), + name(name), + sparse(true), + sparseIdxCount(sparseIdxBufferView.count), + sparseIdxBufferView(sparseIdxBufferView.ix), + sparseIdxBufferViewOffset(0), + sparseIdxBufferViewType(0), + sparseDataBufferView(sparseDataBufferView.ix), + sparseDataBufferViewOffset(0) {} AccessorData::AccessorData(GLType type) : Holdable(), bufferView(-1), type(std::move(type)), byteOffset(0), count(0) {} @@ -23,7 +39,7 @@ AccessorData::AccessorData(GLType type) json AccessorData::serialize() const { json result{ {"componentType", type.componentType.glType}, {"type", type.dataType}, {"count", count}}; - if (bufferView >= 0) { + if (bufferView >= 0 && !sparse) { result["bufferView"] = bufferView; result["byteOffset"] = byteOffset; } @@ -33,6 +49,17 @@ json AccessorData::serialize() const { if (!max.empty()) { result["max"] = max; } + if (sparse) { + json sparseData = {{"count", sparseIdxCount}}; + sparseData["indices"] = { {"bufferView", sparseIdxBufferView}, + {"byteOffset", sparseIdxBufferViewOffset}, + {"componentType", sparseIdxBufferViewType}}; + + sparseData["values"] = { {"bufferView", sparseDataBufferView}, + {"byteOffset", sparseDataBufferViewOffset}}; + + result["sparse"] = sparseData; + } if (name.length() > 0) { result["name"] = name; } diff --git a/src/gltf/properties/AccessorData.hpp b/src/gltf/properties/AccessorData.hpp index 5a72e70..78304d5 100644 --- a/src/gltf/properties/AccessorData.hpp +++ b/src/gltf/properties/AccessorData.hpp @@ -11,35 +11,30 @@ #include "gltf/Raw2Gltf.hpp" struct AccessorData : Holdable { - AccessorData(const BufferViewData& bufferView, GLType type, std::string name); - explicit AccessorData(GLType type); + AccessorData(const BufferViewData& bufferView, GLType type, std::string name); + explicit AccessorData(GLType type); + AccessorData(const AccessorData& baseAccessor, const BufferViewData& sparseIdxBufferView, const BufferViewData& sparseDataBufferView, GLType type, std::string name); - json serialize() const override; + json serialize() const override; - template - void appendAsBinaryArray(const std::vector& in, std::vector& out) { - const unsigned int stride = type.byteStride(); - const size_t offset = out.size(); - const size_t count = in.size(); - - this->count = (unsigned int)count; - - out.resize(offset + count * stride); - for (int ii = 0; ii < count; ii++) { - type.write(&out[offset + ii * stride], in[ii]); + unsigned int byteLength() const { + return type.byteStride() * count; } - } - unsigned int byteLength() const { - return type.byteStride() * count; - } + const int bufferView; + const GLType type; - const int bufferView; - const GLType type; + unsigned int byteOffset; + unsigned int count; + std::vector min; + std::vector max; + std::string name; - unsigned int byteOffset; - unsigned int count; - std::vector min; - std::vector max; - std::string name; + bool sparse; + int sparseIdxCount; + int sparseIdxBufferView; + int sparseIdxBufferViewOffset; + int sparseIdxBufferViewType; + int sparseDataBufferView; + int sparseDataBufferViewOffset; }; diff --git a/src/gltf/properties/BufferViewData.hpp b/src/gltf/properties/BufferViewData.hpp index 8e85cc5..d887684 100644 --- a/src/gltf/properties/BufferViewData.hpp +++ b/src/gltf/properties/BufferViewData.hpp @@ -21,9 +21,25 @@ struct BufferViewData : Holdable { json serialize() const override; + template + void appendAsBinaryArray(const std::vector& in, std::vector& out, GLType type) { + const unsigned int stride = type.byteStride(); + const size_t offset = out.size(); + const size_t count = in.size(); + + this->byteLength = stride * count; + this->count = count; + + out.resize(offset + count * stride); + for (int ii = 0; ii < count; ii++) { + type.write(&out[offset + ii * stride], in[ii]); + } + } + const unsigned int buffer; const unsigned int byteOffset; const GL_ArrayType target; + unsigned int count = 0; unsigned int byteLength = 0; };