Update Tangent W calculation (#938)

* Update Tangent W calculation

W Tangent calculation was impacted by floating point rounding error and generate inverted vector randomly

* Aggregate calculation into MathUtilities function

* set default parameter value

Co-authored-by: Nicholas Barlow <whoisdrigax@gmail.com>

Author: pandaGaume

3ds Max/Max2Babylon/Exporter/BabylonExporter.Mesh.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using Newtonsoft.Json.Linq;
 using System.Globalization;
+using Utilities;
 
 namespace Max2Babylon
 {
@@ -1097,12 +1098,16 @@ int CreateGlobalVertex(IIGameMesh mesh, BabylonAbstractMesh babylonAbstractMesh,
             // tangent
             if (exportParameters.exportTangents)
             {
-                int indexTangentBinormal = mesh.GetFaceVertexTangentBinormal(face.MeshFaceIndex, facePart, 1);
-                IPoint3 normal = vertex.Normal.Normalize;
-                IPoint3 tangent = mesh.GetTangent(indexTangentBinormal, 1).Normalize;
-                IPoint3 bitangent = mesh.GetBinormal(indexTangentBinormal, 1).Normalize;
-                int w = GetW(normal, tangent, bitangent);
-                vertex.Tangent = new float[] { tangent.X, tangent.Y, tangent.Z, w };
+                int mapChannel = 1; // Texture Coordinates
+                if (mesh.GetNumberOfTangents(mapChannel) != 0)
+                {
+                    int indexTangentBinormal = mesh.GetFaceVertexTangentBinormal(face.MeshFaceIndex, facePart, mapChannel);
+                    IPoint3 normal = vertex.Normal.Normalize;
+                    IPoint3 tangent = mesh.GetTangent(indexTangentBinormal, mapChannel).Normalize;
+                    IPoint3 bitangent = mesh.GetBinormal(indexTangentBinormal, mapChannel).Normalize;
+                    float w = GetW(normal, tangent, bitangent);
+                    vertex.Tangent = new float[] { tangent.X, tangent.Y, tangent.Z, w };
+                }
             }
 
             if (hasUV)
@@ -1336,33 +1341,45 @@ public void GenerateCoordinatesAnimations(IIGameNode meshNode, List<BabylonAnima
         }
 
         /// <summary>
-        /// get the w of the tangent
+        /// get the w of the UV tangent
         /// </summary>
         /// <param name="normal"></param>
         /// <param name="tangent"></param>
         /// <param name="bitangent"></param>
         /// <returns>
-        /// -1 when the normal is not flipped
-        /// 1 when the normal is flipped
+        /// 1 when the bitangent is nearly 0,0,0 or is not flipped
+        /// -1 when the bitangent is flipped (oposite direction of the cross product of normal ^ tangent)
         /// </returns>
-        private int GetW(IPoint3 normal, IPoint3 tangent, IPoint3 bitangent)
+        private float GetW(IPoint3 normal, IPoint3 tangent, IPoint3 bitangent)
         {
-            //Cross product bitangent = w * normal ^ tangent
-            float x = normal.Y * tangent.Z - normal.Z * tangent.Y;
-            float y = normal.Z * tangent.X - normal.X * tangent.Z;
-            float z = normal.X * tangent.Y - normal.Y * tangent.X;
+            float btx = MathUtilities.RoundToIfAlmostEqualTo(bitangent.X, 0, Tools.Epsilon);
+            float bty = MathUtilities.RoundToIfAlmostEqualTo(bitangent.Y, 0, Tools.Epsilon);
+            float btz = MathUtilities.RoundToIfAlmostEqualTo(bitangent.Z, 0, Tools.Epsilon);
 
-            int w = Math.Sign(bitangent.X * x);
-            if (w == 0)
+            if( btx == 0 && bty == 0 && btz == 0)
             {
-                w = Math.Sign(bitangent.Y * y);
+                return 1;
             }
-            if (w == 0)
-            {
-                w = Math.Sign(bitangent.Z * z);
-            }
-
-            return w;
+ 
+            float nx = MathUtilities.RoundToIfAlmostEqualTo(normal.X, 0, Tools.Epsilon);
+            float ny = MathUtilities.RoundToIfAlmostEqualTo(normal.Y, 0, Tools.Epsilon);
+            float nz = MathUtilities.RoundToIfAlmostEqualTo(normal.Z, 0, Tools.Epsilon);
+
+            float tx = MathUtilities.RoundToIfAlmostEqualTo(tangent.X, 0, Tools.Epsilon);
+            float ty = MathUtilities.RoundToIfAlmostEqualTo(tangent.Y, 0, Tools.Epsilon);
+            float tz = MathUtilities.RoundToIfAlmostEqualTo(tangent.Z, 0, Tools.Epsilon);
+
+            // Cross product bitangent = w * normal ^ tangent
+
+            // theorical bittangent
+            MathUtilities.CrossProduct(nx, ny, nz, tx, ty, tz, out float x, out float y, out float z);
+ 
+            // Speaking in broadest terms, if the dot product of two non-zero vectors is positive, 
+            // then the two vectors point in the same general direction, meaning less than 90 degrees. 
+            // If the dot product is negative, then the two vectors point in opposite directions, 
+            // or above 90 and less than or equal to 180 degrees.
+            var dot = MathUtilities.DotProduct(btx, bty,btz, x,y,z);
+            return dot < 0 ? -1 : 1;
         }
 
     }

3ds Max/Max2Babylon/Exporter/GlobalVertex.cs

@@ -37,21 +37,21 @@ public GlobalVertex(GlobalVertex other)
 
         public override int GetHashCode()
         {
-            /*
-            return string.Format("{0}-{1}-{2}-{3}-{4}-{5}-{6}-{7}-{8}-{9}",
-                                    BaseIndex,
-                                    CurrentIndex,
-                                    Position != null ? Position.ToArray() : null,
-                                    Normal != null ? Normal.ToArray() : null,
-                                    Tangent,
-                                    UV != null ? UV.ToArray() : null,
-                                    UV2 != null ? UV.ToArray() : null,
-                                    BonesIndices,
-                                    Weights != null ? Weights.ToArray() : null,
-                                    BonesIndicesExtra,
-                                    WeightsExtra != null ? WeightsExtra.ToArray() : null,
-                                    Color).GetHashCode();
-            */
+          
+            //return string.Format("{0}-{1}-{2}-{3}-{4}-{5}-{6}-{7}-{8}-{9}",
+            //                        BaseIndex,
+            //                        CurrentIndex,
+            //                        Position != null ? Position.ToArray() : null,
+            //                        Normal != null ? Normal.ToArray() : null,
+            //                        Tangent,
+            //                        UV != null ? UV.ToArray() : null,
+            //                        UV2 != null ? UV.ToArray() : null,
+            //                        BonesIndices,
+            //                        Weights != null ? Weights.ToArray() : null,
+            //                        BonesIndicesExtra,
+            //                        WeightsExtra != null ? WeightsExtra.ToArray() : null,
+            //                        Color).GetHashCode();
+            
             return base.GetHashCode();
         }
 

SharedProjects/Utilities/MathUtilities.cs

@@ -1,12 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using BabylonExport.Entities;
 
 namespace Utilities
 {
     static class MathUtilities
     {
+        public const float Epsilon = 1E-7f;
         public static float GetLerpFactor(float from, float to, float value)
         {
             return (value - from) / (to - from);
@@ -53,11 +52,35 @@ public static int RoundToInt(float f)
             return Convert.ToInt32(Math.Round(f, MidpointRounding.AwayFromZero));
         }
 
-        public static bool IsAlmostEqualTo(float first, float second, float epsilon)
+        public static bool IsAlmostEqualTo(float first, float second, float epsilon = Epsilon)
         {
-            return Math.Abs(first - second) < epsilon;
+            return Math.Abs(first - second) <= epsilon;
         }
 
+        /// <summary>
+        /// This is used to round floating 
+        /// </summary>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <param name="epsilon"></param>
+        /// <returns></returns>
+        public static float RoundToIfAlmostEqualTo(float a, float b, float epsilon = Epsilon)
+        {
+            return Math.Abs(a - b) <= epsilon ? b : a ;
+        }
+
+        public static float DotProduct(float x1, float y1, float z1, float x2, float y2, float z2)
+        {
+            return x1 * x2 + y1 * y2 + z1 * z2;
+        }
+        public static void CrossProduct(float x1, float y1, float z1, float x2, float y2, float z2, out float x3, out float y3, out float z3)
+        {
+            x3 = y1 * z2 - z1 * y2;
+            y3 = z1 * x2 - x1 * z2;
+            z3 = x1 * y2 - y1 * x2;
+        }
+
+
         /**
          * Computes a texture transform matrix with a pre-transformation
          */