Merge branch 'master' into Uni-33058_unitTest_for_VendorLocations

# Conflicts:
#	Assets/FbxExporters/Editor/FbxExportSettings.cs
#	Assets/FbxExporters/Editor/UnitTests/FbxExportSettingsTest.cs

Author: AJubrey

Assets/FbxExporters/Editor/FbxExportSettings.cs

@@ -158,13 +158,13 @@ public override void OnInspectorGUI() {
             EditorGUILayout.Space();
 
             exportSettings.launchAfterInstallation = EditorGUILayout.Toggle(
-                new GUIContent("Keep open:",
+                new GUIContent("Keep Open:",
                     "Keep the selected 3D application open after Unity integration install has completed."),
                 exportSettings.launchAfterInstallation
             );
 
             exportSettings.HideSendToUnityMenu = EditorGUILayout.Toggle(
-                new GUIContent("Hide native menu:",
+                new GUIContent("Hide Native Menu:",
                     "Replace Maya's native 'Send to Unity' menu with the Unity Integration's menu"),
                 exportSettings.HideSendToUnityMenu
             );
@@ -451,6 +451,11 @@ public void SetDCCOptionNames(List<string> newList)
             dccOptionNames = newList;
         }
 
+        public void SetDCCOptionPaths(List<string> newList)
+        {
+            dccOptionPaths = newList;
+        }
+
         public void ClearDCCOptionNames()
         {
             dccOptionNames.Clear();

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -124,6 +124,13 @@ public static Material DefaultMaterial {
             }
             static Material s_defaultMaterial = null;
 
+            static Dictionary<UnityEngine.LightType, FbxLight.EType> MapLightType = new Dictionary<UnityEngine.LightType, FbxLight.EType> () {
+                { UnityEngine.LightType.Directional,    FbxLight.EType.eDirectional },
+                { UnityEngine.LightType.Spot,           FbxLight.EType.eSpot },
+                { UnityEngine.LightType.Point,          FbxLight.EType.ePoint },
+                { UnityEngine.LightType.Area,           FbxLight.EType.eArea },
+            };
+
             /// <summary>
             /// Gets the version number of the FbxExporters plugin from the readme.
             /// </summary>
@@ -825,18 +832,6 @@ protected bool ExportCamera (GameObject unityGO, FbxScene fbxScene, FbxNode fbxN
                 fbxCamera.SetFarPlane (unityCamera.farClipPlane*UnitScaleFactor);
                 #endregion
 
-                // Export backgroundColor as a custom property
-                // NOTE: export on fbxNode so that it will show up in Maya
-                ExportColorProperty (fbxNode, unityCamera.backgroundColor,
-                    MakeName("backgroundColor"), 
-                    "The color with which the screen will be cleared.");
-
-                // Export clearFlags as a custom property
-                // NOTE: export on fbxNode so that it will show up in Maya
-                ExportIntProperty (fbxNode, (int)unityCamera.clearFlags,
-                    MakeName("clearFlags"), 
-                    "How the camera clears the background.");
-
                 fbxNode.SetNodeAttribute (fbxCamera);
 
                 // set +90 post rotation to counteract for FBX camera's facing +X direction by default
@@ -851,55 +846,84 @@ protected bool ExportCamera (GameObject unityGO, FbxScene fbxScene, FbxNode fbxN
             }
 
             /// <summary>
-            /// configures default camera for the scene
+            /// Exports light component.
+            /// Supported types: point, spot and directional
+            /// Cookie => Gobo
             /// </summary>
-            protected void SetDefaultCamera (FbxScene fbxScene)
+            protected bool ExportLight (GameObject unityGo, FbxScene fbxScene, FbxNode fbxNode)
             {
-                if (DefaultCamera == "")
-                    DefaultCamera = Globals.FBXSDK_CAMERA_PERSPECTIVE;
+                Light unityLight = unityGo.GetComponent<Light> ();
 
-                fbxScene.GetGlobalSettings ().SetDefaultCamera (DefaultCamera);
-            }
+                if (unityLight == null)
+                    return false;
 
-            /// <summary>
-            /// Export Component's color property
-            /// </summary>
-            bool ExportColorProperty (FbxObject fbxObject, Color value, string name, string label)
-            {
-                // create a custom property for component value
-                var fbxProperty = FbxProperty.Create (fbxObject, Globals.FbxColor4DT, name, label);
-                if (!fbxProperty.IsValid ()) {
-                    throw new System.NullReferenceException ();
+                FbxLight.EType fbxLightType;
+
+                // Is light type supported?
+                if (!MapLightType.TryGetValue (unityLight.type, out fbxLightType))
+                    return false;
+                
+                FbxLight fbxLight = FbxLight.Create (fbxScene.GetFbxManager (), unityLight.name);
+
+                // Set the type of the light.      
+                fbxLight.LightType.Set(fbxLightType);
+
+                switch (unityLight.type) 
+                {
+                case LightType.Directional : {
+                        break;
+                    }
+                case LightType.Spot : {
+                        // Set the angle of the light's spotlight cone in degrees.
+                        fbxLight.InnerAngle.Set(unityLight.spotAngle);
+                        fbxLight.OuterAngle.Set(unityLight.spotAngle);
+                        break;
+                    }
+                case LightType.Point : {
+                        break;
+                    }
+                case LightType.Area : {
+                        // TODO: areaSize: The size of the area light by scaling the node XY
+                        break;
+                    }
                 }
+                // The color of the light.
+                var unityLightColor = unityLight.color;
+                fbxLight.Color.Set (new FbxDouble3(unityLightColor.r, unityLightColor.g, unityLightColor.b));
 
-                FbxColor fbxColor = new FbxColor(value.r, value.g, value.b, value.a );
+                // Set the Intensity of a light is multiplied with the Light color.
+                fbxLight.Intensity.Set (unityLight.intensity * UnitScaleFactor /*compensate for Maya scaling by system units*/ );
 
-                fbxProperty.Set (fbxColor);
+                // Set the range of the light.
+                // applies-to: Point & Spot
+                // => FarAttenuationStart, FarAttenuationEnd
+                fbxLight.FarAttenuationStart.Set (0.01f /* none zero start */);
+                fbxLight.FarAttenuationEnd.Set(unityLight.range*UnitScaleFactor);
 
-                // Must be marked user-defined or it won't be shown in most DCCs
-                fbxProperty.ModifyFlag (FbxPropertyFlags.EFlags.eUserDefined, true);
-                fbxProperty.ModifyFlag (FbxPropertyFlags.EFlags.eAnimatable, true);
+                // shadows           Set how this light casts shadows
+                // applies-to: Point & Spot
+                bool unityLightCastShadows = unityLight.shadows != LightShadows.None;
+                fbxLight.CastShadows.Set (unityLightCastShadows);
+
+                fbxNode.SetNodeAttribute (fbxLight);
+
+                // set +90 post rotation on x to counteract for FBX light's facing -Y direction by default
+                fbxNode.SetPostRotation(FbxNode.EPivotSet.eSourcePivot, new FbxVector4(90,0,0));
+                // have to set rotation active to true in order for post rotation to be applied
+                fbxNode.SetRotationActive (true);
 
                 return true;
             }
 
             /// <summary>
-            /// Export Component's int property
+            /// configures default camera for the scene
             /// </summary>
-            bool ExportIntProperty (FbxObject fbxObject, int value, string name, string label)
+            protected void SetDefaultCamera (FbxScene fbxScene)
             {
-                // create a custom property for component value
-                var fbxProperty = FbxProperty.Create (fbxObject, Globals.FbxIntDT, name, label);
-                if (!fbxProperty.IsValid ()) {
-                    throw new System.NullReferenceException ();
-                }
-                fbxProperty.Set (value);
-
-                // Must be marked user-defined or it won't be shown in most DCCs
-                fbxProperty.ModifyFlag (FbxPropertyFlags.EFlags.eUserDefined, true);
-                fbxProperty.ModifyFlag (FbxPropertyFlags.EFlags.eAnimatable, true);
+                if (DefaultCamera == "")
+                    DefaultCamera = Globals.FBXSDK_CAMERA_PERSPECTIVE;
 
-                return true;
+                fbxScene.GetGlobalSettings ().SetDefaultCamera (DefaultCamera);
             }
 
             /// <summary>
@@ -964,8 +988,14 @@ protected int ExportComponents (
                 }
 
                 // export camera, but only if no mesh was exported
+                bool exportedCamera = false;
                 if (!exportedMesh) {
-                    ExportCamera (unityGo, fbxScene, fbxNode);
+                    exportedCamera = ExportCamera (unityGo, fbxScene, fbxNode);
+                }
+
+                // export light, but only if no mesh or camera was exported
+                if (!exportedMesh && !exportedCamera) {
+                    ExportLight (unityGo, fbxScene, fbxNode);
                 }
 
                 if (Verbose)
@@ -1318,6 +1348,9 @@ private void ReplaceFile ()
                 } catch (IOException) {
                 }
 
+                // refresh the database so Unity knows the file's been deleted
+                AssetDatabase.Refresh();
+
                 if (File.Exists (m_lastFilePath)) {
                     Debug.LogWarning ("Failed to delete file: " + m_lastFilePath);
                 }

Assets/FbxExporters/Editor/UnitTests/FbxExportSettingsTest.cs

@@ -214,6 +214,57 @@ public void TestFindPreferredProgram()
         }
 
         [Test]
+        public void TestGetDCCOptions()
+        {
+            //Our.exe file
+            string executableName = "/maya.exe";
+
+            //Our folder names
+            string firstSubFolder = "/maya 3000";
+            string secondSubFolder = "/maya 3001";
+
+            //Make a folder structure to mimic an 'autodesk' type hierarchy
+            string testFolder = Path.GetRandomFileName();
+            var firstPath = Directory.CreateDirectory(testFolder + firstSubFolder);
+            var secondPath = Directory.CreateDirectory(testFolder + secondSubFolder);
+
+            try
+            {
+                //Create any files we need within the folders
+                FileInfo firstExe = new FileInfo(firstPath.FullName + executableName);
+                using (FileStream s = firstExe.Create()) { }
+
+                //Add the paths which will be copied to DCCOptionPaths
+                List<string> testPathList = new List<string>();
+                testPathList.Add(firstPath.FullName + executableName); //this path is valid!
+                testPathList.Add(secondPath.FullName + executableName);
+                testPathList.Add(null);
+                testPathList.Add("cookies/milk/foo/bar");
+
+                //Add the names which will be copied to DCCOptionNames
+                List<string> testNameList = new List<string>();
+                testNameList.Add(firstSubFolder.TrimStart('/'));
+                testNameList.Add(secondSubFolder.TrimStart('/'));
+                testNameList.Add(null);
+                testNameList.Add("Cookies & Milk");
+
+                ExportSettings.instance.SetDCCOptionNames(testNameList);
+                ExportSettings.instance.SetDCCOptionPaths(testPathList);
+
+                GUIContent[] options = ExportSettings.GetDCCOptions();
+
+                //We expect 1, as the others are purposefully bogus
+                Assert.AreEqual(options.Length, 1);
+
+                Assert.IsTrue(options[0].text == "maya 3000");
+            }
+            finally
+            {
+                Directory.Delete(testFolder, true);
+            }
+        }
+
+		[Test]
         public void FindDCCInstallsTest1()
         {
             string rootDir1 = GetRandomFileNamePath(extName: "");

Assets/FbxExporters/Editor/UnitTests/FbxPrefabTest.cs

@@ -425,10 +425,16 @@ public void TestTransformAndReparenting()
             var newCopyPath = ModelExporter.ExportObject(
                 GetRandomFbxFilePath(), root);
             SleepForFileTimestamp();
+
+            var destFile = new FbxPrefabAutoUpdater.FbxPrefabUtility (original.GetComponent<FbxPrefab> ()).GetFbxAssetPath ();
+            if (System.IO.File.Exists (destFile)) {
+                System.IO.File.Delete (destFile);
+            }
+            AssetDatabase.Refresh ();
             System.IO.File.Copy(
                 newCopyPath,
-                new FbxPrefabAutoUpdater.FbxPrefabUtility(original.GetComponent<FbxPrefab>()).GetFbxAssetPath(),
-                overwrite: true);
+                destFile,
+                overwrite: false);
             AssetDatabase.Refresh();
 
             // Make sure the update took.

Assets/FbxExporters/Editor/UnitTests/ModelExporterTest.cs

@@ -362,13 +362,24 @@ public void TestExportCamera(){
         /// <param name="filename">Filename.</param>
         /// <param name="cameraObj">Camera object.</param>
         private Camera ExportCamera(string filename, GameObject cameraObj){
-            ModelExporter.ExportObject (filename, cameraObj);
+            return ExportComponent<Camera> (filename, cameraObj);
+        }
+
+        /// <summary>
+        /// Exports the GameObject and returns component of type T.
+        /// </summary>
+        /// <returns>The component.</returns>
+        /// <param name="filename">Filename.</param>
+        /// <param name="obj">Object.</param>
+        /// <typeparam name="T">The component type.</typeparam>
+        private T ExportComponent<T>(string filename, GameObject obj) where T : Component {
+            ModelExporter.ExportObject (filename, obj);
 
             GameObject fbxObj = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject;
-            var fbxCamera = fbxObj.GetComponent<Camera> ();
+            var fbxComponent = fbxObj.GetComponent<T> ();
 
-            Assert.IsNotNull (fbxCamera);
-            return fbxCamera;
+            Assert.IsNotNull (fbxComponent);
+            return fbxComponent;
         }
 
         private void CompareCameraValues(Camera camera, Camera fbxCamera, float delta=0.001f){
@@ -377,5 +388,54 @@ private void CompareCameraValues(Camera camera, Camera fbxCamera, float delta=0.
             Assert.AreEqual (camera.nearClipPlane, fbxCamera.nearClipPlane, delta);
             Assert.AreEqual (camera.farClipPlane, fbxCamera.farClipPlane, delta);
         }
+
+        [Test]
+        public void TestExportLight()
+        {
+            // create a Unity light
+            GameObject lightObj = new GameObject("TestLight");
+            Light light = lightObj.AddComponent<Light> ();
+
+            light.type = LightType.Spot;
+            light.spotAngle = 55.4f;
+            light.color = Color.blue;
+            light.intensity = 2.3f;
+            light.range = 45;
+            light.shadows = LightShadows.Soft;
+
+            string filename = GetRandomFbxFilePath ();
+            var fbxLight = ExportComponent<Light> (filename, lightObj);
+            CompareLightValues (light, fbxLight);
+
+            light.type = LightType.Point;
+            light.color = Color.red;
+            light.intensity = 0.4f;
+            light.range = 120;
+            light.shadows = LightShadows.Hard;
+
+            filename = GetRandomFbxFilePath ();
+            fbxLight = ExportComponent<Light> (filename, lightObj);
+            CompareLightValues (light, fbxLight);
+        }
+
+        private void CompareLightValues(Light light, Light fbxLight, float delta=0.001f){
+            Assert.AreEqual (light.type, fbxLight.type);
+            if (light.type == LightType.Spot) {
+                Assert.AreEqual (light.spotAngle, fbxLight.spotAngle, delta);
+            }
+            Assert.AreEqual (light.color, fbxLight.color);
+            Assert.AreEqual (light.intensity, fbxLight.intensity, delta);
+            Assert.AreEqual (light.range, fbxLight.range, delta);
+
+            // compare shadows
+            // make sure that if we exported without shadows, don't import with shadows
+            if (light.shadows == LightShadows.None) {
+                Assert.AreEqual (LightShadows.None, fbxLight.shadows);
+            } else {
+                Assert.AreNotEqual (LightShadows.None, fbxLight.shadows);
+            }
+
+            Assert.IsTrue (light.transform.rotation == fbxLight.transform.rotation);
+        }
     }
 }