Merge pull request #7 from Unity-Technologies/UNI-20504-merge-duplicate-verts-on-export

Uni 20504 merge duplicate verts on export

Author: inwoods

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -57,7 +57,7 @@ public static ModelExporter Create ()
             /// <summary>
             /// Export the mesh's UVs using layer 0.
             /// </summary>
-            public void ExportUVsAndNormals (MeshInfo mesh, FbxMesh fbxMesh, int[] fbxTriangles)
+            public void ExportUVsAndNormals (MeshInfo mesh, FbxMesh fbxMesh, int[] unmergedTriangles)
             {
                 // Set the normals on Layer 0.
                 FbxLayer fbxLayer = fbxMesh.GetLayer (0 /* default layer */);
@@ -67,23 +67,22 @@ public void ExportUVsAndNormals (MeshInfo mesh, FbxMesh fbxMesh, int[] fbxTriang
                 }
 
                 using (var fbxLayerElement = FbxLayerElementNormal.Create (fbxMesh, "Normals")) {
-                    fbxLayerElement.SetMappingMode (FbxLayerElement.EMappingMode.eByControlPoint);
-
-                    // TODO: normals for each triangle vertex instead of averaged per control point
-                    //fbxNormalLayer.SetMappingMode (FbxLayerElement.eByPolygonVertex);
+                    fbxLayerElement.SetMappingMode (FbxLayerElement.EMappingMode.eByPolygonVertex);
 
                     fbxLayerElement.SetReferenceMode (FbxLayerElement.EReferenceMode.eDirect);
 
                     // Add one normal per each vertex face index (3 per triangle)
                     FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray ();
 
-                    for (int n = 0; n < mesh.Normals.Length; n++) {
-                        fbxElementArray.Add (new FbxVector4 (-mesh.Normals [n] [0], 
-                            mesh.Normals [n] [1], 
-                            mesh.Normals [n] [2]));
+                    for (int n = 0; n < unmergedTriangles.Length; n++) {
+                        int unityTriangle = unmergedTriangles [n];
+                        fbxElementArray.Add (new FbxVector4 (-mesh.Normals [unityTriangle] [0],
+                            mesh.Normals [unityTriangle] [1],
+                            mesh.Normals [unityTriangle] [2]));
                     }
-                    fbxLayer.SetNormals (fbxLayerElement);
-                }
+
+					fbxLayer.SetNormals (fbxLayerElement);
+				}
 
                 using (var fbxLayerElement = FbxLayerElementUV.Create (fbxMesh, "UVSet")) {
                     fbxLayerElement.SetMappingMode (FbxLayerElement.EMappingMode.eByPolygonVertex);
@@ -92,20 +91,19 @@ public void ExportUVsAndNormals (MeshInfo mesh, FbxMesh fbxMesh, int[] fbxTriang
                     // set texture coordinates per vertex
                     FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray ();
 
+                    // TODO: only copy unique UVs into this array, and index appropriately
                     for (int n = 0; n < mesh.UV.Length; n++) {
                         fbxElementArray.Add (new FbxVector2 (mesh.UV [n] [0],
                             mesh.UV [n] [1]));
                     }
 
                     // For each face index, point to a texture uv
-                    var unityTriangles = mesh.Triangles;
                     FbxLayerElementArray fbxIndexArray = fbxLayerElement.GetIndexArray ();
-                    fbxIndexArray.SetCount (unityTriangles.Length);
+                    fbxIndexArray.SetCount (unmergedTriangles.Length);
 
-                    for (int i = 0; i < fbxTriangles.Length; i++) {
-                        fbxIndexArray.SetAt (i, fbxTriangles [i]);
+                    for(int i = 0; i < unmergedTriangles.Length; i++){
+                        fbxIndexArray.SetAt (i, unmergedTriangles [i]);
                     }
-
                     fbxLayer.SetUVs (fbxLayerElement, FbxLayerElement.EType.eTextureDiffuse);
                 }
             }
@@ -223,31 +221,54 @@ public FbxSurfaceMaterial ExportMaterial (Material unityMaterial, FbxScene fbxSc
             /// Unconditionally export this mesh object to the file.
             /// We have decided; this mesh is definitely getting exported.
             /// </summary>
-            public void ExportMesh (MeshInfo meshInfo, FbxNode fbxNode, FbxScene fbxScene)
+            public void ExportMesh (MeshInfo meshInfo, FbxNode fbxNode, FbxScene fbxScene, bool weldVertices = true)
             {
                 if (!meshInfo.IsValid)
                     return;
 
                 NumMeshes++;
                 NumTriangles += meshInfo.Triangles.Length / 3;
-                NumVertices += meshInfo.VertexCount;
 
                 // create the mesh structure.
                 FbxMesh fbxMesh = FbxMesh.Create (fbxScene, "Scene");
 
                 // Create control points.
-                int NumControlPoints = meshInfo.VertexCount;
+                Dictionary<Vector3, int> ControlPointToIndex = new Dictionary<Vector3, int> ();
 
-                fbxMesh.InitControlPoints (NumControlPoints);
+                int NumControlPoints = 0;
+                if (weldVertices) {
+                    for (int v = 0; v < meshInfo.VertexCount; v++) {
+                        if (ControlPointToIndex.ContainsKey (meshInfo.Vertices [v])) {
+                            continue;
+                        }
+                        ControlPointToIndex [meshInfo.Vertices [v]] = NumControlPoints;
 
-                // copy control point data from Unity to FBX
-                for (int v = 0; v < meshInfo.VertexCount; v++) {
-                    // convert from left to right-handed by negating x (Unity negates x again on import)
-                    fbxMesh.SetControlPointAt (new FbxVector4 (
-                        -meshInfo.Vertices [v].x,
-                        meshInfo.Vertices [v].y,
-                        meshInfo.Vertices [v].z
-                    ), v);
+                        NumControlPoints++;
+                    }
+                    fbxMesh.InitControlPoints (NumControlPoints);
+
+                    // copy control point data from Unity to FBX
+                    foreach (var controlPoint in ControlPointToIndex.Keys) {
+                        fbxMesh.SetControlPointAt (new FbxVector4 (
+                            -controlPoint.x,
+                            controlPoint.y,
+                            controlPoint.z
+                        ), ControlPointToIndex [controlPoint]);
+                    }
+                } else {
+                    NumControlPoints = meshInfo.VertexCount;
+                    fbxMesh.InitControlPoints (NumControlPoints);
+
+                    // copy control point data from Unity to FBX
+                    for (int v = 0; v < NumControlPoints; v++)
+                    {
+                        // convert from left to right-handed by negating x (Unity negates x again on import)
+                        fbxMesh.SetControlPointAt(new FbxVector4 (
+                            -meshInfo.Vertices [v].x,
+                            meshInfo.Vertices [v].y,
+                            meshInfo.Vertices [v].z
+                        ), v);
+                    }
                 }
 
                 var fbxMaterial = ExportMaterial (meshInfo.Material, fbxScene);
@@ -258,7 +279,7 @@ meshInfo.Vertices [v].z
                  * or else they will be inverted on import 
                  * (due to the conversion from left to right handed coords)
                  */
-                int[] fbxTriangles = new int[meshInfo.Triangles.Length];
+                int[] unmergedTriangles = new int[meshInfo.Triangles.Length];
                 int current = 0;
                 for (int f = 0; f < meshInfo.Triangles.Length / 3; f++) {
                     fbxMesh.BeginPolygon ();
@@ -267,17 +288,22 @@ meshInfo.Vertices [v].z
                     // of 0,1,2, as this gets flipped back during import
                     foreach (int val in new int[]{0,2,1}) {
                         int tri = meshInfo.Triangles [3 * f + val];
+
+                        // Save the triangle order (without merging vertices) so we
+                        // properly export UVs, normals, binormals, etc.
+                        unmergedTriangles [current] = tri;
+
+                        if (weldVertices) {
+                            tri = ControlPointToIndex [meshInfo.Vertices [tri]];
+                        }
                         fbxMesh.AddPolygon (tri);
 
-                        // save the exported triangle order so we
-                        // properly export UVs
-                        fbxTriangles [current] = tri;
                         current++;
                     }
                     fbxMesh.EndPolygon ();
                 }
 
-                ExportUVsAndNormals (meshInfo, fbxMesh, fbxTriangles);
+                ExportUVsAndNormals (meshInfo, fbxMesh, unmergedTriangles);
 
                 // set the fbxNode containing the mesh
                 fbxNode.SetNodeAttribute (fbxMesh);
@@ -712,11 +738,6 @@ private MeshInfo GetMeshInfo (GameObject gameObject, bool requireRenderer = true
             /// </summary>
             public int NumTriangles { private set; get; }
 
-            /// <summary>
-            /// Number of vertices
-            /// </summary>
-            public int NumVertices { private set; get; }
-
             /// <summary>
             /// Clean up this class on garbage collection
             /// </summary>