babylonjs-serializers 6.6.0 → 6.7.0

package/babylonjs.serializers.module.d.ts

@@ -23,9 +23,9 @@ export class EXT_mesh_gpu_instancing implements IGLTFExporterExtensionV2 {
     dispose(): void;
     /** @internal */
     get wasUsed(): boolean;
-    postExportNodeAsync?(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+    postExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap: {
         [key: number]: number;
-    }, binaryWriter?: _BinaryWriter): Promise<Nullable<INode>>;
+    }, binaryWriter: _BinaryWriter): Promise<Nullable<INode>>;
     private _buildAccessor;
 }
 
@@ -83,7 +83,7 @@ export class KHR_lights_punctual implements IGLTFExporterExtensionV2 {
      * @param nodeMap Node mapping of unique id to glTF node index
      * @returns nullable INode promise
      */
-    postExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+    postExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap: {
         [key: number]: number;
     }): Promise<Nullable<INode>>;
 }
@@ -448,11 +448,10 @@ export class _GLTFAnimation {
      * @param babylonTransformNode - BabylonJS mesh.
      * @param animation - animation.
      * @param animationChannelTargetPath - The target animation channel.
-     * @param convertToRightHandedSystem - Specifies if the values should be converted to right-handed.
      * @param useQuaternion - Specifies if quaternions are used.
      * @returns nullable IAnimationData
      */
-    static _CreateNodeAnimation(babylonTransformNode: Node, animation: Animation, animationChannelTargetPath: AnimationChannelTargetPath, convertToRightHandedSystem: boolean, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
+    static _CreateNodeAnimation(babylonTransformNode: Node, animation: Animation, animationChannelTargetPath: AnimationChannelTargetPath, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
     private static _DeduceAnimationInfo;
     /**
      * @ignore
@@ -465,12 +464,11 @@ export class _GLTFAnimation {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
     static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: {
         [key: number]: number;
-    }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
+    }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
     /**
      * @ignore
      * Create individual morph animations from the mesh's morph target animation tracks
@@ -482,12 +480,11 @@ export class _GLTFAnimation {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
     static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: {
         [key: number]: number;
-    }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
+    }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
     /**
      * @ignore
      * Create node and morph animations from the animation groups
@@ -498,14 +495,11 @@ export class _GLTFAnimation {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystemMap
      * @param animationSampleRate
      */
     static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: IAnimation[], nodeMap: {
         [key: number]: number;
-    }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystemMap: {
-        [nodeId: number]: boolean;
-    }, animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
+    }, binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
     private static _AddAnimation;
     /**
      * Create a baked animation
@@ -521,7 +515,6 @@ export class _GLTFAnimation {
      * @param minMaxFrames
      * @param minMaxFrames.min
      * @param minMaxFrames.max
-     * @param convertToRightHandedSystem converts the values to right-handed
      * @param useQuaternion specifies if quaternions should be used
      */
     private static _CreateBakedAnimation;
@@ -532,10 +525,8 @@ export class _GLTFAnimation {
      * @param babylonTransformNode BabylonJS mesh
      * @param animation BabylonJS animation
      * @param animationChannelTargetPath The target animation channel
-     * @param frameDelta The difference between the last and first frame of the animation
      * @param inputs Array to store the key frame times
      * @param outputs Array to store the key frame data
-     * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
      * @param useQuaternion Specifies if quaternions are used in the animation
      */
     private static _CreateLinearOrStepAnimation;
@@ -547,7 +538,6 @@ export class _GLTFAnimation {
      * @param frameDelta The difference between the last and first frame of the animation
      * @param inputs Array to store the key frame times
      * @param outputs Array to store the key frame data
-     * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
      * @param useQuaternion Specifies if quaternions are used in the animation
      */
     private static _CreateCubicSplineAnimation;
@@ -559,7 +549,6 @@ export class _GLTFAnimation {
      * @param outputs
      * @param animationChannelTargetPath
      * @param babylonTransformNode
-     * @param convertToRightHandedSystem
      * @param useQuaternion
      */
     private static _AddKeyframeValue;
@@ -581,7 +570,6 @@ export class _GLTFAnimation {
      * @param keyFrame The key frame with the animation data
      * @param frameDelta Time difference between two frames used to scale the tangent by the frame delta
      * @param useQuaternion Specifies if quaternions are used
-     * @param convertToRightHandedSystem Specifies if the values should be converted to right-handed
      */
     private static _AddSplineTangent;
     /**
@@ -623,7 +611,6 @@ import { Vector3, Vector4 } from "babylonjs/Maths/math.vector";
 import { Node } from "babylonjs/node";
 import { TransformNode } from "babylonjs/Meshes/transformNode";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
-import { MorphTarget } from "babylonjs/Morph/morphTarget";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { Texture } from "babylonjs/Materials/Textures/texture";
 import { Material } from "babylonjs/Materials/material";
@@ -713,27 +700,11 @@ export class _Exporter {
             mimeType: ImageMimeType;
         };
     };
-    protected _orderedImageData: Array<{
-        data: ArrayBuffer;
-        mimeType: ImageMimeType;
-    }>;
+    private _orderedImageData;
     /**
      * Stores a map of the unique id of a node to its index in the node array
      */
-    _nodeMap: {
-        [key: number]: number;
-    };
-    /**
-     * Specifies if the source Babylon scene was left handed, and needed conversion.
-     */
-    _convertToRightHandedSystem: boolean;
-    /**
-     * Specifies if a Babylon node should be converted to right-handed on export
-     */
-    _convertToRightHandedSystemMap: {
-        [nodeId: number]: boolean;
-    };
-    _includeCoordinateSystemConversionNodes: boolean;
+    private _nodeMap;
     /**
      * Baked animation sample rate
      */
@@ -748,9 +719,9 @@ export class _Exporter {
     private _applyExtensions;
     _extensionsPreExportTextureAsync(context: string, babylonTexture: Nullable<Texture>, mimeType: ImageMimeType): Promise<Nullable<BaseTexture>>;
     _extensionsPostExportMeshPrimitiveAsync(context: string, meshPrimitive: IMeshPrimitive, babylonSubMesh: SubMesh, binaryWriter: _BinaryWriter): Promise<Nullable<IMeshPrimitive>>;
-    _extensionsPostExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+    _extensionsPostExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap: {
         [key: number]: number;
-    }, binaryWriter?: _BinaryWriter): Promise<Nullable<INode>>;
+    }, binaryWriter: _BinaryWriter): Promise<Nullable<INode>>;
     _extensionsPostExportMaterialAsync(context: string, material: Nullable<IMaterial>, babylonMaterial: Material): Promise<Nullable<IMaterial>>;
     _extensionsPostExportMaterialAdditionalTextures(context: string, material: IMaterial, babylonMaterial: Material): BaseTexture[];
     _extensionsPostExportTextures(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
@@ -786,51 +757,40 @@ 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
      */
     private _reorderVertexAttributeDataBasedOnPrimitiveMode;
     /**
      * 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
      */
     private _reorderTriangleFillMode;
     /**
      * 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
      */
     private _reorderTriangleStripDrawMode;
     /**
      * 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
      */
     private _reorderTriangleFanMode;
     /**
@@ -838,9 +798,7 @@ 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
      */
     private _writeVertexAttributeData;
     /**
@@ -851,10 +809,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: string, attributeComponentKind: AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, babylonTransformNode: TransformNode): void;
+    _writeAttributeData(vertexBufferKind: string, attributeComponentKind: AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, babylonTransformNode: TransformNode): void;
     /**
      * Writes mesh attribute data to a data buffer
      * Returns the bytelength of the data
@@ -866,10 +823,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: string, attributeComponentKind: AccessorComponentType, meshPrimitive: SubMesh, morphTarget: MorphTarget, meshAttributeArray: FloatArray, morphTargetAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, minMax?: any): void;
+    writeMorphTargetAttributeData(vertexBufferKind: string, attributeComponentKind: AccessorComponentType, meshPrimitive: SubMesh, meshAttributeArray: FloatArray, morphTargetAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, minMax?: any): void;
     /**
      * Generates glTF json data
      * @param shouldUseGlb Indicates whether the json should be written for a glb file
@@ -904,7 +860,6 @@ 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
      */
     private _setNodeTransformation;
     private _setCameraTransformation;
@@ -916,7 +871,6 @@ 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
      */
     private _createBufferViewKind;
     /**
@@ -925,7 +879,6 @@ 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
      */
     private _setMorphTargetAttributes;
     /**
@@ -951,15 +904,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
      */
     private _setPrimitiveAttributesAsync;
-    /**
-     * 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
-     */
-    private _isBabylonCoordinateSystemConvertingNode;
     /**
      * Creates a glTF scene based on the array of meshes
      * Returns the the total byte offset
@@ -976,7 +922,6 @@ export class _Exporter {
     private _getExportNodes;
     /**
      * 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
@@ -986,7 +931,6 @@ 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
      */
     private _createNodeAsync;
@@ -1134,9 +1078,9 @@ export interface IGLTFExporterExtensionV2 extends IGLTFExporterExtension, IDispo
      * @param babylonNode BabylonJS node
      * @returns nullable INode promise
      */
-    postExportNodeAsync?(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+    postExportNodeAsync?(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap: {
         [key: number]: number;
-    }, binaryWriter?: _BinaryWriter): Promise<Nullable<INode>>;
+    }, binaryWriter: _BinaryWriter): Promise<Nullable<INode>>;
     /**
      * Define this method to modify the default behavior when exporting a material
      * @param material glTF material
@@ -1386,19 +1330,24 @@ export interface IExportOptions {
      */
     metadataSelector?(metadata: any): any;
     /**
-     * The sample rate to bake animation curves
+     * The sample rate to bake animation curves. Defaults to 1 / 60.
      */
     animationSampleRate?: number;
     /**
-     * Begin serialization without waiting for the scene to be ready
+     * Begin serialization without waiting for the scene to be ready. Defaults to false.
      */
     exportWithoutWaitingForScene?: boolean;
     /**
-     * Indicates if unused vertex uv attributes should be included in export
+     * Indicates if unused vertex uv attributes should be included in export. Defaults to false.
      */
     exportUnusedUVs?: boolean;
     /**
-     * Indicates if coordinate system swapping root nodes should be included in export
+     * Remove no-op root nodes when possible. Defaults to true.
+     */
+    removeNoopRootNodes?: boolean;
+    /**
+     * Indicates if coordinate system swapping root nodes should be included in export. Defaults to false.
+     * @deprecated Please use removeNoopRootNodes instead
      */
     includeCoordinateSystemConversionNodes?: boolean;
 }
@@ -1432,8 +1381,7 @@ declare module "babylonjs-serializers/glTF/2.0/glTFUtilities" {
 import { IBufferView, AccessorComponentType, IAccessor } from "babylonjs-gltf2interface";
 import { AccessorType } from "babylonjs-gltf2interface";
 import { FloatArray, Nullable } from "babylonjs/types";
-import { Vector4, Quaternion } from "babylonjs/Maths/math.vector";
-import { Vector3 } from "babylonjs/Maths/math.vector";
+import { Vector4 } from "babylonjs/Maths/math.vector";
 /**
  * @internal
  */
@@ -1466,65 +1414,12 @@ export class _GLTFUtilities {
      * @param positions Positions array of a mesh
      * @param vertexStart Starting vertex offset to calculate min and max values
      * @param vertexCount Number of vertices to check for min and max values
-     * @param convertToRightHandedSystem
      * @returns min number array and max number array
      */
-    static _CalculateMinMaxPositions(positions: FloatArray, vertexStart: number, vertexCount: number, convertToRightHandedSystem: boolean): {
+    static _CalculateMinMaxPositions(positions: FloatArray, vertexStart: number, vertexCount: number): {
         min: number[];
         max: number[];
     };
-    /**
-     * Converts a new right-handed Vector3
-     * @param vector vector3 array
-     * @returns right-handed Vector3
-     */
-    static _GetRightHandedPositionVector3(vector: Vector3): Vector3;
-    /**
-     * Converts a Vector3 to right-handed
-     * @param vector Vector3 to convert to right-handed
-     */
-    static _GetRightHandedPositionVector3FromRef(vector: Vector3): void;
-    /**
-     * Converts a three element number array to right-handed
-     * @param vector number array to convert to right-handed
-     */
-    static _GetRightHandedPositionArray3FromRef(vector: number[]): void;
-    /**
-     * Converts a new right-handed Vector3
-     * @param vector vector3 array
-     * @returns right-handed Vector3
-     */
-    static _GetRightHandedNormalVector3(vector: Vector3): Vector3;
-    /**
-     * Converts a Vector3 to right-handed
-     * @param vector Vector3 to convert to right-handed
-     */
-    static _GetRightHandedNormalVector3FromRef(vector: Vector3): void;
-    /**
-     * Converts a three element number array to right-handed
-     * @param vector number array to convert to right-handed
-     */
-    static _GetRightHandedNormalArray3FromRef(vector: number[]): void;
-    /**
-     * Converts a Vector4 to right-handed
-     * @param vector Vector4 to convert to right-handed
-     */
-    static _GetRightHandedVector4FromRef(vector: Vector4): void;
-    /**
-     * Converts a Vector4 to right-handed
-     * @param vector Vector4 to convert to right-handed
-     */
-    static _GetRightHandedArray4FromRef(vector: number[]): void;
-    /**
-     * Converts a Quaternion to right-handed
-     * @param quaternion Source quaternion to convert to right-handed
-     */
-    static _GetRightHandedQuaternionFromRef(quaternion: Quaternion): void;
-    /**
-     * Converts a Quaternion to right-handed
-     * @param quaternion Source quaternion to convert to right-handed
-     */
-    static _GetRightHandedQuaternionArrayFromRef(quaternion: number[]): void;
     static _NormalizeTangentFromRef(tangent: Vector4): void;
     static _GetDataAccessorElementCount(accessorType: AccessorType): 1 | 3 | 2 | 4 | 9 | 16;
 }
@@ -1673,9 +1568,9 @@ declare module BABYLON {
         dispose(): void;
         /** @internal */
         get wasUsed(): boolean;
-        postExportNodeAsync?(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap: {
             [key: number]: number;
-        }, binaryWriter?: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.INode>>;
+        }, binaryWriter: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.INode>>;
         private _buildAccessor;
     }
 
@@ -1713,7 +1608,7 @@ declare module BABYLON {
          * @param nodeMap Node mapping of unique id to glTF node index
          * @returns nullable BABYLON.GLTF2.INode promise
          */
-        postExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap: {
             [key: number]: number;
         }): Promise<Nullable<BABYLON.GLTF2.INode>>;
     }
@@ -2011,11 +1906,10 @@ declare module BABYLON {
          * @param babylonTransformNode - BabylonJS mesh.
          * @param animation - animation.
          * @param animationChannelTargetPath - The target animation channel.
-         * @param convertToRightHandedSystem - Specifies if the values should be converted to right-handed.
          * @param useQuaternion - Specifies if quaternions are used.
          * @returns nullable IAnimationData
          */
-        static _CreateNodeAnimation(babylonTransformNode: Node, animation: Animation, animationChannelTargetPath: BABYLON.GLTF2.AnimationChannelTargetPath, convertToRightHandedSystem: boolean, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
+        static _CreateNodeAnimation(babylonTransformNode: Node, animation: Animation, animationChannelTargetPath: BABYLON.GLTF2.AnimationChannelTargetPath, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
         private static _DeduceAnimationInfo;
         /**
          * @ignore
@@ -2028,12 +1922,11 @@ declare module BABYLON {
          * @param binaryWriter
          * @param bufferViews
          * @param accessors
-         * @param convertToRightHandedSystem
          * @param animationSampleRate
          */
         static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: BABYLON.GLTF2.IAnimation, idleGLTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
         /**
          * @ignore
          * Create individual morph animations from the mesh's morph target animation tracks
@@ -2045,12 +1938,11 @@ declare module BABYLON {
          * @param binaryWriter
          * @param bufferViews
          * @param accessors
-         * @param convertToRightHandedSystem
          * @param animationSampleRate
          */
         static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: BABYLON.GLTF2.IAnimation, idleGLTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
         /**
          * @ignore
          * Create node and morph animations from the animation groups
@@ -2061,14 +1953,11 @@ declare module BABYLON {
          * @param binaryWriter
          * @param bufferViews
          * @param accessors
-         * @param convertToRightHandedSystemMap
          * @param animationSampleRate
          */
         static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystemMap: {
-            [nodeId: number]: boolean;
-        }, animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
+        }, binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], animationSampleRate: number, shouldExportAnimation?: (animation: Animation) => boolean): void;
         private static _AddAnimation;
         /**
          * Create a baked animation
@@ -2084,7 +1973,6 @@ declare module BABYLON {
          * @param minMaxFrames
          * @param minMaxFrames.min
          * @param minMaxFrames.max
-         * @param convertToRightHandedSystem converts the values to right-handed
          * @param useQuaternion specifies if quaternions should be used
          */
         private static _CreateBakedAnimation;
@@ -2095,10 +1983,8 @@ declare module BABYLON {
          * @param babylonTransformNode BabylonJS mesh
          * @param animation BabylonJS animation
          * @param animationChannelTargetPath The target animation channel
-         * @param frameDelta The difference between the last and first frame of the animation
          * @param inputs Array to store the key frame times
          * @param outputs Array to store the key frame data
-         * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
          * @param useQuaternion Specifies if quaternions are used in the animation
          */
         private static _CreateLinearOrStepAnimation;
@@ -2110,7 +1996,6 @@ declare module BABYLON {
          * @param frameDelta The difference between the last and first frame of the animation
          * @param inputs Array to store the key frame times
          * @param outputs Array to store the key frame data
-         * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
          * @param useQuaternion Specifies if quaternions are used in the animation
          */
         private static _CreateCubicSplineAnimation;
@@ -2122,7 +2007,6 @@ declare module BABYLON {
          * @param outputs
          * @param animationChannelTargetPath
          * @param babylonTransformNode
-         * @param convertToRightHandedSystem
          * @param useQuaternion
          */
         private static _AddKeyframeValue;
@@ -2144,7 +2028,6 @@ declare module BABYLON {
          * @param keyFrame The key frame with the animation data
          * @param frameDelta Time difference between two frames used to scale the tangent by the frame delta
          * @param useQuaternion Specifies if quaternions are used
-         * @param convertToRightHandedSystem Specifies if the values should be converted to right-handed
          */
         private static _AddSplineTangent;
         /**
@@ -2258,27 +2141,11 @@ declare module BABYLON {
                 mimeType: BABYLON.GLTF2.ImageMimeType;
             };
         };
-        protected _orderedImageData: Array<{
-            data: ArrayBuffer;
-            mimeType: BABYLON.GLTF2.ImageMimeType;
-        }>;
+        private _orderedImageData;
         /**
          * Stores a map of the unique id of a node to its index in the node array
          */
-        _nodeMap: {
-            [key: number]: number;
-        };
-        /**
-         * Specifies if the source Babylon scene was left handed, and needed conversion.
-         */
-        _convertToRightHandedSystem: boolean;
-        /**
-         * Specifies if a Babylon node should be converted to right-handed on export
-         */
-        _convertToRightHandedSystemMap: {
-            [nodeId: number]: boolean;
-        };
-        _includeCoordinateSystemConversionNodes: boolean;
+        private _nodeMap;
         /**
          * Baked animation sample rate
          */
@@ -2293,9 +2160,9 @@ declare module BABYLON {
         private _applyExtensions;
         _extensionsPreExportTextureAsync(context: string, babylonTexture: Nullable<Texture>, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Nullable<BaseTexture>>;
         _extensionsPostExportMeshPrimitiveAsync(context: string, meshPrimitive: BABYLON.GLTF2.IMeshPrimitive, babylonSubMesh: SubMesh, binaryWriter: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.IMeshPrimitive>>;
-        _extensionsPostExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
+        _extensionsPostExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap: {
             [key: number]: number;
-        }, binaryWriter?: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.INode>>;
+        }, binaryWriter: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.INode>>;
         _extensionsPostExportMaterialAsync(context: string, material: Nullable<BABYLON.GLTF2.IMaterial>, babylonMaterial: Material): Promise<Nullable<BABYLON.GLTF2.IMaterial>>;
         _extensionsPostExportMaterialAdditionalTextures(context: string, material: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
         _extensionsPostExportTextures(context: string, textureInfo: BABYLON.GLTF2.ITextureInfo, babylonTexture: BaseTexture): void;
@@ -2331,51 +2198,40 @@ declare module BABYLON {
          * 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
          */
         private _reorderVertexAttributeDataBasedOnPrimitiveMode;
         /**
          * 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
          */
         private _reorderTriangleFillMode;
         /**
          * 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
          */
         private _reorderTriangleStripDrawMode;
         /**
          * 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
          */
         private _reorderTriangleFanMode;
         /**
@@ -2383,9 +2239,7 @@ declare module BABYLON {
          * @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
          */
         private _writeVertexAttributeData;
         /**
@@ -2396,10 +2250,9 @@ declare module BABYLON {
          * @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: string, attributeComponentKind: BABYLON.GLTF2.AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, babylonTransformNode: TransformNode): void;
+        _writeAttributeData(vertexBufferKind: string, attributeComponentKind: BABYLON.GLTF2.AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, babylonTransformNode: TransformNode): void;
         /**
          * Writes mesh attribute data to a data buffer
          * Returns the bytelength of the data
@@ -2411,10 +2264,9 @@ declare module BABYLON {
          * @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: string, attributeComponentKind: BABYLON.GLTF2.AccessorComponentType, meshPrimitive: SubMesh, morphTarget: MorphTarget, meshAttributeArray: FloatArray, morphTargetAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, minMax?: any): void;
+        writeMorphTargetAttributeData(vertexBufferKind: string, attributeComponentKind: BABYLON.GLTF2.AccessorComponentType, meshPrimitive: SubMesh, meshAttributeArray: FloatArray, morphTargetAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, minMax?: any): void;
         /**
          * Generates glTF json data
          * @param shouldUseGlb Indicates whether the json should be written for a glb file
@@ -2449,7 +2301,6 @@ declare module BABYLON {
          * 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
          */
         private _setNodeTransformation;
         private _setCameraTransformation;
@@ -2461,7 +2312,6 @@ declare module BABYLON {
          * @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
          */
         private _createBufferViewKind;
         /**
@@ -2470,7 +2320,6 @@ declare module BABYLON {
          * @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
          */
         private _setMorphTargetAttributes;
         /**
@@ -2496,15 +2345,8 @@ declare module BABYLON {
          * @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
          */
         private _setPrimitiveAttributesAsync;
-        /**
-         * 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
-         */
-        private _isBabylonCoordinateSystemConvertingNode;
         /**
          * Creates a glTF scene based on the array of meshes
          * Returns the the total byte offset
@@ -2521,7 +2363,6 @@ declare module BABYLON {
         private _getExportNodes;
         /**
          * 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
@@ -2531,7 +2372,6 @@ declare module BABYLON {
          * 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
          */
         private _createNodeAsync;
@@ -2668,9 +2508,9 @@ declare module BABYLON {
          * @param babylonNode BabylonJS node
          * @returns nullable BABYLON.GLTF2.INode promise
          */
-        postExportNodeAsync?(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync?(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap: {
             [key: number]: number;
-        }, binaryWriter?: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.INode>>;
+        }, binaryWriter: _BinaryWriter): Promise<Nullable<BABYLON.GLTF2.INode>>;
         /**
          * Define this method to modify the default behavior when exporting a material
          * @param material glTF material
@@ -2905,19 +2745,24 @@ declare module BABYLON {
          */
         metadataSelector?(metadata: any): any;
         /**
-         * The sample rate to bake animation curves
+         * The sample rate to bake animation curves. Defaults to 1 / 60.
          */
         animationSampleRate?: number;
         /**
-         * Begin serialization without waiting for the scene to be ready
+         * Begin serialization without waiting for the scene to be ready. Defaults to false.
          */
         exportWithoutWaitingForScene?: boolean;
         /**
-         * Indicates if unused vertex uv attributes should be included in export
+         * Indicates if unused vertex uv attributes should be included in export. Defaults to false.
          */
         exportUnusedUVs?: boolean;
         /**
-         * Indicates if coordinate system swapping root nodes should be included in export
+         * Remove no-op root nodes when possible. Defaults to true.
+         */
+        removeNoopRootNodes?: boolean;
+        /**
+         * Indicates if coordinate system swapping root nodes should be included in export. Defaults to false.
+         * @deprecated Please use removeNoopRootNodes instead
          */
         includeCoordinateSystemConversionNodes?: boolean;
     }
@@ -2979,65 +2824,12 @@ declare module BABYLON {
          * @param positions Positions array of a mesh
          * @param vertexStart Starting vertex offset to calculate min and max values
          * @param vertexCount Number of vertices to check for min and max values
-         * @param convertToRightHandedSystem
          * @returns min number array and max number array
          */
-        static _CalculateMinMaxPositions(positions: FloatArray, vertexStart: number, vertexCount: number, convertToRightHandedSystem: boolean): {
+        static _CalculateMinMaxPositions(positions: FloatArray, vertexStart: number, vertexCount: number): {
             min: number[];
             max: number[];
         };
-        /**
-         * Converts a new right-handed Vector3
-         * @param vector vector3 array
-         * @returns right-handed Vector3
-         */
-        static _GetRightHandedPositionVector3(vector: Vector3): Vector3;
-        /**
-         * Converts a Vector3 to right-handed
-         * @param vector Vector3 to convert to right-handed
-         */
-        static _GetRightHandedPositionVector3FromRef(vector: Vector3): void;
-        /**
-         * Converts a three element number array to right-handed
-         * @param vector number array to convert to right-handed
-         */
-        static _GetRightHandedPositionArray3FromRef(vector: number[]): void;
-        /**
-         * Converts a new right-handed Vector3
-         * @param vector vector3 array
-         * @returns right-handed Vector3
-         */
-        static _GetRightHandedNormalVector3(vector: Vector3): Vector3;
-        /**
-         * Converts a Vector3 to right-handed
-         * @param vector Vector3 to convert to right-handed
-         */
-        static _GetRightHandedNormalVector3FromRef(vector: Vector3): void;
-        /**
-         * Converts a three element number array to right-handed
-         * @param vector number array to convert to right-handed
-         */
-        static _GetRightHandedNormalArray3FromRef(vector: number[]): void;
-        /**
-         * Converts a Vector4 to right-handed
-         * @param vector Vector4 to convert to right-handed
-         */
-        static _GetRightHandedVector4FromRef(vector: Vector4): void;
-        /**
-         * Converts a Vector4 to right-handed
-         * @param vector Vector4 to convert to right-handed
-         */
-        static _GetRightHandedArray4FromRef(vector: number[]): void;
-        /**
-         * Converts a Quaternion to right-handed
-         * @param quaternion Source quaternion to convert to right-handed
-         */
-        static _GetRightHandedQuaternionFromRef(quaternion: Quaternion): void;
-        /**
-         * Converts a Quaternion to right-handed
-         * @param quaternion Source quaternion to convert to right-handed
-         */
-        static _GetRightHandedQuaternionArrayFromRef(quaternion: number[]): void;
         static _NormalizeTangentFromRef(tangent: Vector4): void;
         static _GetDataAccessorElementCount(accessorType: BABYLON.GLTF2.AccessorType): 1 | 3 | 2 | 4 | 9 | 16;
     }