babylonjs-serializers 6.6.0 → 6.7.0

package/babylonjs.serializers.d.ts

@@ -16,9 +16,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;
     }
 
@@ -56,7 +56,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>>;
     }
@@ -354,11 +354,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
@@ -371,12 +370,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
@@ -388,12 +386,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
@@ -404,14 +401,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
@@ -427,7 +421,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;
@@ -438,10 +431,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;
@@ -453,7 +444,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;
@@ -465,7 +455,6 @@ declare module BABYLON {
          * @param outputs
          * @param animationChannelTargetPath
          * @param babylonTransformNode
-         * @param convertToRightHandedSystem
          * @param useQuaternion
          */
         private static _AddKeyframeValue;
@@ -487,7 +476,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;
         /**
@@ -601,27 +589,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
          */
@@ -636,9 +608,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;
@@ -674,51 +646,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;
         /**
@@ -726,9 +687,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;
         /**
@@ -739,10 +698,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
@@ -754,10 +712,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
@@ -792,7 +749,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;
@@ -804,7 +760,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;
         /**
@@ -813,7 +768,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;
         /**
@@ -839,15 +793,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
@@ -864,7 +811,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
@@ -874,7 +820,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;
@@ -1011,9 +956,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
@@ -1248,19 +1193,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;
     }
@@ -1322,65 +1272,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;
     }