UT-3419 Duplicate meshes export as instances. (#536)

Duplicate meshes export as instances even when not apart of a prefab.

Author: natalia-wh

com.unity.formats.fbx/Editor/FbxExporter.cs

@@ -196,6 +196,8 @@ internal enum FbxNodeRelationType
         /// Used for enforcing unique names on export.
         /// </summary>
         Dictionary<string, int> TextureNameToIndexMap = new Dictionary<string, int>();
+        
+        Dictionary<Mesh, FbxNode> MeshToFbxNodeMap = new Dictionary<Mesh, FbxNode>();
 
         /// <summary>
         /// Format for creating unique names
@@ -1313,7 +1315,7 @@ internal bool ExportTransform (UnityEngine.Transform unityTransform, FbxNode fbx
         }
 
         /// <summary>
-        /// if this game object is a model prefab then export with shared components
+        /// if this game object is a model prefab or the model has already been exported, then export with shared components
         /// </summary>
         [SecurityPermission(SecurityAction.LinkDemand)]
         private bool ExportInstance(GameObject unityGo, FbxScene fbxScene, FbxNode fbxNode)
@@ -1322,31 +1324,46 @@ private bool ExportInstance(GameObject unityGo, FbxScene fbxScene, FbxNode fbxNo
             {
                 return false;
             }
-            
-            PrefabAssetType unityPrefabType = PrefabUtility.GetPrefabAssetType(unityGo);
-            // only export as an instance if the GameObject is part of a prefab instance
-            if (unityPrefabType == PrefabAssetType.MissingAsset ||
-                unityPrefabType == PrefabAssetType.NotAPrefab ||
-                PrefabUtility.GetPrefabInstanceStatus(unityGo) != PrefabInstanceStatus.Connected)
-            {
-                return false;
-            }
 
             Object unityPrefabParent = PrefabUtility.GetCorrespondingObjectFromSource(unityGo);
 
-            if (Verbose)
-                Debug.Log (string.Format ("exporting instance {0}({1})", unityGo.name, unityPrefabParent.name));
-
             FbxMesh fbxMesh = null;
 
-            if (!SharedMeshes.TryGetValue (unityPrefabParent.GetInstanceID(), out fbxMesh))
+            if (unityPrefabParent != null && !SharedMeshes.TryGetValue (unityPrefabParent.GetInstanceID(), out fbxMesh))
             {
+                if (Verbose)
+                    Debug.Log (string.Format ("exporting instance {0}({1})", unityGo.name, unityPrefabParent.name));
+                
                 if (ExportMesh (unityGo, fbxNode) && fbxNode.GetMesh() != null) {
                     SharedMeshes [unityPrefabParent.GetInstanceID()] = fbxNode.GetMesh ();
                     return true;
                 }
                 return false;
             }
+            // check if mesh is shared between 2 objects that are not prefabs
+            else if (unityPrefabParent == null)
+            {
+                // check if same mesh has already been exported
+                MeshFilter unityGoMesh = unityGo.GetComponent<MeshFilter>();
+                if (unityGoMesh != null && MeshToFbxNodeMap.ContainsKey(unityGoMesh.sharedMesh))
+                {
+                    fbxMesh = MeshToFbxNodeMap[unityGoMesh.sharedMesh].GetMesh();
+                }
+                // export mesh as normal and add it to list
+                else
+                {
+                    if (unityGoMesh != null)
+                    {
+                        MeshToFbxNodeMap.Add(unityGoMesh.sharedMesh, fbxNode);
+                    }
+                    return false;
+                }
+            }
+
+            if (fbxMesh == null)
+            {
+                return false;
+            }
 
             // We don't export the mesh because we already have it from the parent, but we still need to assign the material
             var renderer = unityGo.GetComponent<Renderer>();

com.unity.formats.fbx/Tests/FbxApiTests/PublicAPITest.cs

@@ -15,7 +15,7 @@ public class PublicAPITest : ExporterTestBaseAPI
         public override void Init()
         {
             base.Init();
-            m_toExport = new GameObject[] {CreateGameObjectToExport(), CreateGameObjectToExport()};
+            m_toExport = new GameObject[] {CreateGameObjectToExport(PrimitiveType.Cube), CreateGameObjectToExport(PrimitiveType.Sphere) };
         }
 
         [TearDown]
@@ -32,9 +32,9 @@ public override void Term()
         /// Creates a GameObject to export.
         /// </summary>
         /// <returns>The game object to export.</returns>
-        private GameObject CreateGameObjectToExport ()
+        private GameObject CreateGameObjectToExport (PrimitiveType type = PrimitiveType.Sphere)
         {
-            return GameObject.CreatePrimitive (PrimitiveType.Sphere);
+            return GameObject.CreatePrimitive (type);
         }
 
         [Test]

com.unity.formats.fbx/Tests/FbxTests/ModelExporterTest.cs

@@ -232,7 +232,10 @@ public void TestExporterCallbacks()
         {
             var tree = CreateHierarchy();
             var tester = new CallbackTester(tree.transform, GetRandomFbxFilePath());
-            var n = tree.GetComponentsInChildren<Transform>().Length;
+            var nbTransforms = tree.GetComponentsInChildren<Transform>().Length;
+            // UT-3419: because cubes are duplicates, there are less model callbacks than transforms
+            // 1 for the root and 1 for the cube model all the gameobjects share
+            var nbMeshCallbacks = 2;
 
             // No callbacks registered => no calls.
             tester.Verify(0, 0);
@@ -241,34 +244,34 @@ public void TestExporterCallbacks()
             ModelExporter.RegisterMeshCallback<FbxPrefab>(tester.CallbackForFbxPrefab);
 
             // No fbprefab => no component calls, but every object called.
-            tester.Verify(0, n);
+            tester.Verify(0, nbMeshCallbacks);
 
             // Add a fbxprefab, check every object called and the prefab called.
             tree.transform.Find("Parent1").gameObject.AddComponent<FbxPrefab>();
-            tester.Verify(1, n);
+            tester.Verify(1, nbTransforms);
 
             // Make the object report it's replacing everything => no component calls.
-            tester.Verify(0, n, objectResult: true);
+            tester.Verify(0, nbTransforms, objectResult: true);
 
             // Make sure we can't register for a component twice, but we can
             // for an object.  Register twice for an object means two calls per
             // object.
             Assert.That( () => ModelExporter.RegisterMeshCallback<FbxPrefab>(tester.CallbackForFbxPrefab),
                     Throws.Exception);
             ModelExporter.RegisterMeshObjectCallback(tester.CallbackForObject);
-            tester.Verify(1, 2 * n);
+            tester.Verify(1, 2 * nbTransforms);
 
             // Register twice but return true => only one call per object.
-            tester.Verify(0, n, objectResult: true);
+            tester.Verify(0, nbTransforms, objectResult: true);
 
             // Unregister once => only one call per object, and no more for the prefab.
             ModelExporter.UnRegisterMeshCallback<FbxPrefab>();
             ModelExporter.UnRegisterMeshObjectCallback(tester.CallbackForObject);
-            tester.Verify(0, n);
+            tester.Verify(0, nbMeshCallbacks);
 
             // Legal to unregister if already unregistered.
             ModelExporter.UnRegisterMeshCallback<FbxPrefab>();
-            tester.Verify(0, n);
+            tester.Verify(0, nbMeshCallbacks);
 
             // Register same callback twice gets back to original state.
             ModelExporter.UnRegisterMeshObjectCallback(tester.CallbackForObject);
@@ -302,11 +305,12 @@ public void TestExporterCallbacks()
             ModelExporter.ExportObject(filename, tree);
             ModelExporter.UnRegisterMeshCallback<FbxPrefab>();
 
+            // UT-3419 Parent1 and Parent2 are instances the same mesh, so they should point to the same mesh
             asset = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject;
             assetMesh = asset.transform.Find("Parent1").GetComponent<MeshFilter>().sharedMesh;
             Assert.AreEqual(sphereMesh.triangles.Length, assetMesh.triangles.Length);
             assetMesh = asset.transform.Find("Parent2").GetComponent<MeshFilter>().sharedMesh;
-            Assert.AreEqual(cubeMesh.triangles.Length, assetMesh.triangles.Length);
+            Assert.AreEqual(sphereMesh.triangles.Length, assetMesh.triangles.Length);
 
             // Try again, but this time pick on Parent2 by name (different just
             // to make sure we don't pass if the previous pass didn't
@@ -325,11 +329,12 @@ public void TestExporterCallbacks()
             ModelExporter.ExportObject(filename, tree);
             ModelExporter.UnRegisterMeshObjectCallback(callback);
 
+            // UT-3419 Parent1 and Parent2 are instances the same mesh, so they should point to the same mesh
             asset = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject;
             assetMesh = asset.transform.Find("Parent1").GetComponent<MeshFilter>().sharedMesh;
             Assert.AreEqual(cubeMesh.triangles.Length, assetMesh.triangles.Length);
             assetMesh = asset.transform.Find("Parent2").GetComponent<MeshFilter>().sharedMesh;
-            Assert.AreEqual(sphereMesh.triangles.Length, assetMesh.triangles.Length);
+            Assert.AreEqual(cubeMesh.triangles.Length, assetMesh.triangles.Length);
         }
 
         [Test]
@@ -1079,5 +1084,25 @@ public void TestPreserveImportSettings()
             newGuid = AssetDatabase.AssetPathToGUID(filename);
             Assert.AreEqual(originalGuid, newGuid);
         }
+
+        // UT-3419 Test that identical models export as instances
+        [Test]
+        public void TestInstanceExport()
+        {
+            // create root with 2 identical children
+            var filename = GetRandomFbxFilePath();
+            GameObject root = new GameObject("root");
+            GameObject child1 = CreateGameObject("child1", root.transform);
+            GameObject child2 = CreateGameObject("child2", root.transform);
+
+            // check export was successful
+            var result = ModelExporter.ExportObject(filename, root);
+            Assert.That(result, Is.Not.Null);
+            Assert.AreEqual(filename, result);
+
+            // check that both children reference the same mesh
+            GameObject fbxObj = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject;
+            Assert.AreEqual(fbxObj.transform.GetChild(0).GetComponent<MeshFilter>().sharedMesh.name, fbxObj.transform.GetChild(1).GetComponent<MeshFilter>().sharedMesh.name);
+        }
     }
 }