Add Sparse Accessor Support

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",
+         "--skinning-weights",
-      gltfOptions.maxSkinningWeights,
+         gltfOptions.maxSkinningWeights,
-      "The number of joint influences per vertex.",
+         "The number of joint influences per vertex.",
-      true)
+         true)
       ->check(CLI::Range(0, 512));
 
   app.add_option(
          "-k,--keep-attribute",
          [&](std::vector<std::string> 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);
 

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. */
+  /** Whether to not use sparse accessors in blend shapes */
-    bool useBlendShapeNormals { false };
+  bool disableSparseBlendShapes{false};
-    /** Whether to include blend shape tangents, if present according to the SDK. */
+  /** Whether to include blend shape normals, if present according to the SDK. */
-    bool useBlendShapeTangents { false };
+  bool useBlendShapeNormals{false};
-    /** Whether to normalized skinning weights. */
+  /** Whether to include blend shape tangents, if present according to the SDK. */
-    bool normalizeSkinningWeights { true };
+  bool useBlendShapeTangents{false};
-    /** Maximum number of bone influences per vertex. */
+  /** Whether to normalized skinning weights. */
-    int maxSkinningWeights { 8 };
+  bool normalizeSkinningWeights{true};
-    /** When to compute vertex normals from geometry. */
+  /** Maximum number of bone influences per vertex. */
-    ComputeNormalsOption computeNormals = ComputeNormalsOption::BROKEN;
+  int maxSkinningWeights{8};
-    /** When to use 32-bit indices. */
+  /** When to compute vertex normals from geometry. */
-    UseLongIndicesOptions useLongIndices = UseLongIndicesOptions::AUTO;
+  ComputeNormalsOption computeNormals = ComputeNormalsOption::BROKEN;
-    /** Select baked animation framerate. */    
+  /** When to use 32-bit indices. */
-    AnimationFramerateOptions animationFramerate = AnimationFramerateOptions::BAKE30;
+  UseLongIndicesOptions useLongIndices = UseLongIndicesOptions::AUTO;
+  /** Select baked animation framerate. */
+  AnimationFramerateOptions animationFramerate = AnimationFramerateOptions::BAKE30;
 
-    /** Temporary directory used by FBX SDK. */
+  /** Temporary directory used by FBX SDK. */
-    std::string fbxTempDir;   
+  std::string fbxTempDir;
 };

src/gltf/GltfModel.hpp

@@ -69,6 +69,12 @@ class GltfModel {
       BufferData& buffer,
       const std::string& filename);
 
