add unit tests

Author: inwoods

Assets/com.unity.formats.fbx.tests/FbxCameraTests.cs

@@ -7,11 +7,14 @@
 using NUnit.Framework;
 using System.Collections.Generic;
 using System.Collections;
+using FbxExporters.CustomExtensions;
 
 namespace FbxExporters.UnitTests
 {
     public class FbxCameraTest : ExporterTestBase
     {
+        const float EPSILON = 0.00001f;
+
         [TearDown]
         public override void Term ()
         {
@@ -34,5 +37,84 @@ public void AnimationWithCameraFOVTest()
 
             tester.DoIt();
         }
+
+        [Test]
+        public void GameCameraTest()
+        {
+            var filename = GetRandomFileNamePath();
+
+            var original = FbxAnimationTest.AnimTester.CreateTargetObject("GameCamera", typeof (Camera));
+
+            var origCam = original.GetComponent<Camera>();
+
+            // Configure Game Camera 
+            origCam.fieldOfView = 59;
+                
+            // FBX Value range is [0.001, 600000.0] centimeters
+            // Unity Property Inspector range is [0.01, MAX_FLT] meters
+            // Unity Importer range is [0.3, MAX_FLT] meters
+            origCam.nearClipPlane = 30f.Centimeters().ToMeters(); // minumum
+            origCam.farClipPlane = 6000f;
+
+            // Convert it to FBX. The asset file will be deleted automatically
+            // on termination.
+            var fbxAsset = FbxExporters.Editor.ModelExporter.ExportObject(
+                filename, original);
+
+            // refresh the assetdata base so that we can query for the model
+            AssetDatabase.Refresh ();
+
+            var source = AssetDatabase.LoadMainAssetAtPath(fbxAsset) as GameObject;
+            var srcCam = source.GetComponent<Camera>();
+
+            Assert.That( srcCam.aspect, Is.EqualTo(origCam.aspect));
+            Assert.That( srcCam.fieldOfView, Is.EqualTo(origCam.fieldOfView));
+            Assert.That( srcCam.farClipPlane, Is.EqualTo(origCam.farClipPlane));
+            Assert.That( srcCam.nearClipPlane, Is.EqualTo(origCam.nearClipPlane));
+        }
+
+        #if UNITY_2018_2_OR_NEWER || UNITY_2018_2_OR_LATER
+        [Test]
+        public void PhysicalCameraTest()
+        {
+            var filename = GetRandomFileNamePath();
+
+            var original = FbxAnimationTest.AnimTester.CreateTargetObject("GameCamera", typeof (Camera));
+
+            var origCam = original.GetComponent<Camera>();
+
+            // Configure FilmBack Super 8mm, 5.79f x 4.01mm
+            origCam.usePhysicalProperties = true;
+            origCam.aspect = 4.01f / 5.79f;
+            origCam.focalLength = 50f.Centimeters().ToMillimeters();
+            origCam.sensorSize = new Vector2(5.79f, 4.01f);
+
+            // Lens Shift ( Film Offset ) as a percentage between 0 and 1
+            origCam.lensShift = new Vector2(1f, 1f);
+
+            origCam.nearClipPlane = 30f.Centimeters().ToMeters();
+            origCam.farClipPlane = 600000f.Centimeters().ToMeters();
+
+            // Convert it to FBX. The asset file will be deleted automatically
+            // on termination.
+            var fbxAsset = FbxExporters.Editor.ModelExporter.ExportObject(
+                filename, original);
+            
+            var source = AssetDatabase.LoadMainAssetAtPath(fbxAsset) as GameObject;
+            var srcCam = source.GetComponent<Camera>();
+
+            Assert.That( srcCam.fieldOfView, Is.EqualTo(origCam.fieldOfView).Within(EPSILON));
+            Assert.That( srcCam.focalLength, Is.EqualTo(origCam.focalLength));
+            Assert.That( srcCam.sensorSize.x, Is.EqualTo(origCam.sensorSize.x).Within(EPSILON));
+            Assert.That( srcCam.sensorSize.y, Is.EqualTo(origCam.sensorSize.y).Within(EPSILON));
+            Assert.That( srcCam.usePhysicalProperties, Is.EqualTo(origCam.usePhysicalProperties));
+            Assert.That( srcCam.lensShift.x, Is.EqualTo(origCam.lensShift.x).Within(EPSILON));
+            Assert.That( srcCam.lensShift.y, Is.EqualTo(origCam.lensShift.y).Within(EPSILON));
+            Assert.That( srcCam.aspect, Is.EqualTo(origCam.aspect).Within(EPSILON));
+            Assert.That( srcCam.nearClipPlane, Is.EqualTo(origCam.nearClipPlane));
+            Assert.That( srcCam.farClipPlane, Is.EqualTo(origCam.farClipPlane));
+        }
+
+        #endif
     }
 }

Packages/com.unity.formats.fbx/Editor/Integrations.meta

