apply FBXGeometry.scaleOffset to mesh vertices

tools/vhacd-util/src/VHACDUtil.cpp

@@ -87,19 +87,12 @@ void getTrianglesInMeshPart(const FBXMeshPart &meshPart, std::vector<int>& trian
     }
 }
 
-
+void vhacd::VHACDUtil::fattenMesh(const FBXMesh& mesh, const glm::mat4& geometryOffset, FBXMesh& result) const {
-void vhacd::VHACDUtil::fattenMeshes(const FBXMesh& mesh, FBXMesh& result,
-                                    uint32_t& meshPartCount,
-                                    uint32_t startMeshIndex, uint32_t endMeshIndex) const {
     // this is used to make meshes generated from a highfield collidable.  each triangle
     // is converted into a tetrahedron and made into its own mesh-part.
 
     std::vector<int> triangleIndices;
     foreach (const FBXMeshPart &meshPart, mesh.parts) {
-        if (meshPartCount < startMeshIndex || meshPartCount >= endMeshIndex) {
-            meshPartCount++;
-            continue;
-        }
         getTrianglesInMeshPart(meshPart, triangleIndices);
     }
 
@@ -107,10 +100,13 @@ void vhacd::VHACDUtil::fattenMeshes(const FBXMesh& mesh, FBXMesh& result,
         return;
     }
 
+    int indexStartOffset = result.vertices.size();
+
     // new mesh gets the transformed points from the original
+    glm::mat4 totalTransform = geometryOffset * mesh.modelTransform;
     for (int i = 0; i < mesh.vertices.size(); i++) {
         // apply the source mesh's transform to the points
-        glm::vec4 v = mesh.modelTransform * glm::vec4(mesh.vertices[i], 1.0f);
+        glm::vec4 v = totalTransform * glm::vec4(mesh.vertices[i], 1.0f);
         result.vertices += glm::vec3(v);
     }
 
@@ -118,7 +114,6 @@ void vhacd::VHACDUtil::fattenMeshes(const FBXMesh& mesh, FBXMesh& result,
 
     const uint32_t TRIANGLE_STRIDE = 3;
     const float COLLISION_TETRAHEDRON_SCALE = 0.25f;
-    int indexStartOffset = result.vertices.size();
     for (uint32_t i = 0; i < triangleIndices.size(); i += TRIANGLE_STRIDE) {
         int index0 = triangleIndices[i] + indexStartOffset;
         int index1 = triangleIndices[i + 1] + indexStartOffset;
@@ -341,8 +336,9 @@ bool vhacd::VHACDUtil::computeVHACD(FBXGeometry& geometry,
 
         // each mesh has its own transform to move it to model-space
         std::vector<glm::vec3> vertices;
+        glm::mat4 totalTransform = geometry.offset * mesh.modelTransform;
         foreach (glm::vec3 vertex, mesh.vertices) {
-            vertices.push_back(glm::vec3(mesh.modelTransform * glm::vec4(vertex, 1.0f)));
+            vertices.push_back(glm::vec3(totalTransform * glm::vec4(vertex, 1.0f)));
         }
         uint32_t numVertices = (uint32_t)vertices.size();
 

tools/vhacd-util/src/VHACDUtil.h

@@ -29,9 +29,7 @@ namespace vhacd {
 
         bool loadFBX(const QString filename, FBXGeometry& result);
 
-        void fattenMeshes(const FBXMesh& mesh, FBXMesh& result,
+        void fattenMesh(const FBXMesh& mesh, const glm::mat4& gometryOffset, FBXMesh& result) const;
-                          unsigned int& meshPartCount,
-                          unsigned int startMeshIndex, unsigned int endMeshIndex) const;
 
         bool computeVHACD(FBXGeometry& geometry,
                           VHACD::IVHACD::Parameters params,

tools/vhacd-util/src/VHACDUtilApp.cpp

@@ -126,12 +126,6 @@ VHACDUtilApp::VHACDUtilApp(int argc, char* argv[]) :
     const QCommandLineOption outputCentimetersOption("c", "output units are centimeters");
     parser.addOption(outputCentimetersOption);
 
-    const QCommandLineOption startMeshIndexOption("s", "start-mesh index", "0");
-    parser.addOption(startMeshIndexOption);
-
-    const QCommandLineOption endMeshIndexOption("e", "end-mesh index", "0");
-    parser.addOption(endMeshIndexOption);
-
     const QCommandLineOption minimumMeshSizeOption("m", "minimum mesh (diagonal) size to consider", "0");
     parser.addOption(minimumMeshSizeOption);
 
@@ -230,16 +224,6 @@ VHACDUtilApp::VHACDUtilApp(int argc, char* argv[]) :
         Q_UNREACHABLE();
     }
 
-    int startMeshIndex = -1;
-    if (parser.isSet(startMeshIndexOption)) {
-        startMeshIndex = parser.value(startMeshIndexOption).toInt();
-    }
-
-    int endMeshIndex = -1;
-    if (parser.isSet(endMeshIndexOption)) {
-        endMeshIndex = parser.value(endMeshIndexOption).toInt();
-    }
-
     float minimumMeshSize = 0.0f;
     if (parser.isSet(minimumMeshSizeOption)) {
         minimumMeshSize = parser.value(minimumMeshSizeOption).toFloat();
@@ -417,17 +401,9 @@ VHACDUtilApp::VHACDUtilApp(int argc, char* argv[]) :
             meshCount += mesh.parts.size();
         }
 
-        if (startMeshIndex < 0) {
-            startMeshIndex = 0;
-        }
-        if (endMeshIndex < 0) {
-            endMeshIndex = meshCount;
-        }
-
-        unsigned int meshPartCount = 0;
         result.modelTransform = glm::mat4(); // Identity matrix
         foreach (const FBXMesh& mesh, fbx.meshes) {
-            vUtil.fattenMeshes(mesh, result, meshPartCount, startMeshIndex, endMeshIndex);
+            vUtil.fattenMesh(mesh, fbx.offset, result);
         }
 
         newFbx.meshes.append(result);