Merge pull request #54 from Unity-Technologies/UNI-21707-improve-export-performance

UNI-21707 improve export performance

Author: vkovec

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -978,7 +978,7 @@ static void OnContextItem (MenuCommand command)
             ///<summary>
             ///Information about the mesh that is important for exporting.
             ///</summary>
-            public struct MeshInfo
+            public class MeshInfo
             {
                 /// <summary>
                 /// The transform of the mesh.
@@ -1009,19 +1009,33 @@ public struct MeshInfo
                 /// Ex: if triangles = [3,4,2], then we have one triangle with vertices vertices[3], vertices[4], and vertices[2]
                 /// </summary>
                 /// <value>The triangles.</value>
-                public int [] Triangles { get { return mesh.triangles; } }
+                private int[] m_triangles;
+                public int [] Triangles { get { 
+                        if(m_triangles == null) { m_triangles = mesh.triangles; }
+                        return m_triangles; 
+                    } }
 
                 /// <summary>
                 /// Gets the vertices, represented in local coordinates.
                 /// </summary>
                 /// <value>The vertices.</value>
-                public Vector3 [] Vertices { get { return mesh.vertices; } }
+                private Vector3[] m_vertices;
+                public Vector3 [] Vertices { get { 
+                        if(m_vertices == null) { m_vertices = mesh.vertices; }
+                        return m_vertices; 
+                    } }
 
                 /// <summary>
                 /// Gets the normals for the vertices.
                 /// </summary>
                 /// <value>The normals.</value>
-                public Vector3 [] Normals { get { return mesh.normals; } }
+                private Vector3[] m_normals;
+                public Vector3 [] Normals { get {
+                        if (m_normals == null) {
+                            m_normals = mesh.normals;
+                        }
+                        return m_normals; 
+                    } }
 
                 /// <summary>
                 /// TODO: Gets the binormals for the vertices.
@@ -1036,12 +1050,15 @@ public Vector3 [] Binormals {
                         ///    => Math.cross (normal, tangent.xyz) * tangent.w
                         if (m_Binormals == null || m_Binormals.Length == 0) 
                         {
-                            m_Binormals = new Vector3 [mesh.normals.Length];
+                            var normals = Normals;
+                            var tangents = Tangents;
+
+                            m_Binormals = new Vector3 [normals.Length];
 
-                            for (int i = 0; i < mesh.normals.Length; i++)
-                                m_Binormals [i] = Vector3.Cross (mesh.normals [i],
-                                    mesh.tangents [i])
-                                * mesh.tangents [i].w;
+                            for (int i = 0; i < normals.Length; i++)
+                                m_Binormals [i] = Vector3.Cross (normals [i],
+                                    tangents [i])
+                                    * tangents [i].w;
 
                         }
                         return m_Binormals;
@@ -1052,19 +1069,37 @@ public Vector3 [] Binormals {
                 /// TODO: Gets the tangents for the vertices.
                 /// </summary>
                 /// <value>The tangents.</value>
-                public Vector4 [] Tangents { get { return mesh.tangents; } }
+                private Vector4[] m_tangents;
+                public Vector4 [] Tangents { get { 
+                        if (m_tangents == null) {
+                            m_tangents = mesh.tangents;
+                        }
+                        return m_tangents; 
+                    } }
 
                 /// <summary>
-                /// TODO: Gets the tangents for the vertices.
+                /// TODO: Gets the vertex colors for the vertices.
                 /// </summary>
-                /// <value>The tangents.</value>
-                public Color32 [] VertexColors { get { return mesh.colors32; } }
+                /// <value>The vertex colors.</value>
+                private Color32 [] m_vertexColors;
+                public Color32 [] VertexColors { get { 
+                        if (m_vertexColors == null) {
+                            m_vertexColors = mesh.colors32;
+                        }
+                        return m_vertexColors; 
+                    } }
 
                 /// <summary>
                 /// Gets the uvs.
                 /// </summary>
                 /// <value>The uv.</value>
-                public Vector2 [] UV { get { return mesh.uv; } }
+                private Vector2[] m_UVs;
+                public Vector2 [] UV { get { 
+                        if (m_UVs == null) {
+                            m_UVs = mesh.uv;
+                        }
+                        return m_UVs; 
+                    } }
 
                 /// <summary>
                 /// The material used, if any; otherwise null.
@@ -1104,6 +1139,12 @@ public MeshInfo (Mesh mesh)
                     this.xform = Matrix4x4.identity;
                     this.unityObject = null;
                     this.m_Binormals = null;
+                    this.m_vertices = null;
+                    this.m_triangles = null;
+                    this.m_normals = null;
+                    this.m_UVs = null;
+                    this.m_vertexColors = null;
+                    this.m_tangents = null;
                 }
 
                 /// <summary>
@@ -1117,6 +1158,12 @@ public MeshInfo (GameObject gameObject, Mesh mesh)
                     this.xform = gameObject.transform.localToWorldMatrix;
                     this.unityObject = gameObject;
                     this.m_Binormals = null;
+                    this.m_vertices = null;
+                    this.m_triangles = null;
+                    this.m_normals = null;
+                    this.m_UVs = null;
+                    this.m_vertexColors = null;
+                    this.m_tangents = null;
                 }
             }
 