+  template <class T>
+  void
+  CopyToBufferView(BufferViewData& bufferView, const std::vector<T>& source, const GLType& type) {
+    bufferView.appendAsBinaryArray(source, *binary, type);
+  }
+
   template <class T>
   std::shared_ptr<AccessorData> AddAccessorWithView(
       BufferViewData& bufferView,
@@ -76,8 +82,42 @@ class GltfModel {
       const std::vector<T>& source,
       std::string name) {
     auto accessor = accessors.hold(new AccessorData(bufferView, type, name));
-    accessor->appendAsBinaryArray(source, *binary);
+    bufferView.appendAsBinaryArray(source, *binary, type);
-    bufferView.byteLength = accessor->byteLength();
+    accessor->count = bufferView.count;
+    return accessor;
+  }
+
+  template <class T>
+  std::shared_ptr<AccessorData> AddSparseAccessorWithView(
+      AccessorData& baseAccessor,
+      BufferViewData& indexBufferView,
+      const GLType& indexBufferViewType,
+      BufferViewData& bufferView,
+      const GLType& type,
+      const std::vector<T>& 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 <class T>
+  std::shared_ptr<AccessorData> AddSparseAccessor(
+      AccessorData& baseAccessor,
+      BufferViewData& indexBufferView,
+      const GLType& indexBufferViewType,
+      BufferViewData& bufferView,
+      const GLType& type,
+      //      const std::vector<T>& 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 <class T>
   std::shared_ptr<AccessorData> AddAttributeArrayToPrimitive(
-    BufferData& buffer,
+      BufferData& buffer,
-    const RawModel& surfaceModel,
+      const RawModel& surfaceModel,
-    PrimitiveData& primitive,
+      PrimitiveData& primitive,
-    const AttributeArrayDefinition<T>& attrDef) {
+      const AttributeArrayDefinition<T>& attrDef) {
     // copy attribute data into vector
     std::vector<T> attribArr;
     surfaceModel.GetArrayAttributeArray<T>(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(""));
     }

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<AccessorData> pAccBase;
+      std::shared_ptr<AccessorData> nAccBase;
+      std::shared_ptr<AccessorData> 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<BufferViewData> dummyIdxView;
+      std::shared_ptr<BufferViewData> dummyDataView;
       {
         if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_POSITION) != 0) {
           const AttributeDefinition<Vec3f> 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<Vec3f> ATTR_NORMAL(
@@ -545,11 +560,13 @@ ModelData* Raw2Gltf(
               draco::DT_FLOAT32);
           const auto _ =
               gltf->AddAttributeToPrimitive<Vec3f>(buffer, surfaceModel, *primitive, ATTR_NORMAL);
+          nAccBase = _;
         }
         if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_TANGENT) != 0) {
           const AttributeDefinition<Vec4f> ATTR_TANGENT("TANGENT", &RawVertex::tangent, GLT_VEC4F);
           const auto _ =
               gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_TANGENT);
+          tAccBase = _;
         }
         if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_COLOR) != 0) {
           const AttributeDefinition<Vec4f> ATTR_COLOR(
@@ -617,43 +634,133 @@ ModelData* Raw2Gltf(
 
           std::vector<Vec3f> positions, normals;
           std::vector<Vec4f> tangents;
+
+          std::vector<TriangleIndex> 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);
+            bool isSparseVertex = options.disableSparseBlendShapes; // If sparse is off, add all vertices
-            if (options.useBlendShapeTangents && channel.hasNormals) {
+            // Check to see whether position, normal or tangent deviates from base mesh and flag as
-              normals.push_back(blendVertex.normal);
+            // sparse.
+            if (blendVertex.position.Length() > 0.00) {
+              isSparseVertex = true;
             }
-            if (options.useBlendShapeTangents && channel.hasTangents) {
+//            if (options.useBlendShapeNormals && channel.hasNormals &&
-              tangents.push_back(blendVertex.tangent);
+//                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<AccessorData> 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<AccessorData> pAcc;
           std::shared_ptr<AccessorData> nAcc;
-          if (!normals.empty()) {
+          std::shared_ptr<AccessorData> tAcc;
-            nAcc = gltf->AddAccessorWithView(
+          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<TriangleIndex> 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<Vec3f> 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<BufferViewData> 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,
+                positions,
-                channel.name);
-          }
-
-          std::shared_ptr<AccessorData> tAcc;
-          if (!tangents.empty()) {
-            nAcc = gltf->AddAccessorWithView(
-                *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
-                GLT_VEC4F,
-                tangents,
                 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());
         }
       }

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;
   }

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);
+    AccessorData(const BufferViewData& bufferView, GLType type, std::string name);
-  explicit AccessorData(GLType type);
+    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 <class T>
+    unsigned int byteLength() const {
-  void appendAsBinaryArray(const std::vector<T>& in, std::vector<uint8_t>& out) {
+        return type.byteStride() * count;
-    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 {
+    const int bufferView;
-    return type.byteStride() * count;
+    const GLType type;
-  }
 
-  const int bufferView;
+    unsigned int byteOffset;
-  const GLType type;
+    unsigned int count;
+    std::vector<float> min;
+    std::vector<float> max;
+    std::string name;
 
-  unsigned int byteOffset;
+    bool sparse;
-  unsigned int count;
+    int sparseIdxCount;
-  std::vector<float> min;
+    int sparseIdxBufferView;
-  std::vector<float> max;
+    int sparseIdxBufferViewOffset;
-  std::string name;
+    int sparseIdxBufferViewType;
+    int sparseDataBufferView;
+    int sparseDataBufferViewOffset;
 };

src/gltf/properties/BufferViewData.hpp

@@ -21,9 +21,25 @@ struct BufferViewData : Holdable {
 
   json serialize() const override;
 
+  template <class T>
+  void appendAsBinaryArray(const std::vector<T>& in, std::vector<uint8_t>& 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;
 };