@@ -0,0 +1,119 @@
+using System;
+using UnityEngine;
+using Unity.FbxSdk;
+using FbxExporters.CustomExtensions;
+
+namespace FbxExporters
+{
+    namespace Visitors
+    {
+        public static class CameraVisitor
+        {
+            /// <summary>
+            /// Visit Object and configure FbxCamera
+            /// </summary>
+            public static FbxNodeAttribute VisitNodeAttribute (UnityEngine.Object unityGo, FbxNodeAttribute fbxNodeAttr)
+            {
+                #if UNITY_2018_2_OR_NEWER
+                Camera unityCamera = unityGo as Camera;
+
+                return unityCamera.usePhysicalProperties 
+                    ? ConfigurePhysicalCamera(fbxNodeAttr as FbxCamera, unityCamera) 
+                        : ConfigureGameCamera(fbxNodeAttr as FbxCamera, unityCamera);
+                #else
+                return ConfigureGameCamera(fbxCamera as FbxCamera, unityGo as Camera);
+                #endif
+            }
+
+            /// <summary>
+            /// Configure FbxCameras from GameCamera 
+            /// </summary>
+            private static FbxCamera ConfigureGameCamera (FbxCamera fbxCamera, Camera unityCamera)
+            {
+                // Configure FilmBack settings as a 35mm TV Projection (0.816 x 0.612)
+                float aspectRatio = unityCamera.aspect;
+
+                float apertureHeightInInches = 0.612f;
+                float apertureWidthInInches = aspectRatio * apertureHeightInInches;
+
+                FbxCamera.EProjectionType projectionType =
+                    unityCamera.orthographic ? FbxCamera.EProjectionType.eOrthogonal : FbxCamera.EProjectionType.ePerspective;
+
+                fbxCamera.ProjectionType.Set(projectionType);
+                fbxCamera.FilmAspectRatio.Set(aspectRatio);
+                fbxCamera.SetApertureWidth (apertureWidthInInches);
+                fbxCamera.SetApertureHeight (apertureHeightInInches);
+                fbxCamera.SetApertureMode (FbxCamera.EApertureMode.eVertical);
+
+                // Focal Length
+                double focalLength = fbxCamera.ComputeFocalLength (unityCamera.fieldOfView);
+
+                fbxCamera.FocalLength.Set(focalLength);
+
+                // Field of View
+                fbxCamera.FieldOfView.Set (unityCamera.fieldOfView);
+
+                // NearPlane
+                fbxCamera.SetNearPlane (unityCamera.nearClipPlane.Meters().ToCentimeters());
+
+                // FarPlane
+                fbxCamera.SetFarPlane (unityCamera.farClipPlane.Meters().ToCentimeters());
+
+                return fbxCamera;
+            }
+
+            #if UNITY_2018_2_OR_NEWER || UNITY_2018_2_OR_LATER
+            /// <summary>
+            /// Configure FbxCameras from a Physical Camera 
+            /// </summary>
+            private static FbxCamera ConfigurePhysicalCamera (FbxCamera fbxCamera, Camera unityCamera)
+            {
+                Debug.Assert(unityCamera.usePhysicalProperties);
+
+                // Configure FilmBack settings
+                float apertureHeightInInches = unityCamera.sensorSize.y.Millimeters().ToInches();
+                float apertureWidthInInches = unityCamera.sensorSize.x.Millimeters().ToInches();
+                float aspectRatio = apertureWidthInInches / apertureHeightInInches;
+
+                FbxCamera.EProjectionType projectionType = unityCamera.orthographic 
+                    ? FbxCamera.EProjectionType.eOrthogonal 
+                    : FbxCamera.EProjectionType.ePerspective;
+
+                // NOTE: it is possible to match some of the sensor sizes to the  
+                // predefined EApertureFormats : e16mmTheatrical, eSuper16mm, 
+                // e35mmFullAperture, eIMAX. However the round in the sizes is not
+                // consistent between Unity and FBX so we choose
+                // to leave the values as a eCustomAperture setting.
+
+                fbxCamera.ProjectionType.Set(projectionType);
+                fbxCamera.FilmAspectRatio.Set(aspectRatio);
+                fbxCamera.SetApertureWidth (apertureWidthInInches);
+                fbxCamera.SetApertureHeight (apertureHeightInInches);
+
+                // Fit the resolution gate horizontally within the film gate.
+                fbxCamera.GateFit.Set(FbxCamera.EGateFit.eFitHorizontal);
+
+                // Lens Shift ( Film Offset ) as a percentage 0..1
+                // FBX FilmOffset is in inches
+                fbxCamera.FilmOffsetX.Set(apertureWidthInInches * Mathf.Clamp(unityCamera.lensShift.x, 0f, 1f));
+                fbxCamera.FilmOffsetY.Set(apertureHeightInInches * Mathf.Clamp(unityCamera.lensShift.y, 0f, 1f));
+
+                // Focal Length
+                fbxCamera.SetApertureMode (FbxCamera.EApertureMode.eFocalLength); 
+
+                double focalLength = (double)unityCamera.focalLength;
+                fbxCamera.FocalLength.Set(focalLength); /* in millimeters */
+
+                // NearPlane
+                fbxCamera.SetNearPlane ((double)unityCamera.nearClipPlane.Meters().ToCentimeters());
+
+                // FarPlane
+                fbxCamera.SetFarPlane ((float)unityCamera.farClipPlane.Meters().ToCentimeters());
+
+                return fbxCamera;
+            }
+            #endif
+        }
+    }
+}
+