Merge pull request #277 from unity3d-jp/blendshape_support

Uni-35840-Blendshape support

Author: inwoods

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -426,6 +426,86 @@ private static bool ExportUVs(FbxMesh fbxMesh, MeshInfo mesh, int[] unmergedTria
                 return k > 0;
             }
 
+            /// <summary>
+            /// Export the mesh's blend shapes.
+            /// </summary>
+            private bool ExportBlendShapes(MeshInfo mesh, FbxMesh fbxMesh, FbxScene fbxScene, int[] unmergedTriangles)
+            {
+                var umesh = mesh.mesh;
+                if (umesh.blendShapeCount == 0)
+                    return false;
+
+                var fbxBlendShape = FbxBlendShape.Create(fbxScene, umesh.name + "_BlendShape");
+                fbxMesh.AddDeformer(fbxBlendShape);
+
+                var numVertices = umesh.vertexCount;
+                var basePoints = umesh.vertices;
+                var baseNormals = umesh.normals;
+                var baseTangents = umesh.tangents;
+                var deltaPoints = new Vector3[numVertices];
+                var deltaNormals = new Vector3[numVertices];
+                var deltaTangents = new Vector3[numVertices];
+
+                for (int bi = 0; bi < umesh.blendShapeCount; ++bi)
+                {
+                    var bsName = umesh.GetBlendShapeName(bi);
+                    var numFrames = umesh.GetBlendShapeFrameCount(bi);
+                    var fbxChannel = FbxBlendShapeChannel.Create(fbxScene, bsName);
+                    fbxBlendShape.AddBlendShapeChannel(fbxChannel);
+
+                    for (int fi = 0; fi < numFrames; ++fi)
+                    {
+                        var weight = umesh.GetBlendShapeFrameWeight(bi, fi);
+                        umesh.GetBlendShapeFrameVertices(bi, fi, deltaPoints, deltaNormals, deltaTangents);
+
+                        var fbxShape = FbxShape.Create(fbxScene, "");
+                        fbxChannel.AddTargetShape(fbxShape, weight);
+
+                        // control points
+                        fbxShape.InitControlPoints(ControlPointToIndex.Count());
+                        for (int vi = 0; vi < numVertices; ++vi)
+                        {
+                            int ni = ControlPointToIndex[basePoints[vi]];
+                            var v = basePoints[vi] + deltaPoints[vi];
+                            fbxShape.SetControlPointAt(ConvertToRightHanded(v, UnitScaleFactor), ni);
+                        }
+
+                        // normals
+                        if (mesh.HasValidNormals())
+                        {
+                            var elemNormals = fbxShape.CreateElementNormal();
+                            elemNormals.SetMappingMode(FbxLayerElement.EMappingMode.eByPolygonVertex);
+                            elemNormals.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
+                            var dstNormals = elemNormals.GetDirectArray();
+                            dstNormals.SetCount(unmergedTriangles.Length);
+                            for (int ii = 0; ii < unmergedTriangles.Length; ++ii)
+                            {
+                                int vi = unmergedTriangles[ii];
+                                var n = baseNormals[vi] + deltaNormals[vi];
+                                dstNormals.SetAt(ii, ConvertToRightHanded(n));
+                            }
+                        }
+
+                        // tangents
+                        if (mesh.HasValidTangents())
+                        {
+                            var elemTangents = fbxShape.CreateElementTangent();
+                            elemTangents.SetMappingMode(FbxLayerElement.EMappingMode.eByPolygonVertex);
+                            elemTangents.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
+                            var dstTangents = elemTangents.GetDirectArray();
+                            dstTangents.SetCount(unmergedTriangles.Length);
+                            for (int ii = 0; ii < unmergedTriangles.Length; ++ii)
+                            {
+                                int vi = unmergedTriangles[ii];
+                                var t = (Vector3)baseTangents[vi] + deltaTangents[vi];
+                                dstTangents.SetAt(ii, ConvertToRightHanded(t));
+                            }
+                        }
+                    }
+                }
+                return true;
+            }
+
             /// <summary>
             /// Takes in a left-handed UnityEngine.Vector3 denoting a normal,
             /// returns a right-handed FbxVector4.