@@ -1158,7 +1205,7 @@ private MeshInfo GetMeshInfo (GameObject gameObject, bool requireRenderer = true
                     }
                 }
                 if (!mesh) {
-                    return new MeshInfo ();
+                    return new MeshInfo(null);
                 }
                 return new MeshInfo (gameObject, mesh);
             }

Assets/FbxExporters/Editor/UnitTests/DefaultSelectionTest.cs

@@ -13,62 +13,14 @@ namespace FbxExporters.UnitTests
     /// Tests that the right GameObjects are exported and
     /// that they have the expected transforms.
     /// </summary>
-    public class DefaultSelectionTest
+    public class DefaultSelectionTest : ExporterTestBase
     {
-        private string _filePath;
-        protected string filePath       { get { return string.IsNullOrEmpty(_filePath) ? Application.dataPath : _filePath; } set { _filePath = value; } }
-
-        private string _fileNamePrefix;
-        protected string fileNamePrefix { get { return string.IsNullOrEmpty(_fileNamePrefix) ? "_safe_to_delete__" : _fileNamePrefix; }
-            set { _fileNamePrefix = value; } }
-
-        private string _fileNameExt;
-        protected string fileNameExt    { get { return string.IsNullOrEmpty(_fileNameExt) ? ".fbx" : _fileNameExt; } set { _fileNameExt = value; } }
-
-        private string MakeFileName(string baseName = null, string prefixName = null, string extName = null)
-        {
-            if (baseName==null)
-                baseName = Path.GetRandomFileName();
-
-            if (prefixName==null)
-                prefixName = this.fileNamePrefix;
-
-            if (extName==null)
-                extName = this.fileNameExt;
-
-            return prefixName + baseName + extName;
-        }
-
-        protected string GetRandomFileNamePath(string pathName = null, string prefixName = null, string extName = null)
-        {
-            string temp;
-
-            if (pathName==null)
-                pathName = this.filePath;
-
-            if (prefixName==null)
-                prefixName = this.fileNamePrefix;
-
-            if (extName==null)
-                extName = this.fileNameExt;
-
-            // repeat until you find a file that does not already exist
-            do {
-                temp = Path.Combine (pathName, MakeFileName(prefixName: prefixName, extName: extName));
-
-            } while(File.Exists (temp));
-
-            return temp;
-        }
-
         protected GameObject m_root;
 
         [TearDown]
-        public void Term ()
+        public override void Term ()
         {
-            foreach (string file in Directory.GetFiles (this.filePath, MakeFileName("*"))) {
-                File.Delete (file);
-            }
+            base.Term ();
             if (m_root) {
                 UnityEngine.Object.DestroyImmediate (m_root);
             }
@@ -212,7 +164,7 @@ private GameObject CreateGameObject(string name, Transform parent = null)
             var go = new GameObject (name);
             go.transform.SetParent (parent);
             return go;
-        }
+        }    
 
         private void CompareHierarchies(
             GameObject expectedHierarchy, GameObject actualHierarchy,
@@ -256,31 +208,5 @@ private void CompareHierarchies(GameObject[] expectedHierarchy, GameObject[] act
                 CompareGlobalTransform (actualHierarchy [i].transform, expectedHierarchy [i].transform);
             }
         }
