Merge pull request #257 from Unity-Technologies/UNI-29415-export-lights

Uni 29415 export lights

Author: inwoods

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>
@@ -838,6 +845,76 @@ protected bool ExportCamera (GameObject unityGO, FbxScene fbxScene, FbxNode fbxN
                 return true;
             }
 
+            /// <summary>
+            /// Exports light component.
+            /// Supported types: point, spot and directional
+            /// Cookie => Gobo
+            /// </summary>
+            protected bool ExportLight (GameObject unityGo, FbxScene fbxScene, FbxNode fbxNode)
+            {
+                Light unityLight = unityGo.GetComponent<Light> ();
+
+                if (unityLight == null)
+                    return false;
+
+                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));
+
+                // 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*/ );
+
+                // 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);
+
+                // 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>
             /// configures default camera for the scene
             /// </summary>
@@ -911,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)

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);
+        }
     }
 }