Merge branch 'master' into UNI-21512-document-exporters

Not a straightforward merge for the README.

Author: Benoit Hudson

Assets/FbxExporters/Editor/ConvertToModel.cs

@@ -32,7 +32,8 @@ public void Dispose () { }
             [MenuItem (MenuItemName1, false)]
             public static void OnMenuItem ()
             {
-                OnConvertInPlace ();
+                GameObject [] unityActiveGOs = Selection.GetFiltered<GameObject> (SelectionMode.Editable | SelectionMode.TopLevel);
+                OnConvertInPlace (unityActiveGOs);
             }
 
             /// <summary>
@@ -45,28 +46,44 @@ public static bool OnValidateMenuItem ()
             }
 
             // Add a menu item called "Export Model..." to a GameObject's context menu.
+            // OnContextItem gets called once per selected object 
+            // (if the parent and child are selected, then OnContextItem will only be called on the parent)
             [MenuItem (MenuItemName2, false, 30)]
             static void OnContextItem (MenuCommand command)
             {
-                OnConvertInPlace ();
+                if (command == null || command.context == null) {
+                    Debug.LogError ("Error: No GameObject selected");
+                    return;
+                }
+                GameObject selected = command.context as GameObject;
+                if (selected == null) {
+                    Debug.LogError (string.Format("Error: {0} is not a GameObject and cannot be converted", command.context.name));
+                    return;
+                }
+                OnConvertInPlace (new GameObject[]{selected});
             }
 
