npm - babylonjs-serializers - Versions diffs - 5.0.0 → 5.0.1 - Mend

babylonjs-serializers 5.0.0 → 5.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/babylonjs.serializers.d.ts +79 -79
package/babylonjs.serializers.module.d.ts +79 -79
package/package.json +3 -3

package/babylonjs.serializers.d.ts CHANGED Viewed

@@ -32,11 +32,11 @@ declare module BABYLON {
          * @param node glTF node
          * @param babylonNode BabylonJS node
          * @param nodeMap Node mapping of unique id to glTF node index
-         * @returns nullable INode promise
+         * @returns nullable BABYLON.GLTF2.INode promise
          */
-        postExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
             [key: number]: number;
-        }): Promise<Nullable<INode>>;
+        }): Promise<Nullable<BABYLON.GLTF2.INode>>;
     }
@@ -56,8 +56,8 @@ declare module BABYLON {
         dispose(): void;
         /** @hidden */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
-        postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
@@ -77,8 +77,8 @@ declare module BABYLON {
         dispose(): void;
         /** @hidden */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
-        postExportMaterialAsync(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAdditionalTextures(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAsync(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
@@ -97,7 +97,7 @@ declare module BABYLON {
         /** @hidden */
         get wasUsed(): boolean;
         dispose(): void;
-        postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
@@ -118,7 +118,7 @@ declare module BABYLON {
         dispose(): void;
         /** @hidden */
         get wasUsed(): boolean;
-        postExportTexture?(context: string, textureInfo: ITextureInfo, babylonTexture: Texture): void;
+        postExportTexture?(context: string, textureInfo: BABYLON.GLTF2.ITextureInfo, babylonTexture: Texture): void;
         preExportTextureAsync(context: string, babylonTexture: Texture): Promise<Texture>;
         /**
          * Transform the babylon texture by the offset, rotation and scale parameters using a procedural texture
@@ -143,9 +143,9 @@ declare module BABYLON {
          */
         outputs: number[][];
         /**
-         * BABYLON.Animation interpolation data.
+         * Animation interpolation data.
          */
-        samplerInterpolation: AnimationSamplerInterpolation;
+        samplerInterpolation: BABYLON.GLTF2.AnimationSamplerInterpolation;
         /**
          * Minimum keyframe value.
          */
@@ -162,11 +162,11 @@ declare module BABYLON {
         /**
          * The target channel for the animation
          */
-        animationChannelTargetPath: AnimationChannelTargetPath;
+        animationChannelTargetPath: BABYLON.GLTF2.AnimationChannelTargetPath;
         /**
          * The glTF accessor type for the data.
          */
-        dataAccessorType: AccessorType.VEC3 | AccessorType.VEC4 | AccessorType.SCALAR;
+        dataAccessorType: BABYLON.GLTF2.AccessorType.VEC3 | BABYLON.GLTF2.AccessorType.VEC4 | BABYLON.GLTF2.AccessorType.SCALAR;
         /**
          * Specifies if quaternions should be used.
          */
@@ -188,7 +188,7 @@ declare module BABYLON {
          * @param useQuaternion - Specifies if quaternions are used.
          * @returns nullable IAnimationData
          */
-        static _CreateNodeAnimation(babylonTransformNode: BABYLON.TransformNode, animation: BABYLON.Animation, animationChannelTargetPath: AnimationChannelTargetPath, convertToRightHandedSystem: boolean, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
+        static _CreateNodeAnimation(babylonTransformNode: TransformNode, animation: Animation, animationChannelTargetPath: BABYLON.GLTF2.AnimationChannelTargetPath, convertToRightHandedSystem: boolean, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
         private static _DeduceAnimationInfo;
         /**
          * @ignore
@@ -204,9 +204,9 @@ declare module BABYLON {
          * @param convertToRightHandedSystem
          * @param animationSampleRate
          */
-        static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: {
+        static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: BABYLON.GLTF2.IAnimation, idleGLTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
         /**
          * @ignore
          * Create individual morph animations from the mesh's morph target animation tracks
@@ -221,9 +221,9 @@ declare module BABYLON {
          * @param convertToRightHandedSystem
          * @param animationSampleRate
          */
-        static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: {
+        static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: BABYLON.GLTF2.IAnimation, idleGLTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
         /**
          * @ignore
          * Create node and morph animations from the animation groups
@@ -237,9 +237,9 @@ declare module BABYLON {
          * @param convertToRightHandedSystemMap
          * @param animationSampleRate
          */
-        static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: IAnimation[], nodeMap: {
+        static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystemMap: {
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystemMap: {
             [nodeId: number]: boolean;
         }, animationSampleRate: number): void;
         private static _AddAnimation;
@@ -358,19 +358,19 @@ declare module BABYLON {
         /**
          * Stores the glTF to export
          */
-        _glTF: IGLTF;
+        _glTF: BABYLON.GLTF2.IGLTF;
         /**
          * Stores all generated buffer views, which represents views into the main glTF buffer data
          */
-        _bufferViews: IBufferView[];
+        _bufferViews: BABYLON.GLTF2.IBufferView[];
         /**
          * Stores all the generated accessors, which is used for accessing the data within the buffer views in glTF
          */
-        _accessors: IAccessor[];
+        _accessors: BABYLON.GLTF2.IAccessor[];
         /**
          * Stores all the generated nodes, which contains transform and/or mesh information per node
          */
-        _nodes: INode[];
+        _nodes: BABYLON.GLTF2.INode[];
         /**
          * Stores all the generated glTF scenes, which stores multiple node hierarchies
          */
@@ -386,26 +386,26 @@ declare module BABYLON {
         /**
          * Stores all the generated material information, which represents the appearance of each primitive
          */
-        _materials: IMaterial[];
+        _materials: BABYLON.GLTF2.IMaterial[];
         _materialMap: {
             [materialID: number]: number;
         };
         /**
          * Stores all the generated texture information, which is referenced by glTF materials
          */
-        _textures: ITexture[];
+        _textures: BABYLON.GLTF2.ITexture[];
         /**
          * Stores all the generated image information, which is referenced by glTF textures
          */
-        _images: IImage[];
+        _images: BABYLON.GLTF2.IImage[];
         /**
          * Stores all the texture samplers
          */
-        _samplers: ISampler[];
+        _samplers: BABYLON.GLTF2.ISampler[];
         /**
          * Stores all the generated glTF skins
          */
-        _skins: ISkin[];
+        _skins: BABYLON.GLTF2.ISkin[];
         /**
          * Stores all the generated animation samplers, which is referenced by glTF animations
          */
@@ -428,12 +428,12 @@ declare module BABYLON {
         _imageData: {
             [fileName: string]: {
                 data: Uint8Array;
-                mimeType: ImageMimeType;
+                mimeType: BABYLON.GLTF2.ImageMimeType;
             };
         };
         protected _orderedImageData: Array<{
             data: Uint8Array;
-            mimeType: ImageMimeType;
+            mimeType: BABYLON.GLTF2.ImageMimeType;
         }>;
         /**
          * Stores a map of the unique id of a node to its index in the node array
@@ -464,14 +464,14 @@ declare module BABYLON {
         private static _ExtensionFactories;
         private _applyExtension;
         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?: {
+        _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?: {
             [key: number]: number;
-        }): Promise<Nullable<INode>>;
-        _extensionsPostExportMaterialAsync(context: string, material: Nullable<IMaterial>, babylonMaterial: BABYLON.Material): Promise<Nullable<IMaterial>>;
-        _extensionsPostExportMaterialAdditionalTextures(context: string, material: IMaterial, babylonMaterial: BABYLON.Material): BaseTexture[];
-        _extensionsPostExportTextures(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
+        }): 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;
         private _forEachExtensions;
         private _extensionsOnExporting;
         /**
@@ -571,7 +571,7 @@ declare module BABYLON {
          * @param convertToRightHandedSystem Converts the values to right-handed
          * @param babylonTransformNode
          */
-        _writeAttributeData(vertexBufferKind: string, attributeComponentKind: AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, babylonTransformNode: BABYLON.TransformNode): void;
+        _writeAttributeData(vertexBufferKind: string, attributeComponentKind: BABYLON.GLTF2.AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, babylonTransformNode: TransformNode): void;
         /**
          * Writes mesh attribute data to a data buffer
          * Returns the bytelength of the data
@@ -586,7 +586,7 @@ declare module BABYLON {
          * @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: BABYLON.GLTF2.AccessorComponentType, meshPrimitive: SubMesh, morphTarget: MorphTarget, meshAttributeArray: FloatArray, morphTargetAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, minMax?: any): void;
         /**
          * Generates glTF json data
          * @param shouldUseGlb Indicates whether the json should be written for a glb file
@@ -773,10 +773,10 @@ declare module BABYLON {
          * @param byteOffset If defined, specifies where to set the value as an offset.
          */
         getUInt32(byteOffset: number): number;
-        getVector3Float32FromRef(vector3: BABYLON.Vector3, byteOffset: number): void;
-        setVector3Float32FromRef(vector3: BABYLON.Vector3, byteOffset: number): void;
-        getVector4Float32FromRef(vector4: BABYLON.Vector4, byteOffset: number): void;
-        setVector4Float32FromRef(vector4: BABYLON.Vector4, byteOffset: number): void;
+        getVector3Float32FromRef(vector3: Vector3, byteOffset: number): void;
+        setVector3Float32FromRef(vector3: Vector3, byteOffset: number): void;
+        getVector4Float32FromRef(vector4: Vector4, byteOffset: number): void;
+        setVector4Float32FromRef(vector4: Vector4, byteOffset: number): void;
         /**
          * Stores a Float32 in the array buffer
          * @param entry
@@ -806,47 +806,47 @@ declare module BABYLON {
          * @param mimeType The mime-type of the generated image
          * @returns A promise that resolves with the exported texture
          */
-        preExportTextureAsync?(context: string, babylonTexture: Nullable<Texture>, mimeType: ImageMimeType): Promise<Texture>;
+        preExportTextureAsync?(context: string, babylonTexture: Nullable<Texture>, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Texture>;
         /**
          * Define this method to get notified when a texture info is created
          * @param context The context when loading the asset
          * @param textureInfo The glTF texture info
          * @param babylonTexture The Babylon.js texture
          */
-        postExportTexture?(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
+        postExportTexture?(context: string, textureInfo: BABYLON.GLTF2.ITextureInfo, babylonTexture: BaseTexture): void;
         /**
          * Define this method to modify the default behavior when exporting texture info
          * @param context The context when loading the asset
          * @param meshPrimitive glTF mesh primitive
          * @param babylonSubMesh Babylon submesh
          * @param binaryWriter glTF serializer binary writer instance
-         * @returns nullable IMeshPrimitive promise
+         * @returns nullable BABYLON.GLTF2.IMeshPrimitive promise
          */
-        postExportMeshPrimitiveAsync?(context: string, meshPrimitive: Nullable<IMeshPrimitive>, babylonSubMesh: SubMesh, binaryWriter: _BinaryWriter): Promise<IMeshPrimitive>;
+        postExportMeshPrimitiveAsync?(context: string, meshPrimitive: Nullable<BABYLON.GLTF2.IMeshPrimitive>, babylonSubMesh: SubMesh, binaryWriter: _BinaryWriter): Promise<BABYLON.GLTF2.IMeshPrimitive>;
         /**
          * Define this method to modify the default behavior when exporting a node
          * @param context The context when exporting the node
          * @param node glTF node
          * @param babylonNode BabylonJS node
-         * @returns nullable INode promise
+         * @returns nullable BABYLON.GLTF2.INode promise
          */
-        postExportNodeAsync?(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync?(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
             [key: number]: number;
-        }): Promise<Nullable<INode>>;
+        }): Promise<Nullable<BABYLON.GLTF2.INode>>;
         /**
          * Define this method to modify the default behavior when exporting a material
          * @param material glTF material
          * @param babylonMaterial BabylonJS material
-         * @returns nullable IMaterial promise
+         * @returns nullable BABYLON.GLTF2.IMaterial promise
          */
-        postExportMaterialAsync?(context: string, node: Nullable<IMaterial>, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAsync?(context: string, node: Nullable<BABYLON.GLTF2.IMaterial>, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
         /**
          * Define this method to return additional textures to export from a material
          * @param material glTF material
          * @param babylonMaterial BabylonJS material
          * @returns List of textures
          */
-        postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
         /** Gets a boolean indicating that this extension was used */
         wasUsed: boolean;
         /** Gets a boolean indicating that this extension is required for the file to work */
@@ -897,26 +897,26 @@ declare module BABYLON {
          * @param mimeType texture mime type
          * @param hasTextureCoords specifies if texture coordinates are present on the material
          */
-        _convertMaterialsToGLTFAsync(exportMaterials: Set<Material>, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<void>;
+        _convertMaterialsToGLTFAsync(exportMaterials: Set<Material>, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<void>;
         /**
          * Makes a copy of the glTF material without the texture parameters
          * @param originalMaterial original glTF material
          * @returns glTF material without texture parameters
          */
-        _stripTexturesFromMaterial(originalMaterial: IMaterial): IMaterial;
+        _stripTexturesFromMaterial(originalMaterial: BABYLON.GLTF2.IMaterial): BABYLON.GLTF2.IMaterial;
         /**
          * Specifies if the material has any texture parameters present
          * @param material glTF Material
          * @returns boolean specifying if texture parameters are present
          */
-        _hasTexturesPresent(material: IMaterial): boolean;
-        _getTextureInfo(babylonTexture: Nullable<BaseTexture>): Nullable<ITextureInfo>;
+        _hasTexturesPresent(material: BABYLON.GLTF2.IMaterial): boolean;
+        _getTextureInfo(babylonTexture: Nullable<BaseTexture>): Nullable<BABYLON.GLTF2.ITextureInfo>;
         /**
          * Converts a Babylon StandardMaterial to a glTF Metallic Roughness Material
          * @param babylonStandardMaterial
          * @returns glTF Metallic Roughness Material representation
          */
-        _convertToGLTFPBRMetallicRoughness(babylonStandardMaterial: StandardMaterial): IMaterialPbrMetallicRoughness;
+        _convertToGLTFPBRMetallicRoughness(babylonStandardMaterial: StandardMaterial): BABYLON.GLTF2.IMaterialPbrMetallicRoughness;
         /**
          * Computes the metallic factor
          * @param diffuse diffused value
@@ -937,7 +937,7 @@ declare module BABYLON {
          * @param mimeType mime type to use for the textures
          * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
          */
-        _convertStandardMaterialAsync(babylonStandardMaterial: StandardMaterial, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<IMaterial>;
+        _convertStandardMaterialAsync(babylonStandardMaterial: StandardMaterial, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<BABYLON.GLTF2.IMaterial>;
         private _finishMaterial;
         /**
          * Converts a Babylon PBR Metallic Roughness Material to a glTF Material
@@ -945,7 +945,7 @@ declare module BABYLON {
          * @param mimeType mime type to use for the textures
          * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
          */
-        _convertPBRMetallicRoughnessMaterialAsync(babylonPBRMetalRoughMaterial: PBRMetallicRoughnessMaterial, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<IMaterial>;
+        _convertPBRMetallicRoughnessMaterialAsync(babylonPBRMetalRoughMaterial: PBRMetallicRoughnessMaterial, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<BABYLON.GLTF2.IMaterial>;
         /**
          * Converts an image typed array buffer to a base64 image
          * @param buffer typed array buffer
@@ -1034,7 +1034,7 @@ declare module BABYLON {
          * @param mimeType mime type to use for the textures
          * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
          */
-        _convertPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<IMaterial>;
+        _convertPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<BABYLON.GLTF2.IMaterial>;
         private _setMetallicRoughnessPbrMaterial;
         private _getPixelsFromTexture;
         /**
@@ -1043,8 +1043,8 @@ declare module BABYLON {
          * @param mimeType Mime Type of the babylonTexture
          * @return glTF texture info, or null if the texture format is not supported
          */
-        _exportTextureAsync(babylonTexture: BaseTexture, mimeType: ImageMimeType): Promise<Nullable<ITextureInfo>>;
-        _exportTextureInfoAsync(babylonTexture: BaseTexture, mimeType: ImageMimeType): Promise<Nullable<ITextureInfo>>;
+        _exportTextureAsync(babylonTexture: BaseTexture, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Nullable<BABYLON.GLTF2.ITextureInfo>>;
+        _exportTextureInfoAsync(babylonTexture: BaseTexture, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Nullable<BABYLON.GLTF2.ITextureInfo>>;
         /**
          * Builds a texture from base64 string
          * @param base64Texture base64 texture string
@@ -1130,7 +1130,7 @@ declare module BABYLON {
          * @param name name of the buffer view
          * @returns bufferView for glTF
          */
-        static _CreateBufferView(bufferIndex: number, byteOffset: number, byteLength: number, byteStride?: number, name?: string): IBufferView;
+        static _CreateBufferView(bufferIndex: number, byteOffset: number, byteLength: number, byteStride?: number, name?: string): BABYLON.GLTF2.IBufferView;
         /**
          * Creates an accessor based on the supplied arguments
          * @param bufferviewIndex The index of the bufferview referenced by this accessor
@@ -1143,7 +1143,7 @@ declare module BABYLON {
          * @param max Maximum value of each component in this attribute
          * @returns accessor for glTF
          */
-        static _CreateAccessor(bufferviewIndex: number, name: string, type: AccessorType, componentType: AccessorComponentType, count: number, byteOffset: Nullable<number>, min: Nullable<number[]>, max: Nullable<number[]>): IAccessor;
+        static _CreateAccessor(bufferviewIndex: number, name: string, type: BABYLON.GLTF2.AccessorType, componentType: BABYLON.GLTF2.AccessorComponentType, count: number, byteOffset: Nullable<number>, min: Nullable<number[]>, max: Nullable<number[]>): BABYLON.GLTF2.IAccessor;
         /**
          * Calculates the minimum and maximum values of an array of position floats
          * @param positions Positions array of a mesh
@@ -1157,32 +1157,32 @@ declare module BABYLON {
             max: number[];
         };
         /**
-         * Converts a new right-handed BABYLON.Vector3
+         * Converts a new right-handed Vector3
          * @param vector vector3 array
-         * @returns right-handed BABYLON.Vector3
+         * @returns right-handed Vector3
          */
-        static _GetRightHandedPositionVector3(vector: BABYLON.Vector3): BABYLON.Vector3;
+        static _GetRightHandedPositionVector3(vector: Vector3): Vector3;
         /**
-         * Converts a BABYLON.Vector3 to right-handed
-         * @param vector BABYLON.Vector3 to convert to right-handed
+         * Converts a Vector3 to right-handed
+         * @param vector Vector3 to convert to right-handed
          */
-        static _GetRightHandedPositionVector3FromRef(vector: BABYLON.Vector3): void;
+        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 BABYLON.Vector3
+         * Converts a new right-handed Vector3
          * @param vector vector3 array
-         * @returns right-handed BABYLON.Vector3
+         * @returns right-handed Vector3
          */
-        static _GetRightHandedNormalVector3(vector: BABYLON.Vector3): BABYLON.Vector3;
+        static _GetRightHandedNormalVector3(vector: Vector3): Vector3;
         /**
-         * Converts a BABYLON.Vector3 to right-handed
-         * @param vector BABYLON.Vector3 to convert to right-handed
+         * Converts a Vector3 to right-handed
+         * @param vector Vector3 to convert to right-handed
          */
-        static _GetRightHandedNormalVector3FromRef(vector: BABYLON.Vector3): void;
+        static _GetRightHandedNormalVector3FromRef(vector: Vector3): void;
         /**
          * Converts a three element number array to right-handed
          * @param vector number array to convert to right-handed
@@ -1209,7 +1209,7 @@ declare module BABYLON {
          */
         static _GetRightHandedQuaternionArrayFromRef(quaternion: number[]): void;
         static _NormalizeTangentFromRef(tangent: Vector4): void;
-        static _GetDataAccessorElementCount(accessorType: AccessorType): 1 | 3 | 2 | 4 | 9 | 16;
+        static _GetDataAccessorElementCount(accessorType: BABYLON.GLTF2.AccessorType): 1 | 3 | 2 | 4 | 9 | 16;
     }

package/babylonjs.serializers.module.d.ts CHANGED Viewed

@@ -1468,11 +1468,11 @@ declare module BABYLON {
          * @param node glTF node
          * @param babylonNode BabylonJS node
          * @param nodeMap Node mapping of unique id to glTF node index
-         * @returns nullable INode promise
+         * @returns nullable BABYLON.GLTF2.INode promise
          */
-        postExportNodeAsync(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
             [key: number]: number;
-        }): Promise<Nullable<INode>>;
+        }): Promise<Nullable<BABYLON.GLTF2.INode>>;
     }
@@ -1492,8 +1492,8 @@ declare module BABYLON {
         dispose(): void;
         /** @hidden */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
-        postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
@@ -1513,8 +1513,8 @@ declare module BABYLON {
         dispose(): void;
         /** @hidden */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
-        postExportMaterialAsync(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAdditionalTextures(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAsync(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
@@ -1533,7 +1533,7 @@ declare module BABYLON {
         /** @hidden */
         get wasUsed(): boolean;
         dispose(): void;
-        postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
@@ -1554,7 +1554,7 @@ declare module BABYLON {
         dispose(): void;
         /** @hidden */
         get wasUsed(): boolean;
-        postExportTexture?(context: string, textureInfo: ITextureInfo, babylonTexture: Texture): void;
+        postExportTexture?(context: string, textureInfo: BABYLON.GLTF2.ITextureInfo, babylonTexture: Texture): void;
         preExportTextureAsync(context: string, babylonTexture: Texture): Promise<Texture>;
         /**
          * Transform the babylon texture by the offset, rotation and scale parameters using a procedural texture
@@ -1579,9 +1579,9 @@ declare module BABYLON {
          */
         outputs: number[][];
         /**
-         * BABYLON.Animation interpolation data.
+         * Animation interpolation data.
          */
-        samplerInterpolation: AnimationSamplerInterpolation;
+        samplerInterpolation: BABYLON.GLTF2.AnimationSamplerInterpolation;
         /**
          * Minimum keyframe value.
          */
@@ -1598,11 +1598,11 @@ declare module BABYLON {
         /**
          * The target channel for the animation
          */
-        animationChannelTargetPath: AnimationChannelTargetPath;
+        animationChannelTargetPath: BABYLON.GLTF2.AnimationChannelTargetPath;
         /**
          * The glTF accessor type for the data.
          */
-        dataAccessorType: AccessorType.VEC3 | AccessorType.VEC4 | AccessorType.SCALAR;
+        dataAccessorType: BABYLON.GLTF2.AccessorType.VEC3 | BABYLON.GLTF2.AccessorType.VEC4 | BABYLON.GLTF2.AccessorType.SCALAR;
         /**
          * Specifies if quaternions should be used.
          */
@@ -1624,7 +1624,7 @@ declare module BABYLON {
          * @param useQuaternion - Specifies if quaternions are used.
          * @returns nullable IAnimationData
          */
-        static _CreateNodeAnimation(babylonTransformNode: BABYLON.TransformNode, animation: BABYLON.Animation, animationChannelTargetPath: AnimationChannelTargetPath, convertToRightHandedSystem: boolean, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
+        static _CreateNodeAnimation(babylonTransformNode: TransformNode, animation: Animation, animationChannelTargetPath: BABYLON.GLTF2.AnimationChannelTargetPath, convertToRightHandedSystem: boolean, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
         private static _DeduceAnimationInfo;
         /**
          * @ignore
@@ -1640,9 +1640,9 @@ declare module BABYLON {
          * @param convertToRightHandedSystem
          * @param animationSampleRate
          */
-        static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: {
+        static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: BABYLON.GLTF2.IAnimation, idleGLTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
         /**
          * @ignore
          * Create individual morph animations from the mesh's morph target animation tracks
@@ -1657,9 +1657,9 @@ declare module BABYLON {
          * @param convertToRightHandedSystem
          * @param animationSampleRate
          */
-        static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: {
+        static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: BABYLON.GLTF2.IAnimation, idleGLTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystem: boolean, animationSampleRate: number): void;
         /**
          * @ignore
          * Create node and morph animations from the animation groups
@@ -1673,9 +1673,9 @@ declare module BABYLON {
          * @param convertToRightHandedSystemMap
          * @param animationSampleRate
          */
-        static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: IAnimation[], nodeMap: {
+        static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: BABYLON.GLTF2.IAnimation[], nodeMap: {
             [key: number]: number;
-        }, nodes: INode[], binaryWriter: _BinaryWriter, bufferViews: IBufferView[], accessors: IAccessor[], convertToRightHandedSystemMap: {
+        }, nodes: BABYLON.GLTF2.INode[], binaryWriter: _BinaryWriter, bufferViews: BABYLON.GLTF2.IBufferView[], accessors: BABYLON.GLTF2.IAccessor[], convertToRightHandedSystemMap: {
             [nodeId: number]: boolean;
         }, animationSampleRate: number): void;
         private static _AddAnimation;
@@ -1794,19 +1794,19 @@ declare module BABYLON {
         /**
          * Stores the glTF to export
          */
-        _glTF: IGLTF;
+        _glTF: BABYLON.GLTF2.IGLTF;
         /**
          * Stores all generated buffer views, which represents views into the main glTF buffer data
          */
-        _bufferViews: IBufferView[];
+        _bufferViews: BABYLON.GLTF2.IBufferView[];
         /**
          * Stores all the generated accessors, which is used for accessing the data within the buffer views in glTF
          */
-        _accessors: IAccessor[];
+        _accessors: BABYLON.GLTF2.IAccessor[];
         /**
          * Stores all the generated nodes, which contains transform and/or mesh information per node
          */
-        _nodes: INode[];
+        _nodes: BABYLON.GLTF2.INode[];
         /**
          * Stores all the generated glTF scenes, which stores multiple node hierarchies
          */
@@ -1822,26 +1822,26 @@ declare module BABYLON {
         /**
          * Stores all the generated material information, which represents the appearance of each primitive
          */
-        _materials: IMaterial[];
+        _materials: BABYLON.GLTF2.IMaterial[];
         _materialMap: {
             [materialID: number]: number;
         };
         /**
          * Stores all the generated texture information, which is referenced by glTF materials
          */
-        _textures: ITexture[];
+        _textures: BABYLON.GLTF2.ITexture[];
         /**
          * Stores all the generated image information, which is referenced by glTF textures
          */
-        _images: IImage[];
+        _images: BABYLON.GLTF2.IImage[];
         /**
          * Stores all the texture samplers
          */
-        _samplers: ISampler[];
+        _samplers: BABYLON.GLTF2.ISampler[];
         /**
          * Stores all the generated glTF skins
          */
-        _skins: ISkin[];
+        _skins: BABYLON.GLTF2.ISkin[];
         /**
          * Stores all the generated animation samplers, which is referenced by glTF animations
          */
@@ -1864,12 +1864,12 @@ declare module BABYLON {
         _imageData: {
             [fileName: string]: {
                 data: Uint8Array;
-                mimeType: ImageMimeType;
+                mimeType: BABYLON.GLTF2.ImageMimeType;
             };
         };
         protected _orderedImageData: Array<{
             data: Uint8Array;
-            mimeType: ImageMimeType;
+            mimeType: BABYLON.GLTF2.ImageMimeType;
         }>;
         /**
          * Stores a map of the unique id of a node to its index in the node array
@@ -1900,14 +1900,14 @@ declare module BABYLON {
         private static _ExtensionFactories;
         private _applyExtension;
         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?: {
+        _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?: {
             [key: number]: number;
-        }): Promise<Nullable<INode>>;
-        _extensionsPostExportMaterialAsync(context: string, material: Nullable<IMaterial>, babylonMaterial: BABYLON.Material): Promise<Nullable<IMaterial>>;
-        _extensionsPostExportMaterialAdditionalTextures(context: string, material: IMaterial, babylonMaterial: BABYLON.Material): BaseTexture[];
-        _extensionsPostExportTextures(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
+        }): 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;
         private _forEachExtensions;
         private _extensionsOnExporting;
         /**
@@ -2007,7 +2007,7 @@ declare module BABYLON {
          * @param convertToRightHandedSystem Converts the values to right-handed
          * @param babylonTransformNode
          */
-        _writeAttributeData(vertexBufferKind: string, attributeComponentKind: AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, babylonTransformNode: BABYLON.TransformNode): void;
+        _writeAttributeData(vertexBufferKind: string, attributeComponentKind: BABYLON.GLTF2.AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, babylonTransformNode: TransformNode): void;
         /**
          * Writes mesh attribute data to a data buffer
          * Returns the bytelength of the data
@@ -2022,7 +2022,7 @@ declare module BABYLON {
          * @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: BABYLON.GLTF2.AccessorComponentType, meshPrimitive: SubMesh, morphTarget: MorphTarget, meshAttributeArray: FloatArray, morphTargetAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, convertToRightHandedSystem: boolean, minMax?: any): void;
         /**
          * Generates glTF json data
          * @param shouldUseGlb Indicates whether the json should be written for a glb file
@@ -2209,10 +2209,10 @@ declare module BABYLON {
          * @param byteOffset If defined, specifies where to set the value as an offset.
          */
         getUInt32(byteOffset: number): number;
-        getVector3Float32FromRef(vector3: BABYLON.Vector3, byteOffset: number): void;
-        setVector3Float32FromRef(vector3: BABYLON.Vector3, byteOffset: number): void;
-        getVector4Float32FromRef(vector4: BABYLON.Vector4, byteOffset: number): void;
-        setVector4Float32FromRef(vector4: BABYLON.Vector4, byteOffset: number): void;
+        getVector3Float32FromRef(vector3: Vector3, byteOffset: number): void;
+        setVector3Float32FromRef(vector3: Vector3, byteOffset: number): void;
+        getVector4Float32FromRef(vector4: Vector4, byteOffset: number): void;
+        setVector4Float32FromRef(vector4: Vector4, byteOffset: number): void;
         /**
          * Stores a Float32 in the array buffer
          * @param entry
@@ -2242,47 +2242,47 @@ declare module BABYLON {
          * @param mimeType The mime-type of the generated image
          * @returns A promise that resolves with the exported texture
          */
-        preExportTextureAsync?(context: string, babylonTexture: Nullable<Texture>, mimeType: ImageMimeType): Promise<Texture>;
+        preExportTextureAsync?(context: string, babylonTexture: Nullable<Texture>, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Texture>;
         /**
          * Define this method to get notified when a texture info is created
          * @param context The context when loading the asset
          * @param textureInfo The glTF texture info
          * @param babylonTexture The Babylon.js texture
          */
-        postExportTexture?(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
+        postExportTexture?(context: string, textureInfo: BABYLON.GLTF2.ITextureInfo, babylonTexture: BaseTexture): void;
         /**
          * Define this method to modify the default behavior when exporting texture info
          * @param context The context when loading the asset
          * @param meshPrimitive glTF mesh primitive
          * @param babylonSubMesh Babylon submesh
          * @param binaryWriter glTF serializer binary writer instance
-         * @returns nullable IMeshPrimitive promise
+         * @returns nullable BABYLON.GLTF2.IMeshPrimitive promise
          */
-        postExportMeshPrimitiveAsync?(context: string, meshPrimitive: Nullable<IMeshPrimitive>, babylonSubMesh: SubMesh, binaryWriter: _BinaryWriter): Promise<IMeshPrimitive>;
+        postExportMeshPrimitiveAsync?(context: string, meshPrimitive: Nullable<BABYLON.GLTF2.IMeshPrimitive>, babylonSubMesh: SubMesh, binaryWriter: _BinaryWriter): Promise<BABYLON.GLTF2.IMeshPrimitive>;
         /**
          * Define this method to modify the default behavior when exporting a node
          * @param context The context when exporting the node
          * @param node glTF node
          * @param babylonNode BabylonJS node
-         * @returns nullable INode promise
+         * @returns nullable BABYLON.GLTF2.INode promise
          */
-        postExportNodeAsync?(context: string, node: Nullable<INode>, babylonNode: Node, nodeMap?: {
+        postExportNodeAsync?(context: string, node: Nullable<BABYLON.GLTF2.INode>, babylonNode: Node, nodeMap?: {
             [key: number]: number;
-        }): Promise<Nullable<INode>>;
+        }): Promise<Nullable<BABYLON.GLTF2.INode>>;
         /**
          * Define this method to modify the default behavior when exporting a material
          * @param material glTF material
          * @param babylonMaterial BabylonJS material
-         * @returns nullable IMaterial promise
+         * @returns nullable BABYLON.GLTF2.IMaterial promise
          */
-        postExportMaterialAsync?(context: string, node: Nullable<IMaterial>, babylonMaterial: Material): Promise<IMaterial>;
+        postExportMaterialAsync?(context: string, node: Nullable<BABYLON.GLTF2.IMaterial>, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
         /**
          * Define this method to return additional textures to export from a material
          * @param material glTF material
          * @param babylonMaterial BabylonJS material
          * @returns List of textures
          */
-        postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
         /** Gets a boolean indicating that this extension was used */
         wasUsed: boolean;
         /** Gets a boolean indicating that this extension is required for the file to work */
@@ -2333,26 +2333,26 @@ declare module BABYLON {
          * @param mimeType texture mime type
          * @param hasTextureCoords specifies if texture coordinates are present on the material
          */
-        _convertMaterialsToGLTFAsync(exportMaterials: Set<Material>, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<void>;
+        _convertMaterialsToGLTFAsync(exportMaterials: Set<Material>, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<void>;
         /**
          * Makes a copy of the glTF material without the texture parameters
          * @param originalMaterial original glTF material
          * @returns glTF material without texture parameters
          */
-        _stripTexturesFromMaterial(originalMaterial: IMaterial): IMaterial;
+        _stripTexturesFromMaterial(originalMaterial: BABYLON.GLTF2.IMaterial): BABYLON.GLTF2.IMaterial;
         /**
          * Specifies if the material has any texture parameters present
          * @param material glTF Material
          * @returns boolean specifying if texture parameters are present
          */
-        _hasTexturesPresent(material: IMaterial): boolean;
-        _getTextureInfo(babylonTexture: Nullable<BaseTexture>): Nullable<ITextureInfo>;
+        _hasTexturesPresent(material: BABYLON.GLTF2.IMaterial): boolean;
+        _getTextureInfo(babylonTexture: Nullable<BaseTexture>): Nullable<BABYLON.GLTF2.ITextureInfo>;
         /**
          * Converts a Babylon StandardMaterial to a glTF Metallic Roughness Material
          * @param babylonStandardMaterial
          * @returns glTF Metallic Roughness Material representation
          */
-        _convertToGLTFPBRMetallicRoughness(babylonStandardMaterial: StandardMaterial): IMaterialPbrMetallicRoughness;
+        _convertToGLTFPBRMetallicRoughness(babylonStandardMaterial: StandardMaterial): BABYLON.GLTF2.IMaterialPbrMetallicRoughness;
         /**
          * Computes the metallic factor
          * @param diffuse diffused value
@@ -2373,7 +2373,7 @@ declare module BABYLON {
          * @param mimeType mime type to use for the textures
          * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
          */
-        _convertStandardMaterialAsync(babylonStandardMaterial: StandardMaterial, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<IMaterial>;
+        _convertStandardMaterialAsync(babylonStandardMaterial: StandardMaterial, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<BABYLON.GLTF2.IMaterial>;
         private _finishMaterial;
         /**
          * Converts a Babylon PBR Metallic Roughness Material to a glTF Material
@@ -2381,7 +2381,7 @@ declare module BABYLON {
          * @param mimeType mime type to use for the textures
          * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
          */
-        _convertPBRMetallicRoughnessMaterialAsync(babylonPBRMetalRoughMaterial: PBRMetallicRoughnessMaterial, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<IMaterial>;
+        _convertPBRMetallicRoughnessMaterialAsync(babylonPBRMetalRoughMaterial: PBRMetallicRoughnessMaterial, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<BABYLON.GLTF2.IMaterial>;
         /**
          * Converts an image typed array buffer to a base64 image
          * @param buffer typed array buffer
@@ -2470,7 +2470,7 @@ declare module BABYLON {
          * @param mimeType mime type to use for the textures
          * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
          */
-        _convertPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, mimeType: ImageMimeType, hasTextureCoords: boolean): Promise<IMaterial>;
+        _convertPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, mimeType: BABYLON.GLTF2.ImageMimeType, hasTextureCoords: boolean): Promise<BABYLON.GLTF2.IMaterial>;
         private _setMetallicRoughnessPbrMaterial;
         private _getPixelsFromTexture;
         /**
@@ -2479,8 +2479,8 @@ declare module BABYLON {
          * @param mimeType Mime Type of the babylonTexture
          * @return glTF texture info, or null if the texture format is not supported
          */
-        _exportTextureAsync(babylonTexture: BaseTexture, mimeType: ImageMimeType): Promise<Nullable<ITextureInfo>>;
-        _exportTextureInfoAsync(babylonTexture: BaseTexture, mimeType: ImageMimeType): Promise<Nullable<ITextureInfo>>;
+        _exportTextureAsync(babylonTexture: BaseTexture, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Nullable<BABYLON.GLTF2.ITextureInfo>>;
+        _exportTextureInfoAsync(babylonTexture: BaseTexture, mimeType: BABYLON.GLTF2.ImageMimeType): Promise<Nullable<BABYLON.GLTF2.ITextureInfo>>;
         /**
          * Builds a texture from base64 string
          * @param base64Texture base64 texture string
@@ -2566,7 +2566,7 @@ declare module BABYLON {
          * @param name name of the buffer view
          * @returns bufferView for glTF
          */
-        static _CreateBufferView(bufferIndex: number, byteOffset: number, byteLength: number, byteStride?: number, name?: string): IBufferView;
+        static _CreateBufferView(bufferIndex: number, byteOffset: number, byteLength: number, byteStride?: number, name?: string): BABYLON.GLTF2.IBufferView;
         /**
          * Creates an accessor based on the supplied arguments
          * @param bufferviewIndex The index of the bufferview referenced by this accessor
@@ -2579,7 +2579,7 @@ declare module BABYLON {
          * @param max Maximum value of each component in this attribute
          * @returns accessor for glTF
          */
-        static _CreateAccessor(bufferviewIndex: number, name: string, type: AccessorType, componentType: AccessorComponentType, count: number, byteOffset: Nullable<number>, min: Nullable<number[]>, max: Nullable<number[]>): IAccessor;
+        static _CreateAccessor(bufferviewIndex: number, name: string, type: BABYLON.GLTF2.AccessorType, componentType: BABYLON.GLTF2.AccessorComponentType, count: number, byteOffset: Nullable<number>, min: Nullable<number[]>, max: Nullable<number[]>): BABYLON.GLTF2.IAccessor;
         /**
          * Calculates the minimum and maximum values of an array of position floats
          * @param positions Positions array of a mesh
@@ -2593,32 +2593,32 @@ declare module BABYLON {
             max: number[];
         };
         /**
-         * Converts a new right-handed BABYLON.Vector3
+         * Converts a new right-handed Vector3
          * @param vector vector3 array
-         * @returns right-handed BABYLON.Vector3
+         * @returns right-handed Vector3
          */
-        static _GetRightHandedPositionVector3(vector: BABYLON.Vector3): BABYLON.Vector3;
+        static _GetRightHandedPositionVector3(vector: Vector3): Vector3;
         /**
-         * Converts a BABYLON.Vector3 to right-handed
-         * @param vector BABYLON.Vector3 to convert to right-handed
+         * Converts a Vector3 to right-handed
+         * @param vector Vector3 to convert to right-handed
          */
-        static _GetRightHandedPositionVector3FromRef(vector: BABYLON.Vector3): void;
+        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 BABYLON.Vector3
+         * Converts a new right-handed Vector3
          * @param vector vector3 array
-         * @returns right-handed BABYLON.Vector3
+         * @returns right-handed Vector3
          */
-        static _GetRightHandedNormalVector3(vector: BABYLON.Vector3): BABYLON.Vector3;
+        static _GetRightHandedNormalVector3(vector: Vector3): Vector3;
         /**
-         * Converts a BABYLON.Vector3 to right-handed
-         * @param vector BABYLON.Vector3 to convert to right-handed
+         * Converts a Vector3 to right-handed
+         * @param vector Vector3 to convert to right-handed
          */
-        static _GetRightHandedNormalVector3FromRef(vector: BABYLON.Vector3): void;
+        static _GetRightHandedNormalVector3FromRef(vector: Vector3): void;
         /**
          * Converts a three element number array to right-handed
          * @param vector number array to convert to right-handed
@@ -2645,7 +2645,7 @@ declare module BABYLON {
          */
         static _GetRightHandedQuaternionArrayFromRef(quaternion: number[]): void;
         static _NormalizeTangentFromRef(tangent: Vector4): void;
-        static _GetDataAccessorElementCount(accessorType: AccessorType): 1 | 3 | 2 | 4 | 9 | 16;
+        static _GetDataAccessorElementCount(accessorType: BABYLON.GLTF2.AccessorType): 1 | 3 | 2 | 4 | 9 | 16;
     }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-serializers",
-    "version": "5.0.0",
+    "version": "5.0.1",
     "main": "babylonjs.serializers.js",
     "types": "babylonjs.serializers.module.d.ts",
     "files": [
@@ -14,8 +14,8 @@
         "clean": "rimraf dist && rimraf babylon*.*"
     },
     "dependencies": {
-        "babylonjs": "^5.0.0",
-        "babylonjs-gltf2interface": "^5.0.0"
+        "babylonjs": "^5.0.1",
+        "babylonjs-gltf2interface": "^5.0.1"
     },
     "devDependencies": {
         "@dev/build-tools": "1.0.0",