@babylonjs/serializers 8.10.0 → 8.11.0

package/glTF/2.0/glTFExporter.js

@@ -1,4 +1,4 @@
-import { TmpVectors, Quaternion, Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { TmpVectors, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
 import { Tools } from "@babylonjs/core/Misc/tools.js";
 import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
 import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
@@ -9,7 +9,7 @@ import { Engine } from "@babylonjs/core/Engines/engine.js";
 import { EngineStore } from "@babylonjs/core/Engines/engineStore.js";
 import { GLTFMaterialExporter } from "./glTFMaterialExporter.js";
 import { GLTFData } from "./glTFData.js";
-import { ConvertToRightHandedPosition, ConvertToRightHandedRotation, DataArrayToUint8Array, GetAccessorType, GetAttributeType, GetMinMax, GetPrimitiveMode, IsNoopNode, IsTriangleFillMode, IsParentAddedByImporter, ConvertToRightHandedNode, RotateNode180Y, FloatsNeed16BitInteger, IsStandardVertexAttribute, IndicesArrayToTypedArray, GetVertexBufferInfo, } from "./glTFUtilities.js";
+import { ConvertToRightHandedPosition, ConvertToRightHandedRotation, DataArrayToUint8Array, GetAccessorType, GetAttributeType, GetMinMax, GetPrimitiveMode, IsNoopNode, IsTriangleFillMode, IsChildCollapsible, FloatsNeed16BitInteger, IsStandardVertexAttribute, IndicesArrayToTypedArray, GetVertexBufferInfo, CollapseChildIntoParent, Rotate180Y, DefaultTranslation, DefaultScale, DefaultRotation, } from "./glTFUtilities.js";
 import { BufferManager } from "./bufferManager.js";
 import { Camera } from "@babylonjs/core/Cameras/camera.js";
 import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.js";
@@ -22,6 +22,8 @@ import { BuildMorphTargetBuffers } from "./glTFMorphTargetsUtilities.js";
 import { LinesMesh } from "@babylonjs/core/Meshes/linesMesh.js";
 import { GreasedLineBaseMesh } from "@babylonjs/core/Meshes/GreasedLine/greasedLineBaseMesh.js";
 import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.js";
+import { TargetCamera } from "@babylonjs/core/Cameras/targetCamera.js";
+import { Epsilon } from "@babylonjs/core/Maths/math.constants.js";
 class ExporterState {
     constructor(convertToRightHanded, wasAddedByNoopNode) {
         // Babylon indices array, start, count, offset, flip -> glTF accessor index
@@ -463,48 +465,48 @@ export class GLTFExporter {
         return container;
     }
     _setNodeTransformation(node, babylonTransformNode, convertToRightHanded) {
-        if (!babylonTransformNode.getPivotPoint().equalsToFloats(0, 0, 0)) {
+        if (!babylonTransformNode.getPivotPoint().equalsWithEpsilon(DefaultTranslation, Epsilon)) {
             Tools.Warn("Pivot points are not supported in the glTF serializer");
         }
-        if (!babylonTransformNode.position.equalsToFloats(0, 0, 0)) {
+        if (!babylonTransformNode.position.equalsWithEpsilon(DefaultTranslation, Epsilon)) {
             const translation = TmpVectors.Vector3[0].copyFrom(babylonTransformNode.position);
             if (convertToRightHanded) {
                 ConvertToRightHandedPosition(translation);
             }
             node.translation = translation.asArray();
         }
-        if (!babylonTransformNode.scaling.equalsToFloats(1, 1, 1)) {
+        if (!babylonTransformNode.scaling.equalsWithEpsilon(DefaultScale, Epsilon)) {
             node.scale = babylonTransformNode.scaling.asArray();
         }
-        const rotationQuaternion = Quaternion.FromEulerAngles(babylonTransformNode.rotation.x, babylonTransformNode.rotation.y, babylonTransformNode.rotation.z);
-        if (babylonTransformNode.rotationQuaternion) {
-            rotationQuaternion.multiplyInPlace(babylonTransformNode.rotationQuaternion);
-        }
-        if (!Quaternion.IsIdentity(rotationQuaternion)) {
+        const rotationQuaternion = babylonTransformNode.rotationQuaternion ||
+            Quaternion.FromEulerAngles(babylonTransformNode.rotation.x, babylonTransformNode.rotation.y, babylonTransformNode.rotation.z);
+        if (!rotationQuaternion.equalsWithEpsilon(DefaultRotation, Epsilon)) {
             if (convertToRightHanded) {
                 ConvertToRightHandedRotation(rotationQuaternion);
             }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
     }
-    _setCameraTransformation(node, babylonCamera, convertToRightHanded, parent) {
-        const translation = TmpVectors.Vector3[0];
-        const rotation = TmpVectors.Quaternion[0];
-        if (parent !== null) {
-            // Camera.getWorldMatrix returns global coordinates. GLTF node must use local coordinates. If camera has parent we need to use local translation/rotation.
-            const parentWorldMatrix = Matrix.Invert(parent.getWorldMatrix());
-            const cameraWorldMatrix = babylonCamera.getWorldMatrix();
-            const cameraLocal = cameraWorldMatrix.multiply(parentWorldMatrix);
-            cameraLocal.decompose(undefined, rotation, translation);
+    _setCameraTransformation(node, babylonCamera, convertToRightHanded) {
+        if (!babylonCamera.position.equalsWithEpsilon(DefaultTranslation, Epsilon)) {
+            const translation = TmpVectors.Vector3[0].copyFrom(babylonCamera.position);
+            if (convertToRightHanded) {
+                ConvertToRightHandedPosition(translation);
+            }
+            node.translation = translation.asArray();
         }
-        else {
-            babylonCamera.getWorldMatrix().decompose(undefined, rotation, translation);
+        const rotationQuaternion = babylonCamera.rotationQuaternion || Quaternion.FromEulerAngles(babylonCamera.rotation.x, babylonCamera.rotation.y, babylonCamera.rotation.z);
+        if (convertToRightHanded) {
+            ConvertToRightHandedRotation(rotationQuaternion);
         }
-        if (!translation.equalsToFloats(0, 0, 0)) {
-            node.translation = translation.asArray();
+        // Left-handed scenes have cameras that always face Z+ (opposite of glTF's Z-).
+        // Use scene coordinate system rather than convertToRightHanded, since some
+        // cameras may not need convertToRightHanded but still need correction to face Z-.
+        if (!this._babylonScene.useRightHandedSystem) {
+            Rotate180Y(rotationQuaternion);
         }
-        if (!Quaternion.IsIdentity(rotation)) {
-            node.rotation = rotation.asArray();
+        if (!rotationQuaternion.equalsWithEpsilon(DefaultRotation, Epsilon)) {
+            node.rotation = rotationQuaternion.asArray();
         }
     }
     // Export babylon cameras to glTF cameras
@@ -953,27 +955,24 @@ export class GLTFExporter {
                 }
             }
         }
-        if (babylonNode instanceof Camera) {
+        if (babylonNode instanceof TargetCamera) {
             const gltfCamera = this._camerasMap.get(babylonNode);
             if (gltfCamera) {
                 if (this._nodesCameraMap.get(gltfCamera) === undefined) {
                     this._nodesCameraMap.set(gltfCamera, []);
                 }
+                this._setCameraTransformation(node, babylonNode, state.convertToRightHanded);
+                // If a parent node exists and can be collapsed, merge their transformations and mark the parent as the camera-containing node.
                 const parentBabylonNode = babylonNode.parent;
-                this._setCameraTransformation(node, babylonNode, state.convertToRightHanded, parentBabylonNode);
-                // If a camera has a node that was added by the GLTF importer, we can just use the parent node transform as the "camera" transform.
-                if (parentBabylonNode && IsParentAddedByImporter(babylonNode, parentBabylonNode)) {
+                if (parentBabylonNode !== null && IsChildCollapsible(babylonNode, parentBabylonNode)) {
                     const parentNodeIndex = this._nodeMap.get(parentBabylonNode);
-                    if (parentNodeIndex) {
+                    if (parentNodeIndex !== undefined) {
                         const parentNode = this._nodes[parentNodeIndex];
+                        CollapseChildIntoParent(node, parentNode);
                         this._nodesCameraMap.get(gltfCamera)?.push(parentNode);
-                        return null; // Skip exporting this node
+                        return null; // Skip exporting the original child node
                     }
                 }
-                if (state.convertToRightHanded) {
-                    ConvertToRightHandedNode(node);
-                    RotateNode180Y(node);
-                }
                 this._nodesCameraMap.get(gltfCamera)?.push(node);
             }
         }
@@ -1108,7 +1107,7 @@ export class GLTFExporter {
                     const colorWhite = Color3.White();
                     const alpha = babylonLinesMesh.material?.alpha ?? 1;
                     const color = babylonLinesMesh.greasedLineMaterial?.color ?? colorWhite;
-                    if (!color.equals(colorWhite) || alpha < 1) {
+                    if (!color.equalsWithEpsilon(colorWhite, Epsilon) || alpha < 1) {
                         material.pbrMetallicRoughness = {
                             baseColorFactor: [...color.asArray(), alpha],
                         };
@@ -1122,7 +1121,7 @@ export class GLTFExporter {
                         name: babylonMaterial.name,
                     };
                     const babylonLinesMesh = babylonMesh;
-                    if (!babylonLinesMesh.color.equals(Color3.White()) || babylonLinesMesh.alpha < 1) {
+                    if (!babylonLinesMesh.color.equalsWithEpsilon(Color3.White(), Epsilon) || babylonLinesMesh.alpha < 1) {
                         material.pbrMetallicRoughness = {
                             baseColorFactor: [...babylonLinesMesh.color.asArray(), babylonLinesMesh.alpha],
                         };