-            private static List<GameObject> OnConvertInPlace ()
+            private static List<GameObject> OnConvertInPlace (GameObject [] unityActiveGOs)
             {
                 List<GameObject> result = new List<GameObject> ();
 
-                GameObject [] unityActiveGOs = Selection.GetFiltered<GameObject> (SelectionMode.Editable | SelectionMode.TopLevel);
-
                 var exportSet = ModelExporter.RemoveRedundantObjects (unityActiveGOs);
                 GameObject[] gosToExport = new GameObject[exportSet.Count];
                 exportSet.CopyTo (gosToExport);
 
+                EnforceUniqueNames (gosToExport);
+
                 // find common ancestor root & filePath;
                 string[] filePaths = new string[gosToExport.Length];
                 string dirPath = Path.Combine (Application.dataPath, "Objects");
 
                 for(int n = 0; n < gosToExport.Length; n++){
-                    filePaths[n] = Path.Combine (dirPath, gosToExport[n].name + ".fbx");
+                    var filename = ModelExporter.ConvertToValidFilename (gosToExport [n].name + ".fbx");
+                    var filePath = Path.Combine (dirPath, filename);
+                    if (File.Exists (filePath)) {
+                        filePath = IncrementFileName (dirPath, filename);
+                    }
+                    filePaths[n] = filePath;
                 }
 
                 string[] fbxFileNames = new string[filePaths.Length];
@@ -81,7 +98,7 @@ private static List<GameObject> OnConvertInPlace ()
                 {
                     var fbxFileName = fbxFileNames [i];
                     if (fbxFileName == null) {
-                        Debug.Log (string.Format ("Warning: Export failed for GameObject {0}", gosToExport [i].name));
+                        Debug.LogWarning (string.Format ("Warning: Export failed for GameObject {0}", gosToExport [i].name));
                         continue;
                     }
 
@@ -98,7 +115,7 @@ private static List<GameObject> OnConvertInPlace ()
                     Object unityMainAsset = AssetDatabase.LoadMainAssetAtPath (fbxFileName);
 
                     if (unityMainAsset != null) {
-                        Object unityObj = PrefabUtility.InstantiateAttachedAsset (unityMainAsset);
+                        Object unityObj = PrefabUtility.InstantiatePrefab (unityMainAsset);
                         GameObject unityGO = unityObj as GameObject;
                         if (unityGO != null) 
                         {
@@ -126,6 +143,66 @@ private static List<GameObject> OnConvertInPlace ()
                 return result;
             }
 
+            /// <summary>
+            /// Check if the file exists, and if it does, then increment the name.
+            /// e.g. if filename is Sphere.fbx and it already exists, change it to Sphere 1.fbx.
+            /// </summary>
+            /// <returns>new file name.</returns>
+            /// <param name="filename">Filename.</param>
+            private static string IncrementFileName(string path, string filename)
+            {
+                string fileWithoutExt = Path.GetFileNameWithoutExtension (filename);
+                string ext = Path.GetExtension (filename);
+
+                int index = 1;
+                string file = null;
+                do {
+                    file = string.Format ("{0} {1}{2}", fileWithoutExt, index, ext);
+                    file = Path.Combine(path, file);
+                    index++;
+                } while (File.Exists (file));
+
+                return file;
+            } 
+
+            /// <summary>
+            /// Enforces that all object names be unique before exporting.
+            /// If an object with a duplicate name is found, then it is incremented.
+            /// e.g. Sphere becomes Sphere 1
+            /// </summary>
+            /// <param name="exportSet">Export set.</param>
+            private static void EnforceUniqueNames(GameObject[] exportSet)
+            {
+                Dictionary<string, int> NameToIndexMap = new Dictionary<string, int> ();
+                string format = "{0} {1}";
+
+                Queue<GameObject> queue = new Queue<GameObject> (exportSet);
+
+                while(queue.Count > 0){
+                    var go = queue.Dequeue ();
+                    var name = go.name;
+                    if (NameToIndexMap.ContainsKey (name)) {
+                        go.name = string.Format (format, name, NameToIndexMap [name]);
+                        NameToIndexMap [name]++;
+                    } else {
+                        NameToIndexMap [name] = 1;
+                    }
+
+                    foreach (Transform child in go.transform) {
+                        queue.Enqueue (child.gameObject);
+                    }
+                }
+            }
+
+            /// <summary>
+            /// Sets up the imported GameObject to match the original.
+            /// - Updates the name to be the same as original (i.e. remove the "(Clone)")
+            /// - Moves the imported object to the correct position in the hierarchy
+            /// - Updates the transform of the imported GameObject to match the original
+            /// - Copy over missing components and component values
+            /// </summary>
+            /// <param name="orig">Original GameObject.</param>
+            /// <param name="imported">Imported GameObject.</param>
             private static void SetupImportedGameObject(GameObject orig, GameObject imported)
             {
                 Transform importedTransform = imported.transform;
@@ -154,9 +231,25 @@ private static void SetupImportedGameObject(GameObject orig, GameObject imported
                     Debug.LogWarning (string.Format ("Warning: Exported {0} objects, but only imported {1}",
                         origTransform.hierarchyCount, importedTransform.hierarchyCount));
                 }
+                FixSiblingOrder (orig.transform, imported.transform);
                 CopyComponentsRecursive (orig, imported);
             }
 
+            private static void FixSiblingOrder(Transform orig, Transform imported){
+                foreach (Transform origChild in orig) {
+                    Transform importedChild = imported.Find (origChild.name);
+                    if (importedChild == null) {
+                        Debug.LogWarning (string.Format(
+                            "Warning: Could not find {0} in parented under {1} in import hierarchy",
+                            origChild.name, imported.name
+                        ));
+                        continue;
+                    }
+                    importedChild.SetSiblingIndex (origChild.GetSiblingIndex ());
+                    FixSiblingOrder (origChild, importedChild);
+                }
+            }
+
             private static void CopyComponentsRecursive(GameObject from, GameObject to){
                 if (!to.name.StartsWith(from.name) || from.transform.childCount != to.transform.childCount) {
                     Debug.LogError (string.Format("Error: hierarchies don't match (From: {0}, To: {1})", from.name, to.name));

Assets/FbxExporters/Editor/FbxExportSettings.cs

@@ -11,8 +11,21 @@ public class ExportSettingsEditor : UnityEditor.Editor {
         public override void OnInspectorGUI() {
             ExportSettings exportSettings = (ExportSettings)target;
 
+            // Increasing the label width so that none of the text gets cut off
+            EditorGUIUtility.labelWidth = 300;
+
             exportSettings.weldVertices = EditorGUILayout.Toggle ("Weld Vertices:", exportSettings.weldVertices);
             exportSettings.embedTextures = EditorGUILayout.Toggle ("Embed Textures:", exportSettings.embedTextures);
+            exportSettings.mayaCompatibleNames = EditorGUILayout.Toggle (
+                new GUIContent("Convert to Maya Compatible Naming:",
+                    "In Maya some symbols such as spaces and accents get replaced when importing an FBX " +
+                    "(e.g. \"foo bar\" becomes \"fooFBXASC032bar\"). " +
+                    "On export, convert the names of GameObjects so they are Maya compatible." +
+                    (exportSettings.mayaCompatibleNames? "" : 
+                        "\n\nWARNING: Disabling this feature may result in lost material connections," +
+                        " and unexpected character replacements in Maya.")
+                ),
+                exportSettings.mayaCompatibleNames);
 
             if (GUI.changed) {
                 EditorUtility.SetDirty (exportSettings);
@@ -26,6 +39,7 @@ public class ExportSettings : FbxExporters.EditorTools.ScriptableSingleton<Expor
     {
         public bool weldVertices = true;
         public bool embedTextures = false;
+        public bool mayaCompatibleNames = true;
 
         [MenuItem("Edit/Project Settings/Fbx Export", priority = 300)]
         static void ShowManager()