@@ -754,6 +834,9 @@ bool ExportMesh (MeshInfo meshInfo, FbxNode fbxNode)
                 // Set up normals, etc.
                 ExportComponentAttributes (meshInfo, fbxMesh, unmergedPolygons.ToArray());
 
+                // Set up blend shapes.
+                ExportBlendShapes(meshInfo, fbxMesh, fbxScene, unmergedPolygons.ToArray());
+
                 // set the fbxNode containing the mesh
                 fbxNode.SetNodeAttribute (fbxMesh);
                 fbxNode.SetShadingMode (FbxNode.EShadingMode.eWireFrame);
@@ -781,31 +864,28 @@ SkinnedMeshRenderer unitySkin
                     Debug.Log (string.Format ("exporting {0} {1}", "Skin", fbxNode.GetName ()));
 
 
-                Dictionary<SkinnedMeshRenderer, Transform[]> skinnedMeshToBonesMap;
-                // export skeleton
-                if (!ExportSkeleton (unitySkin, fbxScene, out skinnedMeshToBonesMap)) {
-                    Debug.LogWarning ("failed to export skeleton");
-                    return false;
-                }
-
-                var meshInfo = new MeshInfo (unitySkin.sharedMesh, unitySkin.sharedMaterials);
+                var meshInfo = new MeshInfo(unitySkin.sharedMesh, unitySkin.sharedMaterials);
 
-                // export skin mesh
                 FbxMesh fbxMesh = null;
-                if (ExportMesh (meshInfo, fbxNode)) {
-                    fbxMesh = fbxNode.GetMesh ();
+                if (ExportMesh(meshInfo, fbxNode))
+                {
+                    fbxMesh = fbxNode.GetMesh();
                 }
-
-                if (fbxMesh == null) {
-                    Debug.LogError ("Could not find mesh");
+                if (fbxMesh == null)
+                {
+                    Debug.LogError("Could not find mesh");
                     return false;
                 }
 
-                // bind mesh to skeleton
-                ExportSkin (unitySkin, meshInfo, fbxScene, fbxMesh, fbxNode);
+                Dictionary<SkinnedMeshRenderer, Transform[]> skinnedMeshToBonesMap;
+                // export skeleton
+                if (ExportSkeleton (unitySkin, fbxScene, out skinnedMeshToBonesMap)) {
+                    // bind mesh to skeleton
+                    ExportSkin (unitySkin, meshInfo, fbxScene, fbxMesh, fbxNode);
 
-                // add bind pose
-                ExportBindPose (unitySkin, fbxNode, fbxScene, skinnedMeshToBonesMap);
+                    // add bind pose
+                    ExportBindPose (unitySkin, fbxNode, fbxScene, skinnedMeshToBonesMap);
+                }
 
                 return true;
             }

Assets/FbxExporters/Editor/UnitTests/FbxAnimationTest.cs

@@ -90,6 +90,13 @@ public static IEnumerable SkinnedMeshTestCases {
                 yield return "Models/DefaultMale/Male_DyingHitFromBack_Blend_T3_Cut01_James.fbx";
             }
         }
+
+        public static IEnumerable BlendShapeTestCases {
+            get {
+                yield return "FbxExporters/Editor/UnitTests/Models/blendshape.fbx";
+                yield return "FbxExporters/Editor/UnitTests/Models/blendshape_with_skinning.fbx";
+            }
+        }
     }
 
     [TestFixture]

Assets/FbxExporters/Editor/UnitTests/ModelExporterTest.cs

@@ -677,5 +677,77 @@ public void TestBoneWeightExport(string fbxPath){
             }
             Debug.LogWarningFormat ("Compared {0} out of a possible {1} bone weights", comparisonCount, minVertCount);
         }