-
-        private GameObject ExportSelection(Object[] selected)
-        {
-            // export selected to a file, then return the root
-            var filename = GetRandomFileNamePath();
-
-            Debug.unityLogger.logEnabled = false;
-            var fbxFileName = FbxExporters.Editor.ModelExporter.ExportObjects (filename, selected) as string;
-            Debug.unityLogger.logEnabled = true;
-
-            Assert.IsNotNull (fbxFileName);
-
-            // make filepath relative to project folder
-            if (fbxFileName.StartsWith (Application.dataPath, System.StringComparison.CurrentCulture)) 
-            {
-                fbxFileName = "Assets" + fbxFileName.Substring (Application.dataPath.Length);
-            }
-            // refresh the assetdata base so that we can query for the model
-            AssetDatabase.Refresh ();
-
-            Object unityMainAsset = AssetDatabase.LoadMainAssetAtPath (fbxFileName);
-            var fbxRoot = unityMainAsset as GameObject;
-
-            Assert.IsNotNull (fbxRoot);
-            return fbxRoot;
-        }
     }
 }

Assets/FbxExporters/Editor/UnitTests/ExportPerformanceTest.cs

@@ -0,0 +1,80 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections;
+using System.Diagnostics;
+
+namespace FbxExporters.UnitTests
+{
+    public class ExportPerformanceTest : ExporterTestBase
+    {
+
+        private const int NumMeshesToCombine = 15;
+
+        // Export should not take longer than this, otherwise test fails
+        private const long PerformanceThresholdMilliseconds = 30000;
+        private Stopwatch m_stopwatch;
+        private GameObject m_toExport;
+
+        [SetUp]
+        public void Init()
+        {
+            m_stopwatch = new Stopwatch ();
+            m_toExport = CreateGameObjectToExport ();
+        }
+
+        [TearDown]
+        public override void Term()
+        {
+            base.Term ();
+            GameObject.DestroyImmediate (m_toExport);
+        }
+
+
+        /// <summary>
+        /// Creates a GameObject containing a very large mesh to export.
+        /// </summary>
+        /// <returns>The game object to export.</returns>
+        private GameObject CreateGameObjectToExport ()
+        {
+            CombineInstance[] combine = new CombineInstance[NumMeshesToCombine];
+            GameObject spheres = GameObject.CreatePrimitive (PrimitiveType.Sphere);
+
+            Transform sphereTransform = spheres.transform;
+            MeshFilter sphereMeshFilter = spheres.GetComponent<MeshFilter> ();
+            Assert.IsNotNull (sphereMeshFilter);
+
+            for (int i = 0; i < NumMeshesToCombine; i++) {
+                combine [i].mesh = sphereMeshFilter.sharedMesh;
+                sphereTransform.position = new Vector3 (i, i, i);
+                combine [i].transform = sphereTransform.localToWorldMatrix;
+            }
+
+            sphereMeshFilter.sharedMesh = new Mesh ();
+            sphereMeshFilter.sharedMesh.name = "Spheres Mesh";
+            sphereMeshFilter.sharedMesh.CombineMeshes (combine);
+            return spheres;
+        }
+
+        [Test]
+        public void TestPerformance ()
+        {
+            Assert.IsNotNull (m_toExport);
+
+            var filename = GetRandomFileNamePath();
+
+            UnityEngine.Debug.unityLogger.logEnabled = false;
+
+            m_stopwatch.Reset ();
+            m_stopwatch.Start ();
+            var fbxFileName = FbxExporters.Editor.ModelExporter.ExportObjects (filename, new Object[]{m_toExport}) as string;
+            m_stopwatch.Stop ();
+
+            UnityEngine.Debug.unityLogger.logEnabled = true;
+
+            Assert.IsNotNull (fbxFileName);
+            Assert.LessOrEqual(m_stopwatch.ElapsedMilliseconds, PerformanceThresholdMilliseconds);
+        }
+    }
+}