@babylonjs/serializers 6.6.1 → 6.7.0

package/glTF/2.0/glTFExporter.js

@@ -18,6 +18,54 @@ import { EngineStore } from "@babylonjs/core/Engines/engineStore.js";
 import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.js";
 // Matrix that converts handedness on the X-axis.
 const convertHandednessMatrix = Matrix.Compose(new Vector3(-1, 1, 1), Quaternion.Identity(), Vector3.Zero());
+function isNoopNode(node, useRightHandedSystem) {
+    if (!(node instanceof TransformNode)) {
+        return false;
+    }
+    // Transform
+    if (useRightHandedSystem) {
+        const matrix = node.getWorldMatrix();
+        if (!matrix.isIdentity()) {
+            return false;
+        }
+    }
+    else {
+        const matrix = node.getWorldMatrix().multiplyToRef(convertHandednessMatrix, TmpVectors.Matrix[0]);
+        if (!matrix.isIdentity()) {
+            return false;
+        }
+    }
+    // Geometry
+    if ((node instanceof Mesh && node.geometry) || (node instanceof InstancedMesh && node.sourceMesh.geometry)) {
+        return false;
+    }
+    return true;
+}
+function convertNodeHandedness(node) {
+    const translation = Vector3.FromArrayToRef(node.translation || [0, 0, 0], 0, TmpVectors.Vector3[0]);
+    const rotation = Quaternion.FromArrayToRef(node.rotation || [0, 0, 0, 1], 0, TmpVectors.Quaternion[0]);
+    const scale = Vector3.FromArrayToRef(node.scale || [1, 1, 1], 0, TmpVectors.Vector3[1]);
+    const matrix = Matrix.ComposeToRef(scale, rotation, translation, TmpVectors.Matrix[0]).multiplyToRef(convertHandednessMatrix, TmpVectors.Matrix[0]);
+    matrix.decompose(scale, rotation, translation);
+    if (translation.equalsToFloats(0, 0, 0)) {
+        delete node.translation;
+    }
+    else {
+        node.translation = translation.asArray();
+    }
+    if (Quaternion.IsIdentity(rotation)) {
+        delete node.rotation;
+    }
+    else {
+        node.rotation = rotation.asArray();
+    }
+    if (scale.equalsToFloats(1, 1, 1)) {
+        delete node.scale;
+    }
+    else {
+        node.scale = scale.asArray();
+    }
+}
 /**
  * Converts Babylon Scene into glTF 2.0.
  * @internal
@@ -119,10 +167,6 @@ export class _Exporter {
      * @param options Options to modify the behavior of the exporter
      */
     constructor(babylonScene, options) {
-        /*
-         * Specifies if root Babylon empty nodes that act as a coordinate space transform should be included in export
-         */
-        this._includeCoordinateSystemConversionNodes = false;
         this._extensions = {};
         this._glTF = {
             asset: { generator: `Babylon.js v${Engine.Version}`, version: "2.0" },
@@ -148,8 +192,7 @@ export class _Exporter {
         this._imageData = {};
         this._orderedImageData = [];
         this._options = options || {};
-        this._animationSampleRate = options && options.animationSampleRate ? options.animationSampleRate : 1 / 60;
-        this._includeCoordinateSystemConversionNodes = options && options.includeCoordinateSystemConversionNodes ? true : false;
+        this._animationSampleRate = this._options.animationSampleRate || 1 / 60;
         this._glTFMaterialExporter = new _GLTFMaterialExporter(this);
         this._loadExtensions();
     }
@@ -227,28 +270,24 @@ export class _Exporter {
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
      * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        if (convertToRightHandedSystem && sideOrientation === Material.ClockWiseSideOrientation) {
-            switch (primitiveMode) {
-                case Material.TriangleFillMode: {
-                    this._reorderTriangleFillMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-                case Material.TriangleStripDrawMode: {
-                    this._reorderTriangleStripDrawMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-                case Material.TriangleFanDrawMode: {
-                    this._reorderTriangleFanMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
+    _reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
+        switch (primitiveMode) {
+            case Material.TriangleFillMode: {
+                this._reorderTriangleFillMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter);
+                break;
+            }
+            case Material.TriangleStripDrawMode: {
+                this._reorderTriangleStripDrawMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter);
+                break;
+            }
+            case Material.TriangleFanDrawMode: {
+                this._reorderTriangleFanMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter);
+                break;
             }
         }
     }
@@ -256,15 +295,12 @@ export class _Exporter {
      * Reorders the vertex attributes in the correct triangle mode order .  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
-     * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _reorderTriangleFillMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _reorderTriangleFillMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
         const vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
             const stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
@@ -325,7 +361,7 @@ export class _Exporter {
                         Tools.Error(`Unsupported Vertex Buffer type: ${vertexBufferKind}`);
                     }
                 }
-                this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
+                this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, binaryWriter);
             }
         }
         else {
@@ -336,15 +372,12 @@ export class _Exporter {
      * Reorders the vertex attributes in the correct triangle strip order.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
-     * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _reorderTriangleStripDrawMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _reorderTriangleStripDrawMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
         const vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
             const stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
@@ -386,7 +419,7 @@ export class _Exporter {
                     Tools.Error(`Unsupported Vertex Buffer type: ${vertexBufferKind}`);
                 }
             }
-            this._writeVertexAttributeData(vertexData, byteOffset + 12, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
+            this._writeVertexAttributeData(vertexData, byteOffset + 12, vertexBufferKind, binaryWriter);
         }
         else {
             Tools.Warn(`reorderTriangleStripDrawMode: Vertex buffer kind ${vertexBufferKind} not present!`);
@@ -396,15 +429,12 @@ export class _Exporter {
      * Reorders the vertex attributes in the correct triangle fan order.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
-     * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _reorderTriangleFanMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _reorderTriangleFanMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
         const vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
             const stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
@@ -448,7 +478,7 @@ export class _Exporter {
                     Tools.Error(`Unsupported Vertex Buffer type: ${vertexBufferKind}`);
                 }
             }
-            this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
+            this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, binaryWriter);
         }
         else {
             Tools.Warn(`reorderTriangleFanMode: Vertex buffer kind ${vertexBufferKind} not present!`);
@@ -459,28 +489,10 @@ export class _Exporter {
      * @param vertices The vertices to write to the binary writer
      * @param byteOffset The offset into the binary writer to overwrite binary data
      * @param vertexAttributeKind The vertex attribute type
-     * @param meshAttributeArray The vertex attribute data
      * @param binaryWriter The writer containing the binary data
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _writeVertexAttributeData(vertices, byteOffset, vertexAttributeKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem) {
+    _writeVertexAttributeData(vertices, byteOffset, vertexAttributeKind, binaryWriter) {
         for (const vertex of vertices) {
-            if (convertToRightHandedSystem && !(vertexAttributeKind === VertexBuffer.ColorKind) && !(vertex instanceof Vector2)) {
-                if (vertex instanceof Vector3) {
-                    if (vertexAttributeKind === VertexBuffer.NormalKind) {
-                        _GLTFUtilities._GetRightHandedNormalVector3FromRef(vertex);
-                    }
-                    else if (vertexAttributeKind === VertexBuffer.PositionKind) {
-                        _GLTFUtilities._GetRightHandedPositionVector3FromRef(vertex);
-                    }
-                    else {
-                        Tools.Error("Unsupported vertex attribute kind!");
-                    }
-                }
-                else {
-                    _GLTFUtilities._GetRightHandedVector4FromRef(vertex);
-                }
-            }
             if (vertexAttributeKind === VertexBuffer.NormalKind) {
                 vertex.normalize();
             }
@@ -501,10 +513,9 @@ export class _Exporter {
      * @param meshAttributeArray Array containing the attribute data
      * @param stride Specifies the space between data
      * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      * @param babylonTransformNode
      */
-    _writeAttributeData(vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, convertToRightHandedSystem, babylonTransformNode) {
+    _writeAttributeData(vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, babylonTransformNode) {
         let vertexAttributes = [];
         let index;
         switch (vertexBufferKind) {
@@ -512,9 +523,6 @@ export class _Exporter {
                 for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
                     const vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedPositionVector3FromRef(vertexData);
-                    }
                     vertexAttributes.push(vertexData.asArray());
                 }
                 break;
@@ -523,11 +531,7 @@ export class _Exporter {
                 for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
                     const vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedNormalVector3FromRef(vertexData);
-                    }
-                    vertexData.normalize();
-                    vertexAttributes.push(vertexData.asArray());
+                    vertexAttributes.push(vertexData.normalize().asArray());
                 }
                 break;
             }
@@ -535,9 +539,6 @@ export class _Exporter {
                 for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
                     const vertexData = Vector4.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedVector4FromRef(vertexData);
-                    }
                     _GLTFUtilities._NormalizeTangentFromRef(vertexData);
                     vertexAttributes.push(vertexData.asArray());
                 }
@@ -570,7 +571,8 @@ export class _Exporter {
             case VertexBuffer.UV2Kind: {
                 for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
-                    vertexAttributes.push(convertToRightHandedSystem ? [meshAttributeArray[index], meshAttributeArray[index + 1]] : [meshAttributeArray[index], meshAttributeArray[index + 1]]);
+                    const vertexData = Vector2.FromArray(meshAttributeArray, index);
+                    vertexAttributes.push(vertexData.asArray());
                 }
                 break;
             }
@@ -637,10 +639,9 @@ export class _Exporter {
      * @param morphTargetAttributeArray
      * @param stride Specifies the space between data
      * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      * @param minMax
      */
-    writeMorphTargetAttributeData(vertexBufferKind, attributeComponentKind, meshPrimitive, morphTarget, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, convertToRightHandedSystem, minMax) {
+    writeMorphTargetAttributeData(vertexBufferKind, attributeComponentKind, meshPrimitive, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, minMax) {
         let vertexAttributes = [];
         let index;
         let difference = new Vector3();
@@ -652,9 +653,6 @@ export class _Exporter {
                     const vertexData = Vector3.FromArray(meshAttributeArray, index);
                     const morphData = Vector3.FromArray(morphTargetAttributeArray, index);
                     difference = morphData.subtractToRef(vertexData, difference);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedPositionVector3FromRef(difference);
-                    }
                     if (minMax) {
                         minMax.min.copyFromFloats(Math.min(difference.x, minMax.min.x), Math.min(difference.y, minMax.min.y), Math.min(difference.z, minMax.min.z));
                         minMax.max.copyFromFloats(Math.max(difference.x, minMax.max.x), Math.max(difference.y, minMax.max.y), Math.max(difference.z, minMax.max.z));
@@ -666,14 +664,9 @@ export class _Exporter {
             case VertexBuffer.NormalKind: {
                 for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
                     index = meshPrimitive.indexStart + k * stride;
-                    const vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    vertexData.normalize();
-                    const morphData = Vector3.FromArray(morphTargetAttributeArray, index);
-                    morphData.normalize();
+                    const vertexData = Vector3.FromArray(meshAttributeArray, index).normalize();
+                    const morphData = Vector3.FromArray(morphTargetAttributeArray, index).normalize();
                     difference = morphData.subtractToRef(vertexData, difference);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedNormalVector3FromRef(difference);
-                    }
                     vertexAttributes.push(difference.asArray());
                 }
                 break;
@@ -686,9 +679,6 @@ export class _Exporter {
                     const morphData = Vector4.FromArray(morphTargetAttributeArray, index);
                     _GLTFUtilities._NormalizeTangentFromRef(morphData);
                     difference4 = morphData.subtractToRef(vertexData, difference4);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedVector4FromRef(difference4);
-                    }
                     vertexAttributes.push([difference4.x, difference4.y, difference4.z]);
                 }
                 break;
@@ -844,7 +834,7 @@ export class _Exporter {
      */
     _generateBinaryAsync() {
         const binaryWriter = new _BinaryWriter(4);
-        return this._createSceneAsync(this._babylonScene, binaryWriter).then(() => {
+        return this._createSceneAsync(binaryWriter).then(() => {
             if (this._localEngine) {
                 this._localEngine.dispose();
             }
@@ -961,16 +951,13 @@ export class _Exporter {
      * Sets the TRS for each node
      * @param node glTF Node for storing the transformation data
      * @param babylonTransformNode Babylon mesh used as the source for the transformation data
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _setNodeTransformation(node, babylonTransformNode, convertToRightHandedSystem) {
+    _setNodeTransformation(node, babylonTransformNode) {
         if (!babylonTransformNode.getPivotPoint().equalsToFloats(0, 0, 0)) {
             Tools.Warn("Pivot points are not supported in the glTF serializer");
         }
         if (!babylonTransformNode.position.equalsToFloats(0, 0, 0)) {
-            node.translation = convertToRightHandedSystem
-                ? _GLTFUtilities._GetRightHandedPositionVector3(babylonTransformNode.position).asArray()
-                : babylonTransformNode.position.asArray();
+            node.translation = babylonTransformNode.position.asArray();
         }
         if (!babylonTransformNode.scaling.equalsToFloats(1, 1, 1)) {
             node.scale = babylonTransformNode.scaling.asArray();
@@ -980,21 +967,15 @@ export class _Exporter {
             rotationQuaternion.multiplyInPlace(babylonTransformNode.rotationQuaternion);
         }
         if (!Quaternion.IsIdentity(rotationQuaternion)) {
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-            }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
     }
-    _setCameraTransformation(node, babylonCamera, convertToRightHandedSystem) {
+    _setCameraTransformation(node, babylonCamera) {
         if (!babylonCamera.position.equalsToFloats(0, 0, 0)) {
-            node.translation = convertToRightHandedSystem ? _GLTFUtilities._GetRightHandedPositionVector3(babylonCamera.position).asArray() : babylonCamera.position.asArray();
+            node.translation = babylonCamera.position.asArray();
         }
         const rotationQuaternion = babylonCamera.rotationQuaternion; // we target the local transformation if one.
         if (rotationQuaternion && !Quaternion.IsIdentity(rotationQuaternion)) {
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-            }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
     }
@@ -1014,9 +995,8 @@ export class _Exporter {
      * @param babylonTransformNode The Babylon mesh to get the vertices data from
      * @param binaryWriter The buffer to write the bufferview data to
      * @param byteStride
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _createBufferViewKind(kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride, convertToRightHandedSystem) {
+    _createBufferViewKind(kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride) {
         const bufferMesh = babylonTransformNode instanceof Mesh
             ? babylonTransformNode
             : babylonTransformNode instanceof InstancedMesh
@@ -1030,7 +1010,7 @@ export class _Exporter {
                 const byteLength = vertexData.length * typeByteLength;
                 const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, kind + " - " + bufferMesh.name);
                 this._bufferViews.push(bufferView);
-                this._writeAttributeData(kind, attributeComponentKind, vertexData, byteStride / typeByteLength, binaryWriter, convertToRightHandedSystem, babylonTransformNode);
+                this._writeAttributeData(kind, attributeComponentKind, vertexData, byteStride / typeByteLength, binaryWriter, babylonTransformNode);
             }
         }
     }
@@ -1040,9 +1020,8 @@ export class _Exporter {
      * @param meshPrimitive
      * @param babylonMorphTarget the morph target to be exported
      * @param binaryWriter The buffer to write the bufferview data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _setMorphTargetAttributes(babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter, convertToRightHandedSystem) {
+    _setMorphTargetAttributes(babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter) {
         if (babylonMorphTarget) {
             if (!meshPrimitive.targets) {
                 meshPrimitive.targets = [];
@@ -1061,7 +1040,7 @@ export class _Exporter {
                 const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "NORMAL", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.NORMAL = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.NormalKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, babylonMorphTarget, vertexNormals, morphNormals, byteStride / 4, binaryWriter, convertToRightHandedSystem);
+                this.writeMorphTargetAttributeData(VertexBuffer.NormalKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexNormals, morphNormals, byteStride / 4, binaryWriter);
             }
             if (babylonMorphTarget.hasPositions) {
                 const vertexPositions = mesh.getVerticesData(VertexBuffer.PositionKind, undefined, undefined, true);
@@ -1076,7 +1055,7 @@ export class _Exporter {
                 const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "POSITION", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.POSITION = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.PositionKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, babylonMorphTarget, vertexPositions, morphPositions, byteStride / 4, binaryWriter, convertToRightHandedSystem, minMax);
+                this.writeMorphTargetAttributeData(VertexBuffer.PositionKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexPositions, morphPositions, byteStride / 4, binaryWriter, minMax);
                 accessor.min = minMax.min.asArray();
                 accessor.max = minMax.max.asArray();
             }
@@ -1092,7 +1071,7 @@ export class _Exporter {
                 const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "TANGENT", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.TANGENT = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.TangentKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, babylonMorphTarget, vertexTangents, morphTangents, byteStride / 4, binaryWriter, convertToRightHandedSystem);
+                this.writeMorphTargetAttributeData(VertexBuffer.TangentKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexTangents, morphTangents, byteStride / 4, binaryWriter);
             }
             meshPrimitive.targets.push(target);
         }
@@ -1212,10 +1191,8 @@ export class _Exporter {
      * @param mesh glTF Mesh object to store the primitive attribute information
      * @param babylonTransformNode Babylon mesh to get the primitive attribute data from
      * @param binaryWriter Buffer to write the attribute data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _setPrimitiveAttributesAsync(mesh, babylonTransformNode, binaryWriter, convertToRightHandedSystem) {
-        var _a;
+    _setPrimitiveAttributesAsync(mesh, babylonTransformNode, binaryWriter) {
         const promises = [];
         let bufferMesh = null;
         let bufferView;
@@ -1255,7 +1232,7 @@ export class _Exporter {
                     if (attribute.byteStride === 12) {
                         attribute.accessorType = "VEC3" /* AccessorType.VEC3 */;
                     }
-                    this._createBufferViewKind(attributeKind, attributeComponentKind, babylonTransformNode, binaryWriter, attribute.byteStride, convertToRightHandedSystem);
+                    this._createBufferViewKind(attributeKind, attributeComponentKind, babylonTransformNode, binaryWriter, attribute.byteStride);
                     attribute.bufferViewIndex = this._bufferViews.length - 1;
                     vertexAttributeBufferViews[attributeKind] = attribute.bufferViewIndex;
                 }
@@ -1322,7 +1299,7 @@ export class _Exporter {
                                     // check to see if bufferviewindex has a numeric value assigned.
                                     minMax = { min: null, max: null };
                                     if (attributeKind == VertexBuffer.PositionKind) {
-                                        minMax = _GLTFUtilities._CalculateMinMaxPositions(vertexData, 0, vertexData.length / stride, convertToRightHandedSystem);
+                                        minMax = _GLTFUtilities._CalculateMinMaxPositions(vertexData, 0, vertexData.length / stride);
                                     }
                                     const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, attributeKind + " - " + babylonTransformNode.name, attribute.accessorType, attribute.accessorComponentType, vertexData.length / stride, 0, minMax.min, minMax.max);
                                     this._accessors.push(accessor);
@@ -1339,10 +1316,7 @@ export class _Exporter {
                     }
                     if (materialIndex != null && Object.keys(meshPrimitive.attributes).length > 0) {
                         const sideOrientation = bufferMesh.overrideMaterialSideOrientation !== null ? bufferMesh.overrideMaterialSideOrientation : babylonMaterial.sideOrientation;
-                        if ((sideOrientation == Material.ClockWiseSideOrientation && this._babylonScene.useRightHandedSystem) ||
-                            (sideOrientation == Material.ClockWiseSideOrientation &&
-                                convertToRightHandedSystem &&
-                                bufferMesh.overrideMaterialSideOrientation !== ((_a = bufferMesh.material) === null || _a === void 0 ? void 0 : _a.sideOrientation))) {
+                        if (sideOrientation === (this._babylonScene.useRightHandedSystem ? Material.ClockWiseSideOrientation : Material.CounterClockWiseSideOrientation)) {
                             let byteOffset = indexBufferViewIndex != null ? this._bufferViews[indexBufferViewIndex].byteOffset : null;
                             if (byteOffset == null) {
                                 byteOffset = 0;
@@ -1358,11 +1332,8 @@ export class _Exporter {
                                 for (const attribute of attributeData) {
                                     const vertexData = bufferMesh.getVerticesData(attribute.kind, undefined, undefined, true);
                                     if (vertexData) {
-                                        let byteOffset = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset;
-                                        if (!byteOffset) {
-                                            byteOffset = 0;
-                                        }
-                                        this._reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, attribute.kind, vertexData, byteOffset, binaryWriter, convertToRightHandedSystem);
+                                        const byteOffset = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset || 0;
+                                        this._reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, attribute.kind, vertexData, byteOffset, binaryWriter);
                                     }
                                 }
                             }
@@ -1373,7 +1344,7 @@ export class _Exporter {
                         let target;
                         for (let i = 0; i < morphTargetManager.numTargets; ++i) {
                             target = morphTargetManager.getTarget(i);
-                            this._setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter, convertToRightHandedSystem);
+                            this._setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter);
                         }
                     }
                     mesh.primitives.push(meshPrimitive);
@@ -1386,79 +1357,42 @@ export class _Exporter {
             /* do nothing */
         });
     }
-    /**
-     * Check if the node is used to convert its descendants from a right handed coordinate system to the Babylon scene's coordinate system.
-     * @param node The node to check
-     * @returns True if the node is used to convert its descendants from right-handed to left-handed. False otherwise
-     */
-    _isBabylonCoordinateSystemConvertingNode(node) {
-        if (node instanceof TransformNode) {
-            // Transform
-            const matrix = node.getWorldMatrix().multiplyToRef(convertHandednessMatrix, TmpVectors.Matrix[0]);
-            if (!matrix.isIdentity()) {
-                return false;
-            }
-            // Geometry
-            if ((node instanceof Mesh && node.geometry !== null) || (node instanceof InstancedMesh && node.sourceMesh.geometry !== null)) {
-                return false;
-            }
-            return true;
-        }
-        return false;
-    }
     /**
      * Creates a glTF scene based on the array of meshes
      * Returns the the total byte offset
      * @param babylonScene Babylon scene to get the mesh data from
      * @param binaryWriter Buffer to write binary data to
      */
-    _createSceneAsync(babylonScene, binaryWriter) {
+    _createSceneAsync(binaryWriter) {
+        var _a;
         const scene = { nodes: [] };
         let glTFNodeIndex;
         let glTFNode;
         let directDescendents;
-        const nodes = [...babylonScene.transformNodes, ...babylonScene.meshes, ...babylonScene.lights, ...babylonScene.cameras];
-        const rootNodesToLeftHanded = [];
-        this._convertToRightHandedSystem = !babylonScene.useRightHandedSystem;
-        this._convertToRightHandedSystemMap = {};
+        const nodes = [...this._babylonScene.transformNodes, ...this._babylonScene.meshes, ...this._babylonScene.lights, ...this._babylonScene.cameras];
+        const removedRootNodes = new Set();
         // Scene metadata
-        if (babylonScene.metadata) {
+        if (this._babylonScene.metadata) {
             if (this._options.metadataSelector) {
-                scene.extras = this._options.metadataSelector(babylonScene.metadata);
+                scene.extras = this._options.metadataSelector(this._babylonScene.metadata);
             }
-            else if (babylonScene.metadata.gltf) {
-                scene.extras = babylonScene.metadata.gltf.extras;
+            else if (this._babylonScene.metadata.gltf) {
+                scene.extras = this._babylonScene.metadata.gltf.extras;
             }
         }
-        // Set default values for all nodes
-        babylonScene.rootNodes.forEach((rootNode) => {
-            this._convertToRightHandedSystemMap[rootNode.uniqueId] = this._convertToRightHandedSystem;
-            rootNode.getDescendants(false).forEach((descendant) => {
-                this._convertToRightHandedSystemMap[descendant.uniqueId] = this._convertToRightHandedSystem;
-            });
-        });
-        // Check if root nodes converting to left-handed are present
-        babylonScene.rootNodes.forEach((rootNode) => {
-            if (this._includeCoordinateSystemConversionNodes) {
-                return;
-            }
-            if (this._isBabylonCoordinateSystemConvertingNode(rootNode)) {
-                rootNodesToLeftHanded.push(rootNode);
-                // Exclude the node from list of nodes to export
-                const indexRootNode = nodes.indexOf(rootNode);
-                if (indexRootNode !== -1) {
-                    // should always be true
-                    nodes.splice(indexRootNode, 1);
+        // Remove no-op root nodes
+        if (((_a = this._options.removeNoopRootNodes) !== null && _a !== void 0 ? _a : true) && !this._options.includeCoordinateSystemConversionNodes) {
+            for (const rootNode of this._babylonScene.rootNodes) {
+                if (isNoopNode(rootNode, this._babylonScene.useRightHandedSystem)) {
+                    removedRootNodes.add(rootNode);
+                    // Exclude the node from list of nodes to export
+                    nodes.splice(nodes.indexOf(rootNode), 1);
                 }
-                // Cancel conversion to right handed system
-                rootNode.getDescendants(false).forEach((descendant) => {
-                    this._convertToRightHandedSystemMap[descendant.uniqueId] = false;
-                });
             }
-        });
+        }
         // Export babylon cameras to glTFCamera
         const cameraMap = new Map();
-        babylonScene.cameras.forEach((camera) => {
+        this._babylonScene.cameras.forEach((camera) => {
             if (!this._options.shouldExportNode || this._options.shouldExportNode(camera)) {
                 const glTFCamera = {
                     type: camera.mode === Camera.PERSPECTIVE_CAMERA ? "perspective" /* CameraType.PERSPECTIVE */ : "orthographic" /* CameraType.ORTHOGRAPHIC */,
@@ -1490,8 +1424,8 @@ export class _Exporter {
         });
         const [exportNodes, exportMaterials] = this._getExportNodes(nodes);
         return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(exportMaterials, "image/png" /* ImageMimeType.PNG */, true).then(() => {
-            return this._createNodeMapAndAnimationsAsync(babylonScene, exportNodes, binaryWriter).then((nodeMap) => {
-                return this._createSkinsAsync(babylonScene, nodeMap, binaryWriter).then((skinMap) => {
+            return this._createNodeMapAndAnimationsAsync(exportNodes, binaryWriter).then((nodeMap) => {
+                return this._createSkinsAsync(nodeMap, binaryWriter).then((skinMap) => {
                     this._nodeMap = nodeMap;
                     this._totalByteLength = binaryWriter.getByteOffset();
                     if (this._totalByteLength == undefined) {
@@ -1513,28 +1447,20 @@ export class _Exporter {
                             if (babylonNode instanceof Camera) {
                                 glTFNode.camera = cameraMap.get(babylonNode);
                             }
-                            if (!babylonNode.parent || rootNodesToLeftHanded.indexOf(babylonNode.parent) !== -1) {
-                                if (this._options.shouldExportNode && !this._options.shouldExportNode(babylonNode)) {
-                                    Tools.Log("Omitting " + babylonNode.name + " from scene.");
+                            if (this._options.shouldExportNode && !this._options.shouldExportNode(babylonNode)) {
+                                Tools.Log("Omitting " + babylonNode.name + " from scene.");
+                            }
+                            else {
+                                if (!babylonNode.parent && !this._babylonScene.useRightHandedSystem) {
+                                    convertNodeHandedness(glTFNode);
                                 }
-                                else {
-                                    const convertToRightHandedSystem = this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                                    if (convertToRightHandedSystem) {
-                                        if (glTFNode.translation) {
-                                            glTFNode.translation[2] *= -1;
-                                            glTFNode.translation[0] *= -1;
-                                        }
-                                        glTFNode.rotation = glTFNode.rotation
-                                            ? Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(glTFNode.rotation)).asArray()
-                                            : Quaternion.FromArray([0, 1, 0, 0]).asArray();
-                                    }
+                                if (!babylonNode.parent || removedRootNodes.has(babylonNode.parent)) {
                                     scene.nodes.push(glTFNodeIndex);
                                 }
                             }
                             if (babylonNode instanceof Mesh) {
-                                const babylonMesh = babylonNode;
-                                if (babylonMesh.skeleton) {
-                                    glTFNode.skin = skinMap[babylonMesh.skeleton.uniqueId];
+                                if (babylonNode.skeleton) {
+                                    glTFNode.skin = skinMap[babylonNode.skeleton.uniqueId];
                                 }
                             }
                             directDescendents = babylonNode.getDescendants(true);
@@ -1593,12 +1519,11 @@ export class _Exporter {
     }
     /**
      * Creates a mapping of Node unique id to node index and handles animations
-     * @param babylonScene Babylon Scene
      * @param nodes Babylon transform nodes
      * @param binaryWriter Buffer to write binary data to
      * @returns Node mapping of unique id to index
      */
-    _createNodeMapAndAnimationsAsync(babylonScene, nodes, binaryWriter) {
+    _createNodeMapAndAnimationsAsync(nodes, binaryWriter) {
         let promiseChain = Promise.resolve();
         const nodeMap = {};
         let nodeIndex;
@@ -1610,8 +1535,7 @@ export class _Exporter {
         const idleGLTFAnimations = [];
         for (const babylonNode of nodes) {
             promiseChain = promiseChain.then(() => {
-                const convertToRightHandedSystem = this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                return this._createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem).then((node) => {
+                return this._createNodeAsync(babylonNode, binaryWriter).then((node) => {
                     const promise = this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap, binaryWriter);
                     if (promise == null) {
                         Tools.Warn(`Not exporting node ${babylonNode.name}`);
@@ -1625,10 +1549,10 @@ export class _Exporter {
                             this._nodes.push(node);
                             nodeIndex = this._nodes.length - 1;
                             nodeMap[babylonNode.uniqueId] = nodeIndex;
-                            if (!babylonScene.animationGroups.length) {
-                                _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, convertToRightHandedSystem, this._animationSampleRate, this._options.shouldExportAnimation);
+                            if (!this._babylonScene.animationGroups.length) {
+                                _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, this._animationSampleRate, this._options.shouldExportAnimation);
                                 if (babylonNode.animations.length) {
-                                    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, convertToRightHandedSystem, this._animationSampleRate, this._options.shouldExportAnimation);
+                                    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, this._animationSampleRate, this._options.shouldExportAnimation);
                                 }
                             }
                         });
@@ -1645,8 +1569,8 @@ export class _Exporter {
                     this._animations.push(idleGLTFAnimation);
                 }
             });
-            if (babylonScene.animationGroups.length) {
-                _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, this._animations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, this._convertToRightHandedSystemMap, this._animationSampleRate, this._options.shouldExportAnimation);
+            if (this._babylonScene.animationGroups.length) {
+                _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(this._babylonScene, this._animations, nodeMap, binaryWriter, this._bufferViews, this._accessors, this._animationSampleRate, this._options.shouldExportAnimation);
             }
             return nodeMap;
         });
@@ -1655,10 +1579,9 @@ export class _Exporter {
      * Creates a glTF node from a Babylon mesh
      * @param babylonNode Source Babylon mesh
      * @param binaryWriter Buffer for storing geometry data
-     * @param convertToRightHandedSystem Converts the values to right-handed
      * @returns glTF node
      */
-    _createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem) {
+    _createNodeAsync(babylonNode, binaryWriter) {
         return Promise.resolve().then(() => {
             // create node to hold translation/rotation/scale and the mesh
             const node = {};
@@ -1669,7 +1592,7 @@ export class _Exporter {
             }
             if (babylonNode instanceof TransformNode) {
                 // Set transformation
-                this._setNodeTransformation(node, babylonNode, convertToRightHandedSystem);
+                this._setNodeTransformation(node, babylonNode);
                 if (babylonNode instanceof Mesh) {
                     const morphTargetManager = babylonNode.morphTargetManager;
                     if (morphTargetManager && morphTargetManager.numTargets > 0) {
@@ -1679,7 +1602,7 @@ export class _Exporter {
                         }
                     }
                 }
-                return this._setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter, convertToRightHandedSystem).then(() => {
+                return this._setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter).then(() => {
                     if (mesh.primitives.length) {
                         this._meshes.push(mesh);
                         node.mesh = this._meshes.length - 1;
@@ -1688,7 +1611,7 @@ export class _Exporter {
                 });
             }
             else if (babylonNode instanceof Camera) {
-                this._setCameraTransformation(node, babylonNode, convertToRightHandedSystem);
+                this._setCameraTransformation(node, babylonNode);
                 return node;
             }
             else {
@@ -1703,11 +1626,11 @@ export class _Exporter {
      * @param binaryWriter Buffer to write binary data to
      * @returns Node mapping of unique id to index
      */
-    _createSkinsAsync(babylonScene, nodeMap, binaryWriter) {
+    _createSkinsAsync(nodeMap, binaryWriter) {
         var _a;
         const promiseChain = Promise.resolve();
         const skinMap = {};
-        for (const skeleton of babylonScene.skeletons) {
+        for (const skeleton of this._babylonScene.skeletons) {
             if (skeleton.bones.length <= 0) {
                 continue;
             }