Merge pull request #393 from Unity-Technologies/Uni-45921-physical-camera

Uni-45921-physical-camera

Author: inwoods

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

@@ -0,0 +1,113 @@
+// NOTE: uncomment the next line to leave temporary FBX files on disk
+// and create a imported object in the scene.
+//#define DEBUG_UNITTEST
+
+using UnityEngine;
+using UnityEditor;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.Collections;
+using FbxExporters.CustomExtensions;
+using Unity.FbxSdk;
+
+namespace FbxExporters.UnitTests
+{
+    public class CustomExtensionsTest : ExporterTestBase
+    {
+        private float Value1 { get { return 1f; } }
+
+        [TearDown]
+        public override void Term ()
+        {
+            #if (!DEBUG_UNITTEST)
+            base.Term ();
+            #endif
+        }
+
+        [Test]
+        public void Vector3ExtensionTest()
+        {
+            var v3 = new Vector3(1f,2f,3f);
+            Assert.That(v3.RightHanded(), Is.EqualTo(new Vector3(-1f,2f,3f)));
+            Assert.That(v3.FbxVector4(), Is.EqualTo(new FbxVector4(1f,2f,3f)));
+        }
+
+        [Test]
+        public void AnimationCurveExtensionTest()
+        {
+            var ac = new AnimationCurve();
+            ac.Dump();
+            ac.Dump("hello world");
+            ac.Dump(keyTimesExpected:new float[]{});
+            ac.Dump(keyValuesExpected:new float[]{});
+            ac.Dump(keyTimesExpected:new float[]{}, keyValuesExpected:new float[]{});
+        }
+
+        [Test]
+        public void FloatExtensionTest()
+        {
+            Assert.That(Value1.Meters().ToCentimeters(), Is.EqualTo(100f));
+
+            Assert.That(1f.Meters(), Is.EqualTo(100f.Centimeters()));
+            Assert.That(10f.Millimeters().ToMeters(), Is.EqualTo(1f.Centimeters().ToMeters()).Within(0.00001f));
+            Assert.That(1f.Centimeters().ToMeters(), Is.EqualTo(10f.Millimeters().ToMeters()).Within(0.00001f));
+            Assert.That(0.0254f.Meters(), Is.EqualTo(1f.Inches().ToMetric()));
+            Assert.That(1f.Meters().ToImperial(), Is.EqualTo(39.3701f.Inches()));
+        }
+
+        [Test]
+        public void ImperialDistanceTest()
+        {
+            var one_inch = new ImperialDistance(1f); // 1 inch
+            var one_foot = new ImperialDistance(12f); // 12 inches
+
+            Assert.That(ImperialDistance.Inch, Is.Not.EqualTo(new MetricDistance(1f)));
+            Assert.That(ImperialDistance.Inch, Is.EqualTo(new ImperialDistance(1f)));
+            Assert.That(ImperialDistance.Foot, Is.EqualTo(new ImperialDistance(12f)));
+
+            Assert.That(one_inch, Is.EqualTo(ImperialDistance.Inch));
+            Assert.That(one_inch.ToInches(), Is.EqualTo(ImperialDistance.Inch.ToInches()));
+            Assert.That(one_inch.ToMetric().ToMeters(), Is.EqualTo(0.0254f));
+            Assert.That(one_inch.ToMeters(), Is.EqualTo(0.0254f));
+            Assert.That(one_inch.ToInches(), Is.EqualTo(1f));
+            Assert.That(one_inch.GetHashCode(), Is.GreaterThan(0));
+            Assert.That(one_inch ==  ImperialDistance.Inch, Is.True);
+            Assert.That(one_inch ==  ImperialDistance.Inch, Is.True);
+
+            Assert.That(one_foot, Is.EqualTo(ImperialDistance.Foot));
+            Assert.That(one_foot!=one_inch, Is.True);
+
+            Assert.That(one_inch+one_inch, Is.EqualTo(new ImperialDistance(2f)));
+            Assert.That(one_inch-one_inch, Is.EqualTo(new ImperialDistance(0f)));
+            Assert.That(new ImperialDistance(2f)*new ImperialDistance(6f), Is.EqualTo(ImperialDistance.Foot));
+            Assert.That(ImperialDistance.Foot / ImperialDistance.Inch, Is.EqualTo(ImperialDistance.Foot));
+        }
+
+        [Test]
+        public void MetricDistanceTest()
+        {
+            var one_cm = new MetricDistance(0.01f); // 1 cm
+            var one_m = new MetricDistance(1f); // 100 cm
+
+            Assert.That(MetricDistance.Millimeter, Is.EqualTo(new MetricDistance(0.001f)));
+            Assert.That(MetricDistance.Centimeter, Is.EqualTo(new MetricDistance(0.01f)));
+            Assert.That(MetricDistance.Meter, Is.EqualTo(new MetricDistance(1f)));
+
+            Assert.That(one_m, Is.EqualTo(MetricDistance.Meter));
+            Assert.That(one_m.ToMeters(), Is.EqualTo(MetricDistance.Meter.ToMeters()));
+            Assert.That(one_m.ToImperial().ToInches(), Is.EqualTo(39.3701f));
+            Assert.That(one_m.ToMeters(), Is.EqualTo(1f));
+            Assert.That(one_m.GetHashCode(), Is.GreaterThan(0));
+            Assert.That(one_m ==  MetricDistance.Meter, Is.True);
+            Assert.That(one_cm ==  MetricDistance.Centimeter, Is.True);
+
+            Assert.That(one_m, Is.EqualTo(MetricDistance.Meter));
+            Assert.That(one_m!=one_cm, Is.True);
+
+            Assert.That(one_m+one_cm, Is.EqualTo(new MetricDistance(1.01f)));
+            Assert.That(one_m-one_cm, Is.EqualTo(new MetricDistance(0.99f)));
+            Assert.That(MetricDistance.Centimeter*MetricDistance.Meter, Is.EqualTo(new MetricDistance(0.01f)));
+            Assert.That(MetricDistance.Meter / MetricDistance.Centimeter, Is.EqualTo(new MetricDistance(100f)));
+        }
+    }
+}

Assets/com.unity.formats.fbx.tests/CustomExtensionsTest.cs.meta

@@ -1,4 +1,4 @@
-// NOTE: uncomment the next line to leave temporary FBX files on disk
+// NOTE: uncomment the next line to leave temporary FBX files on disk
 // and create a imported object in the scene.
 //#define DEBUG_UNITTEST
 
@@ -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,81 @@ 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));
+        }
+
+        [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));
+        }
     }
 }

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

@@ -0,0 +1,111 @@
+using UnityEngine;
+using Unity.FbxSdk;
+using FbxExporters.CustomExtensions;
+
+namespace FbxExporters
+{
+    namespace Visitors
+    {
+        internal static class CameraVisitor
+        {
+            /// <summary>
+            /// Visit Object and configure FbxCamera
+            /// </summary>
+            public static void ConfigureCamera (Camera unityCamera, FbxCamera fbxCamera)
+            {
+                if (unityCamera.usePhysicalProperties) 
+                    ConfigurePhysicalCamera(fbxCamera, unityCamera);
+                else 
+                    ConfigureGameCamera(fbxCamera, unityCamera);
+            }
+
+            /// <summary>
+            /// Configure FbxCameras from GameCamera 
+            /// </summary>
+            private static void 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 ;
+            }
+
+            /// <summary>
+            /// Configure FbxCameras from a Physical Camera 
+            /// </summary>
+            private static void 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 ;
+            }
+        }
+    }
+}
+