Fixed morph targets to not be 0 index based (#1110)

SergioRZMasson · web-flow · commit c31ed63269a7 · 2024-01-25T15:53:28.000-03:00
* Fixed morph targets to not be 0 index based
diff --git a/3ds Max/Max2Babylon/Exporter/BabylonExporter.Mesh.cs b/3ds Max/Max2Babylon/Exporter/BabylonExporter.Mesh.cs
@@ -125,11 +125,11 @@ private BabylonNode ExportMesh(IIGameScene scene, IIGameNode meshNode, BabylonSc
                         {
                             bool isShareMat = masterMeshPair.Key.materialId == null || (meshNode.NodeMaterial != null && meshNode.NodeMaterial.MaxMaterial.GetGuid().ToString().Equals(masterMeshPair.Value.NodeMaterial.MaxMaterial.GetGuid().ToString()));
 
-                            BabylonNode n = isShareMat?
+                            BabylonNode n = isShareMat ?
                                 ExportInstanceMesh(scene, meshNode, babylonScene, masterMeshPair.Key, masterMeshPair.Value) :
                                 exportParameters.useClone ? ExportCloneMesh(scene, meshNode, babylonScene, masterMeshPair.Key, masterMeshPair.Value) : null;
-                            
-                            if( n != null)
+
+                            if (n != null)
                             {
                                 return n;
                             }
@@ -469,7 +469,7 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab
                         babylonMesh.colors = colors;
                         babylonMesh.hasVertexAlpha = hasAlpha;
                     }
-                    
+
                 }
 
                 babylonMesh.subMeshes = subMeshes.ToArray();
@@ -527,14 +527,14 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab
                             var maxMorphTarget = morpher.GetMorphTarget(i);
                             // here we avoid to extract vertices in an optimize way, du to the fact that the actual optimize process is NOT garanty to keep a one to one relationship
                             // with the source and target vertices.
-                            bool mustRebuildMorphTarget = (maxMorphTarget == null || optimizeVertices );
+                            bool mustRebuildMorphTarget = (maxMorphTarget == null || optimizeVertices);
                             if (mustRebuildMorphTarget)
                             {
                                 string actionStr = exportParameters.rebuildMorphTarget ? $" trying to rebuild {i}." : string.Empty;
                                 if (maxMorphTarget == null)
                                 {
                                     RaiseWarning($"Morph target [{i}] is not available anymore - ie: has been deleted in max and is baked into the scene.{actionStr}", 3);
-                                } 
+                                }
                                 else
                                 {
                                     RaiseWarning($"Morph target [{i}] MUST be rebuilt to avoid artifacts, using the vertices export process.{actionStr}", 3);
@@ -550,13 +550,13 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab
                                 var babylonMorphTarget = new BabylonMorphTarget
                                 {
                                     // the name is reconstructed if we have to rebuild the target
-                                    name = maxMorphTarget?.Name ?? $"{meshNode.Name}.morpher({m}).target({i})" 
+                                    name = maxMorphTarget?.Name ?? $"{meshNode.Name}.morpher({m}).target({i})"
                                 };
                                 babylonMorphTargets.Add(babylonMorphTarget);
-                                RaiseMessage($"Morph target {babylonMorphTarget.name} added.",3);
+                                RaiseMessage($"Morph target {babylonMorphTarget.name} added.", 3);
 
                                 // TODO - Influence
-                                babylonMorphTarget.influence = 0f; 
+                                babylonMorphTarget.influence = 0f;
 
                                 // Target geometry
                                 babylonMorphTarget.positions = targetVertices.SelectMany(v => new[] { v.Position.X, v.Position.Y, v.Position.Z }).ToArray();
@@ -566,7 +566,7 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab
                                     if (mustRebuildMorphTarget)
                                     {
                                         // we do not recontruct the normals
-                                        RaiseWarning("we do not have morph normals when morph target has been rebuilded.",4);
+                                        RaiseWarning("we do not have morph normals when morph target has been rebuilded.", 4);
                                         babylonMorphTarget.normals = null;
                                     }
                                     else
@@ -656,7 +656,7 @@ private IEnumerable<IPoint3> ExtractMorphTargetPoints(BabylonAbstractMesh babylo
             // this is the place where we reconstruct the vertices. 
             // the needed function is not available on the .net SDK, then we have to use Max Script.
             // TODO : use direct instance instead of manipulate string
-            var script = $"with printAllElements on (for k in 0 to (WM3_MC_NumMPts ${babylonAbstractMesh.name}.Morpher {morphIndex}) collect (WM3_MC_GetMorphPoint ${babylonAbstractMesh.name}.morpher {morphIndex} k)) as string";
+            var script = $"with printAllElements on (for k in 0 to (WM3_MC_NumMPts ${babylonAbstractMesh.name}.Morpher {morphIndex + 1}) collect (WM3_MC_GetMorphPoint ${babylonAbstractMesh.name}.morpher {morphIndex + 1} k)) as string";
 #if MAX2022 || MAX2023 || MAX2024
             var str = ManagedServices.MaxscriptSDK.ExecuteStringMaxscriptQuery(script, ManagedServices.MaxscriptSDK.ScriptSource.NotSpecified);
 #else
@@ -920,7 +920,7 @@ private void ExtractGeometry(BabylonAbstractMesh babylonAbstractMesh, List<Globa
                 // Material Id is 0 if normal material, and GetMaterialID if multi-material
                 // default is [1,n] increment by 1 but user can decide to change the id (still an int) and set for example [4,3,9,1]
                 // note that GetMaterialID return the user id minus 1
-                int materialId = multiMatsCount == 1? i : meshNode.NodeMaterial.GetMaterialID(i);
+                int materialId = multiMatsCount == 1 ? i : meshNode.NodeMaterial.GetMaterialID(i);
                 var subMesh = new BabylonSubMesh { indexStart = indexStart, materialIndex = i };
                 if (multiMatsCount == 1)
                 {
@@ -1135,7 +1135,7 @@ int CreateGlobalVertex(IIGameMesh mesh, BabylonAbstractMesh babylonAbstractMesh,
                     }
                 }
                 var texCoord = mesh.GetMapVertex(1, indices[facePart]);
-                vertex.UV = Loader.Global.Point2.Create(texCoord.X, 1 -texCoord.Y);
+                vertex.UV = Loader.Global.Point2.Create(texCoord.X, 1 - texCoord.Y);
             }
 
             if (hasUV2)
@@ -1149,7 +1149,7 @@ int CreateGlobalVertex(IIGameMesh mesh, BabylonAbstractMesh babylonAbstractMesh,
                     }
                 }
                 var texCoord = mesh.GetMapVertex(2, indices[facePart]);
-                vertex.UV2 = Loader.Global.Point2.Create(texCoord.X, 1 -texCoord.Y);
+                vertex.UV2 = Loader.Global.Point2.Create(texCoord.X, 1 - texCoord.Y);
             }
 
             if (hasColor)
@@ -1330,9 +1330,9 @@ private void exportAnimation(BabylonNode babylonNode, IIGameNode maxGameNode)
             if (exportParameters.exportAnimations)
             {
                 var animations = new List<BabylonAnimation>();
-                
+
                 GenerateCoordinatesAnimations(maxGameNode, animations);
-                
+
                 if (!ExportFloatController(maxGameNode.MaxNode.VisController, "visibility", animations))
                 {
                     ExportFloatAnimation("visibility", animations, key => new[] { maxGameNode.MaxNode.GetVisibility(key, Tools.Forever) });
@@ -1373,7 +1373,7 @@ private float GetW(IPoint3 normal, IPoint3 tangent, IPoint3 bitangent)
             float bty = MathUtilities.RoundToIfAlmostEqualTo(bitangent.Y, 0, Tools.Epsilon);
             float btz = MathUtilities.RoundToIfAlmostEqualTo(bitangent.Z, 0, Tools.Epsilon);
 
-            if( btx == 0 && bty == 0 && btz == 0)
+            if (btx == 0 && bty == 0 && btz == 0)
             {
                 return 1;
             }
@@ -1395,7 +1395,7 @@ private float GetW(IPoint3 normal, IPoint3 tangent, IPoint3 bitangent)
             // 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);
+            var dot = MathUtilities.DotProduct(btx, bty, btz, x, y, z);
             return dot < 0 ? -1 : 1;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -125,11 +125,11 @@ private BabylonNode ExportMesh(IIGameScene scene, IIGameNode meshNode, BabylonSc`
`125`	`125`	`{`
`126`	`126`	`bool isShareMat = masterMeshPair.Key.materialId == null \|\| (meshNode.NodeMaterial != null && meshNode.NodeMaterial.MaxMaterial.GetGuid().ToString().Equals(masterMeshPair.Value.NodeMaterial.MaxMaterial.GetGuid().ToString()));`
`127`	`127`
`128`		`- BabylonNode n = isShareMat?`
	`128`	`+ BabylonNode n = isShareMat ?`
`129`	`129`	`ExportInstanceMesh(scene, meshNode, babylonScene, masterMeshPair.Key, masterMeshPair.Value) :`
`130`	`130`	`exportParameters.useClone ? ExportCloneMesh(scene, meshNode, babylonScene, masterMeshPair.Key, masterMeshPair.Value) : null;`
`131`		`-`
`132`		`- if( n != null)`
	`131`	`+`
	`132`	`+ if (n != null)`
`133`	`133`	`{`
`134`	`134`	`return n;`
`135`	`135`	`}`
`@@ -469,7 +469,7 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab`
`469`	`469`	`babylonMesh.colors = colors;`
`470`	`470`	`babylonMesh.hasVertexAlpha = hasAlpha;`
`471`	`471`	`}`
`472`		`-`
	`472`	`+`
`473`	`473`	`}`
`474`	`474`
`475`	`475`	`babylonMesh.subMeshes = subMeshes.ToArray();`
`@@ -527,14 +527,14 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab`
`527`	`527`	`var maxMorphTarget = morpher.GetMorphTarget(i);`
`528`	`528`	`// here we avoid to extract vertices in an optimize way, du to the fact that the actual optimize process is NOT garanty to keep a one to one relationship`
`529`	`529`	`// with the source and target vertices.`
`530`		`- bool mustRebuildMorphTarget = (maxMorphTarget == null \|\| optimizeVertices );`
	`530`	`+ bool mustRebuildMorphTarget = (maxMorphTarget == null \|\| optimizeVertices);`
`531`	`531`	`if (mustRebuildMorphTarget)`
`532`	`532`	`{`
`533`	`533`	`string actionStr = exportParameters.rebuildMorphTarget ? $" trying to rebuild {i}." : string.Empty;`
`534`	`534`	`if (maxMorphTarget == null)`
`535`	`535`	`{`
`536`	`536`	`RaiseWarning($"Morph target [{i}] is not available anymore - ie: has been deleted in max and is baked into the scene.{actionStr}", 3);`
`537`		`- }`
	`537`	`+ }`
`538`	`538`	`else`
`539`	`539`	`{`
`540`	`540`	`RaiseWarning($"Morph target [{i}] MUST be rebuilt to avoid artifacts, using the vertices export process.{actionStr}", 3);`
`@@ -550,13 +550,13 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab`
`550`	`550`	`var babylonMorphTarget = new BabylonMorphTarget`
`551`	`551`	`{`
`552`	`552`	`// the name is reconstructed if we have to rebuild the target`
`553`		`- name = maxMorphTarget?.Name ?? $"{meshNode.Name}.morpher({m}).target({i})"`
	`553`	`+ name = maxMorphTarget?.Name ?? $"{meshNode.Name}.morpher({m}).target({i})"`
`554`	`554`	`};`
`555`	`555`	`babylonMorphTargets.Add(babylonMorphTarget);`
`556`		`- RaiseMessage($"Morph target {babylonMorphTarget.name} added.",3);`
	`556`	`+ RaiseMessage($"Morph target {babylonMorphTarget.name} added.", 3);`
`557`	`557`
`558`	`558`	`// TODO - Influence`
`559`		`- babylonMorphTarget.influence = 0f;`
	`559`	`+ babylonMorphTarget.influence = 0f;`
`560`	`560`
`561`	`561`	`// Target geometry`
`562`	`562`	`babylonMorphTarget.positions = targetVertices.SelectMany(v => new[] { v.Position.X, v.Position.Y, v.Position.Z }).ToArray();`
`@@ -566,7 +566,7 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab`
`566`	`566`	`if (mustRebuildMorphTarget)`
`567`	`567`	`{`
`568`	`568`	`// we do not recontruct the normals`
`569`		`- RaiseWarning("we do not have morph normals when morph target has been rebuilded.",4);`
	`569`	`+ RaiseWarning("we do not have morph normals when morph target has been rebuilded.", 4);`
`570`	`570`	`babylonMorphTarget.normals = null;`
`571`	`571`	`}`
`572`	`572`	`else`
`@@ -656,7 +656,7 @@ private IEnumerable<IPoint3> ExtractMorphTargetPoints(BabylonAbstractMesh babylo`
`656`	`656`	`// this is the place where we reconstruct the vertices.`
`657`	`657`	`// the needed function is not available on the .net SDK, then we have to use Max Script.`
`658`	`658`	`// TODO : use direct instance instead of manipulate string`
`659`		`- var script = $"with printAllElements on (for k in 0 to (WM3_MC_NumMPts ${babylonAbstractMesh.name}.Morpher {morphIndex}) collect (WM3_MC_GetMorphPoint ${babylonAbstractMesh.name}.morpher {morphIndex} k)) as string";`
	`659`	`+ var script = $"with printAllElements on (for k in 0 to (WM3_MC_NumMPts ${babylonAbstractMesh.name}.Morpher {morphIndex + 1}) collect (WM3_MC_GetMorphPoint ${babylonAbstractMesh.name}.morpher {morphIndex + 1} k)) as string";`
`660`	`660`	`#if MAX2022 \|\| MAX2023 \|\| MAX2024`
`661`	`661`	`var str = ManagedServices.MaxscriptSDK.ExecuteStringMaxscriptQuery(script, ManagedServices.MaxscriptSDK.ScriptSource.NotSpecified);`
`662`	`662`	`#else`
`@@ -920,7 +920,7 @@ private void ExtractGeometry(BabylonAbstractMesh babylonAbstractMesh, List<Globa`
`920`	`920`	`// Material Id is 0 if normal material, and GetMaterialID if multi-material`
`921`	`921`	`// default is [1,n] increment by 1 but user can decide to change the id (still an int) and set for example [4,3,9,1]`
`922`	`922`	`// note that GetMaterialID return the user id minus 1`
`923`		`- int materialId = multiMatsCount == 1? i : meshNode.NodeMaterial.GetMaterialID(i);`
	`923`	`+ int materialId = multiMatsCount == 1 ? i : meshNode.NodeMaterial.GetMaterialID(i);`
`924`	`924`	`var subMesh = new BabylonSubMesh { indexStart = indexStart, materialIndex = i };`
`925`	`925`	`if (multiMatsCount == 1)`
`926`	`926`	`{`
`@@ -1135,7 +1135,7 @@ int CreateGlobalVertex(IIGameMesh mesh, BabylonAbstractMesh babylonAbstractMesh,`
`1135`	`1135`	`}`
`1136`	`1136`	`}`
`1137`	`1137`	`var texCoord = mesh.GetMapVertex(1, indices[facePart]);`
`1138`		`- vertex.UV = Loader.Global.Point2.Create(texCoord.X, 1 -texCoord.Y);`
	`1138`	`+ vertex.UV = Loader.Global.Point2.Create(texCoord.X, 1 - texCoord.Y);`
`1139`	`1139`	`}`
`1140`	`1140`
`1141`	`1141`	`if (hasUV2)`
`@@ -1149,7 +1149,7 @@ int CreateGlobalVertex(IIGameMesh mesh, BabylonAbstractMesh babylonAbstractMesh,`
`1149`	`1149`	`}`
`1150`	`1150`	`}`
`1151`	`1151`	`var texCoord = mesh.GetMapVertex(2, indices[facePart]);`
`1152`		`- vertex.UV2 = Loader.Global.Point2.Create(texCoord.X, 1 -texCoord.Y);`
	`1152`	`+ vertex.UV2 = Loader.Global.Point2.Create(texCoord.X, 1 - texCoord.Y);`
`1153`	`1153`	`}`
`1154`	`1154`
`1155`	`1155`	`if (hasColor)`
`@@ -1330,9 +1330,9 @@ private void exportAnimation(BabylonNode babylonNode, IIGameNode maxGameNode)`
`1330`	`1330`	`if (exportParameters.exportAnimations)`
`1331`	`1331`	`{`
`1332`	`1332`	`var animations = new List<BabylonAnimation>();`
`1333`		`-`
	`1333`	`+`
`1334`	`1334`	`GenerateCoordinatesAnimations(maxGameNode, animations);`
`1335`		`-`
	`1335`	`+`
`1336`	`1336`	`if (!ExportFloatController(maxGameNode.MaxNode.VisController, "visibility", animations))`
`1337`	`1337`	`{`
`1338`	`1338`	`ExportFloatAnimation("visibility", animations, key => new[] { maxGameNode.MaxNode.GetVisibility(key, Tools.Forever) });`
`@@ -1373,7 +1373,7 @@ private float GetW(IPoint3 normal, IPoint3 tangent, IPoint3 bitangent)`
`1373`	`1373`	`float bty = MathUtilities.RoundToIfAlmostEqualTo(bitangent.Y, 0, Tools.Epsilon);`
`1374`	`1374`	`float btz = MathUtilities.RoundToIfAlmostEqualTo(bitangent.Z, 0, Tools.Epsilon);`
`1375`	`1375`
`1376`		`- if( btx == 0 && bty == 0 && btz == 0)`
	`1376`	`+ if (btx == 0 && bty == 0 && btz == 0)`
`1377`	`1377`	`{`
`1378`	`1378`	`return 1;`
`1379`	`1379`	`}`
`@@ -1395,7 +1395,7 @@ private float GetW(IPoint3 normal, IPoint3 tangent, IPoint3 bitangent)`
`1395`	`1395`	`// then the two vectors point in the same general direction, meaning less than 90 degrees.`
`1396`	`1396`	`// If the dot product is negative, then the two vectors point in opposite directions,`
`1397`	`1397`	`// or above 90 and less than or equal to 180 degrees.`
`1398`		`- var dot = MathUtilities.DotProduct(btx, bty,btz, x,y,z);`
	`1398`	`+ var dot = MathUtilities.DotProduct(btx, bty, btz, x, y, z);`
`1399`	`1399`	`return dot < 0 ? -1 : 1;`
`1400`	`1400`	`}`
`1401`	`1401`