+
+
+        public class Vector3Comparer : IComparer<Vector3>
+        {
+            public int Compare(Vector3 a, Vector3 b)
+            {
+                Assert.That(a.x, Is.EqualTo(b.x).Within(0.00001f));
+                Assert.That(a.y, Is.EqualTo(b.y).Within(0.00001f));
+                Assert.That(a.z, Is.EqualTo(b.z).Within(0.00001f));
+                return 0;  // we're almost equal
+            }
+        }
+
+        [Test, TestCaseSource(typeof(AnimationTestDataClass), "BlendShapeTestCases")]
+        public void TestBlendShapeExport(string fbxPath)
+        {
+            // add fbx to scene
+            GameObject originalFbxObj = AssetDatabase.LoadMainAssetAtPath("Assets/" + fbxPath) as GameObject;
+            Assert.IsNotNull(originalFbxObj);
+            GameObject originalGO = GameObject.Instantiate(originalFbxObj);
+            Assert.IsTrue(originalGO);
+
+            // export fbx
+            // get GameObject
+            string filename = GetRandomFbxFilePath();
+            ModelExporter.ExportObject(filename, originalGO);
+            GameObject fbxObj = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject;
+            Assert.IsTrue(fbxObj);
+
+            var originalSMR = originalGO.GetComponentInChildren<SkinnedMeshRenderer>();
+            var exportedSMR = fbxObj.GetComponentInChildren<SkinnedMeshRenderer>();
+            Assert.IsNotNull(originalSMR);
+            Assert.IsNotNull(exportedSMR);
+
+            var originalMesh = originalSMR.sharedMesh;
+            var exportedMesh = exportedSMR.sharedMesh;
+            Assert.IsNotNull(originalMesh);
+            Assert.IsNotNull(exportedMesh);
+
+            // compare blend shape data
+            Assert.AreNotEqual(originalMesh.blendShapeCount, 0);
+            Assert.AreEqual(originalMesh.blendShapeCount, exportedMesh.blendShapeCount);
+            {
+                var deltaVertices = new Vector3[originalMesh.vertexCount];
+                var deltaNormals = new Vector3[originalMesh.vertexCount];
+                var deltaTangents = new Vector3[originalMesh.vertexCount];
+                var fbxDeltaVertices = new Vector3[originalMesh.vertexCount];
+                var fbxDeltaNormals = new Vector3[originalMesh.vertexCount];
+                var fbxDeltaTangents = new Vector3[originalMesh.vertexCount];
+
+                for (int bi = 0; bi < originalMesh.blendShapeCount; ++bi)
+                {
+                    Assert.AreEqual(originalMesh.GetBlendShapeName(bi), exportedMesh.GetBlendShapeName(bi));
+                    Assert.AreEqual(originalMesh.GetBlendShapeFrameCount(bi), exportedMesh.GetBlendShapeFrameCount(bi));
+
+                    int frameCount = originalMesh.GetBlendShapeFrameCount(bi);
+                    for (int fi = 0; fi < frameCount; ++fi)
+                    {
+                        Assert.AreEqual(originalMesh.GetBlendShapeFrameWeight(bi, fi), exportedMesh.GetBlendShapeFrameWeight(bi, fi));
+
+                        originalMesh.GetBlendShapeFrameVertices(bi, fi, deltaVertices, deltaNormals, deltaTangents);
+                        exportedMesh.GetBlendShapeFrameVertices(bi, fi, fbxDeltaVertices, fbxDeltaNormals, fbxDeltaTangents);
+
+                        var v3comparer = new Vector3Comparer();
+                        Assert.That(deltaVertices, Is.EqualTo(fbxDeltaVertices).Using<Vector3>(v3comparer), string.Format("delta vertices don't match"));
+                        Assert.That(deltaNormals, Is.EqualTo(fbxDeltaNormals).Using<Vector3>(v3comparer), string.Format("delta normals don't match"));
+                        Assert.That(deltaTangents, Is.EqualTo(fbxDeltaTangents).Using<Vector3>(v3comparer), string.Format("delta tangents don't match"));
+
+                    }
+                }
+            }
+        }
     }
 }