@babylonjs/serializers 7.37.1 → 7.37.2

package/glTF/2.0/glTFData.js

@@ -1,50 +1,49 @@
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+function GetMimeType(fileName) {
+    if (fileName.endsWith(".glb")) {
+        return "model/gltf-binary";
+    }
+    else if (fileName.endsWith(".bin")) {
+        return "application/octet-stream";
+    }
+    else if (fileName.endsWith(".gltf")) {
+        return "model/gltf+json";
+    }
+    else if (fileName.endsWith(".jpeg") || fileName.endsWith(".jpg")) {
+        return "image/jpeg" /* ImageMimeType.JPEG */;
+    }
+    else if (fileName.endsWith(".png")) {
+        return "image/png" /* ImageMimeType.PNG */;
+    }
+    else if (fileName.endsWith(".webp")) {
+        return "image/webp" /* ImageMimeType.WEBP */;
+    }
+    return undefined;
+}
 /**
  * Class for holding and downloading glTF file data
  */
 export class GLTFData {
+    constructor() {
+        /**
+         * Object which contains the file name as the key and its data as the value
+         */
+        this.files = {};
+    }
     /**
-     * Initializes the glTF file object
+     * @deprecated Use files instead
      */
-    constructor() {
-        this.glTFFiles = {};
+    get glTFFiles() {
+        return this.files;
     }
     /**
      * Downloads the glTF data as files based on their names and data
      */
     downloadFiles() {
-        /**
-         * Checks for a matching suffix at the end of a string (for ES5 and lower)
-         * @param str Source string
-         * @param suffix Suffix to search for in the source string
-         * @returns Boolean indicating whether the suffix was found (true) or not (false)
-         */
-        function endsWith(str, suffix) {
-            return str.indexOf(suffix, str.length - suffix.length) !== -1;
-        }
-        for (const key in this.glTFFiles) {
-            const link = document.createElement("a");
-            document.body.appendChild(link);
-            link.setAttribute("type", "hidden");
-            link.download = key;
-            const blob = this.glTFFiles[key];
-            let mimeType;
-            if (endsWith(key, ".glb")) {
-                mimeType = { type: "model/gltf-binary" };
-            }
-            else if (endsWith(key, ".bin")) {
-                mimeType = { type: "application/octet-stream" };
-            }
-            else if (endsWith(key, ".gltf")) {
-                mimeType = { type: "model/gltf+json" };
-            }
-            else if (endsWith(key, ".jpeg") || endsWith(key, ".jpg")) {
-                mimeType = { type: "image/jpeg" /* ImageMimeType.JPEG */ };
-            }
-            else if (endsWith(key, ".png")) {
-                mimeType = { type: "image/png" /* ImageMimeType.PNG */ };
-            }
-            link.href = window.URL.createObjectURL(new Blob([blob], mimeType));
-            link.click();
+        for (const key in this.files) {
+            const value = this.files[key];
+            const blob = new Blob([value], { type: GetMimeType(key) });
+            Tools.Download(blob, key);
         }
     }
 }

package/glTF/2.0/glTFData.js.map

@@ -1 +1 @@
-{"version":3,"file":"glTFData.js","sourceRoot":"","sources":["../../../../../dev/serializers/src/glTF/2.0/glTFData.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,OAAO,QAAQ;IAMjB;;OAEG;IACH;QACI,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,aAAa;QAChB;;;;;WAKG;QACH,SAAS,QAAQ,CAAC,GAAW,EAAE,MAAc;YACzC,OAAO,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAClE,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACzC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAChC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACpC,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;YACpB,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACjC,IAAI,QAAQ,CAAC;YAEb,IAAI,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC;gBACxB,QAAQ,GAAG,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;YAC7C,CAAC;iBAAM,IAAI,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC;gBAC/B,QAAQ,GAAG,EAAE,IAAI,EAAE,0BAA0B,EAAE,CAAC;YACpD,CAAC;iBAAM,IAAI,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,CAAC;gBAChC,QAAQ,GAAG,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;YAC3C,CAAC;iBAAM,IAAI,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC;gBACzD,QAAQ,GAAG,EAAE,IAAI,uCAAoB,EAAE,CAAC;YAC5C,CAAC;iBAAM,IAAI,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC;gBAC/B,QAAQ,GAAG,EAAE,IAAI,qCAAmB,EAAE,CAAC;YAC3C,CAAC;YAED,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;YACnE,IAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC;IACL,CAAC;CACJ","sourcesContent":["import { ImageMimeType } from \"babylonjs-gltf2interface\";\r\n\r\n/**\r\n * Class for holding and downloading glTF file data\r\n */\r\nexport class GLTFData {\r\n    /**\r\n     * Object which contains the file name as the key and its data as the value\r\n     */\r\n    glTFFiles: { [fileName: string]: string | Blob };\r\n\r\n    /**\r\n     * Initializes the glTF file object\r\n     */\r\n    public constructor() {\r\n        this.glTFFiles = {};\r\n    }\r\n\r\n    /**\r\n     * Downloads the glTF data as files based on their names and data\r\n     */\r\n    public downloadFiles(): void {\r\n        /**\r\n         * Checks for a matching suffix at the end of a string (for ES5 and lower)\r\n         * @param str Source string\r\n         * @param suffix Suffix to search for in the source string\r\n         * @returns Boolean indicating whether the suffix was found (true) or not (false)\r\n         */\r\n        function endsWith(str: string, suffix: string): boolean {\r\n            return str.indexOf(suffix, str.length - suffix.length) !== -1;\r\n        }\r\n\r\n        for (const key in this.glTFFiles) {\r\n            const link = document.createElement(\"a\");\r\n            document.body.appendChild(link);\r\n            link.setAttribute(\"type\", \"hidden\");\r\n            link.download = key;\r\n            const blob = this.glTFFiles[key];\r\n            let mimeType;\r\n\r\n            if (endsWith(key, \".glb\")) {\r\n                mimeType = { type: \"model/gltf-binary\" };\r\n            } else if (endsWith(key, \".bin\")) {\r\n                mimeType = { type: \"application/octet-stream\" };\r\n            } else if (endsWith(key, \".gltf\")) {\r\n                mimeType = { type: \"model/gltf+json\" };\r\n            } else if (endsWith(key, \".jpeg\") || endsWith(key, \".jpg\")) {\r\n                mimeType = { type: ImageMimeType.JPEG };\r\n            } else if (endsWith(key, \".png\")) {\r\n                mimeType = { type: ImageMimeType.PNG };\r\n            }\r\n\r\n            link.href = window.URL.createObjectURL(new Blob([blob], mimeType));\r\n            link.click();\r\n        }\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"glTFData.js","sourceRoot":"","sources":["../../../../../dev/serializers/src/glTF/2.0/glTFData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,sCAAwB;AAExC,SAAS,WAAW,CAAC,QAAgB;IACjC,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,OAAO,mBAAmB,CAAC;IAC/B,CAAC;SAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,OAAO,0BAA0B,CAAC;IACtC,CAAC;SAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,OAAO,iBAAiB,CAAC;IAC7B,CAAC;SAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACjE,6CAA0B;IAC9B,CAAC;SAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,2CAAyB;IAC7B,CAAC;SAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,6CAA0B;IAC9B,CAAC;IAED,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,QAAQ;IAArB;QACI;;WAEG;QACa,UAAK,GAA0C,EAAE,CAAC;IAmBtE,CAAC;IAjBG;;OAEG;IACH,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,aAAa;QAChB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC9B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC3D,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC9B,CAAC;IACL,CAAC;CACJ","sourcesContent":["import { ImageMimeType } from \"babylonjs-gltf2interface\";\r\nimport { Tools } from \"core/Misc/tools\";\r\n\r\nfunction GetMimeType(fileName: string): string | undefined {\r\n    if (fileName.endsWith(\".glb\")) {\r\n        return \"model/gltf-binary\";\r\n    } else if (fileName.endsWith(\".bin\")) {\r\n        return \"application/octet-stream\";\r\n    } else if (fileName.endsWith(\".gltf\")) {\r\n        return \"model/gltf+json\";\r\n    } else if (fileName.endsWith(\".jpeg\") || fileName.endsWith(\".jpg\")) {\r\n        return ImageMimeType.JPEG;\r\n    } else if (fileName.endsWith(\".png\")) {\r\n        return ImageMimeType.PNG;\r\n    } else if (fileName.endsWith(\".webp\")) {\r\n        return ImageMimeType.WEBP;\r\n    }\r\n\r\n    return undefined;\r\n}\r\n\r\n/**\r\n * Class for holding and downloading glTF file data\r\n */\r\nexport class GLTFData {\r\n    /**\r\n     * Object which contains the file name as the key and its data as the value\r\n     */\r\n    public readonly files: { [fileName: string]: string | Blob } = {};\r\n\r\n    /**\r\n     * @deprecated Use files instead\r\n     */\r\n    public get glTFFiles() {\r\n        return this.files;\r\n    }\r\n\r\n    /**\r\n     * Downloads the glTF data as files based on their names and data\r\n     */\r\n    public downloadFiles(): void {\r\n        for (const key in this.files) {\r\n            const value = this.files[key];\r\n            const blob = new Blob([value], { type: GetMimeType(key) });\r\n            Tools.Download(blob, key);\r\n        }\r\n    }\r\n}\r\n"]}

package/glTF/2.0/glTFExporter.d.ts

@@ -1,231 +1,75 @@
-import type { IBufferView, IAccessor, INode, IMaterial, ITexture, IImage, ISampler, IMeshPrimitive, IGLTF, ITextureInfo, ISkin } from "babylonjs-gltf2interface";
-import { ImageMimeType, AccessorComponentType } from "babylonjs-gltf2interface";
-import type { FloatArray, Nullable } from "@babylonjs/core/types.js";
-import { Vector3, Vector4 } from "@babylonjs/core/Maths/math.vector.js";
+import type { IBufferView, IAccessor, INode, IScene, IMesh, IMaterial, ITexture, IImage, ISampler, IAnimation, IMeshPrimitive, IGLTF, ITextureInfo, ISkin, ICamera } from "babylonjs-gltf2interface";
+import { ImageMimeType } from "babylonjs-gltf2interface";
+import type { Nullable } from "@babylonjs/core/types.js";
 import type { Node } from "@babylonjs/core/node.js";
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
 import type { SubMesh } from "@babylonjs/core/Meshes/subMesh.js";
 import type { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
 import type { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
 import { Material } from "@babylonjs/core/Materials/material.js";
 import type { Scene } from "@babylonjs/core/scene.js";
 import type { IGLTFExporterExtensionV2 } from "./glTFExporterExtension";
-import { _GLTFMaterialExporter } from "./glTFMaterialExporter";
+import { GLTFMaterialExporter } from "./glTFMaterialExporter";
 import type { IExportOptions } from "./glTFSerializer";
 import { GLTFData } from "./glTFData";
-/**
- * Converts Babylon Scene into glTF 2.0.
- * @internal
- */
-export declare class _Exporter {
-    /**
-     * Stores the glTF to export
-     */
-    _glTF: IGLTF;
-    /**
-     * Stores all generated buffer views, which represents views into the main glTF buffer data
-     */
-    _bufferViews: IBufferView[];
-    /**
-     * Stores all the generated accessors, which is used for accessing the data within the buffer views in glTF
-     */
-    _accessors: IAccessor[];
-    /**
-     * Stores all the generated nodes, which contains transform and/or mesh information per node
-     */
-    _nodes: INode[];
-    /**
-     * Stores all the generated glTF scenes, which stores multiple node hierarchies
-     */
-    private _scenes;
-    /**
-     * Stores all the generated glTF cameras
-     */
-    private _cameras;
-    /**
-     * Stores all the generated mesh information, each containing a set of primitives to render in glTF
-     */
-    private _meshes;
-    /**
-     * Stores all the generated material information, which represents the appearance of each primitive
-     */
-    _materials: IMaterial[];
-    _materialMap: {
-        [materialID: number]: number;
-    };
-    /**
-     * Stores all the generated texture information, which is referenced by glTF materials
-     */
-    _textures: ITexture[];
-    /**
-     * Stores all the generated image information, which is referenced by glTF textures
-     */
-    _images: IImage[];
-    /**
-     * Stores all the texture samplers
-     */
-    _samplers: ISampler[];
-    /**
-     * Stores all the generated glTF skins
-     */
-    _skins: ISkin[];
-    /**
-     * Stores all the generated animation samplers, which is referenced by glTF animations
-     */
-    /**
-     * Stores the animations for glTF models
-     */
-    private _animations;
-    /**
-     * Stores the total amount of bytes stored in the glTF buffer
-     */
-    private _totalByteLength;
-    /**
-     * Stores a reference to the Babylon scene containing the source geometry and material information
-     */
-    _babylonScene: Scene;
-    /**
-     * Stores a map of the image data, where the key is the file name and the value
-     * is the image data
-     */
-    _imageData: {
+/** @internal */
+export declare class GLTFExporter {
+    readonly _glTF: IGLTF;
+    readonly _animations: IAnimation[];
+    readonly _accessors: IAccessor[];
+    readonly _bufferViews: IBufferView[];
+    readonly _cameras: ICamera[];
+    readonly _images: IImage[];
+    readonly _materials: IMaterial[];
+    readonly _meshes: IMesh[];
+    readonly _nodes: INode[];
+    readonly _samplers: ISampler[];
+    readonly _scenes: IScene[];
+    readonly _skins: ISkin[];
+    readonly _textures: ITexture[];
+    readonly _babylonScene: Scene;
+    readonly _imageData: {
         [fileName: string]: {
             data: ArrayBuffer;
             mimeType: ImageMimeType;
         };
     };
-    private _orderedImageData;
-    /**
-     * Stores a map of the unique id of a node to its index in the node array
-     */
-    private _nodeMap;
+    private readonly _orderedImageData;
     /**
      * Baked animation sample rate
      */
     private _animationSampleRate;
-    private _options;
-    private _localEngine;
-    _glTFMaterialExporter: _GLTFMaterialExporter;
-    private _extensions;
-    private static _ExtensionNames;
-    private static _ExtensionFactories;
+    private readonly _options;
+    readonly _materialExporter: GLTFMaterialExporter;
+    private readonly _extensions;
+    private readonly _dataWriter;
+    private readonly _shouldExportNodeMap;
+    private readonly _nodeMap;
+    readonly _materialMap: Map<Material, number>;
+    private readonly _camerasMap;
+    private readonly _nodesCameraMap;
+    private readonly _skinMap;
+    private readonly _nodesSkinMap;
+    readonly _materialNeedsUVsSet: Set<Material>;
+    private static readonly _ExtensionNames;
+    private static readonly _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: {
-        [key: number]: number;
-    }, binaryWriter: _BinaryWriter): Promise<Nullable<INode>>;
-    _extensionsPostExportMaterialAsync(context: string, material: Nullable<IMaterial>, babylonMaterial: Material): Promise<Nullable<IMaterial>>;
+    _extensionsPreExportTextureAsync(context: string, babylonTexture: Texture, mimeType: ImageMimeType): Promise<Nullable<BaseTexture>>;
+    _extensionsPostExportMeshPrimitiveAsync(context: string, meshPrimitive: IMeshPrimitive, babylonSubMesh: SubMesh): Promise<Nullable<IMeshPrimitive>>;
+    _extensionsPostExportNodeAsync(context: string, node: INode, babylonNode: Node, nodeMap: Map<Node, number>, convertToRightHanded: boolean): Promise<Nullable<INode>>;
+    _extensionsPostExportMaterialAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<Nullable<IMaterial>>;
     _extensionsPostExportMaterialAdditionalTextures(context: string, material: IMaterial, babylonMaterial: Material): BaseTexture[];
     _extensionsPostExportTextures(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
     private _forEachExtensions;
     private _extensionsOnExporting;
-    /**
-     * Load glTF serializer extensions
-     */
     private _loadExtensions;
-    /**
-     * Creates a glTF Exporter instance, which can accept optional exporter options
-     * @param babylonScene Babylon scene object
-     * @param options Options to modify the behavior of the exporter
-     */
     constructor(babylonScene?: Nullable<Scene>, options?: IExportOptions);
     dispose(): void;
-    get options(): IExportOptions;
-    /**
-     * Registers a glTF exporter extension
-     * @param name Name of the extension to export
-     * @param factory The factory function that creates the exporter extension
-     */
-    static RegisterExtension(name: string, factory: (exporter: _Exporter) => IGLTFExporterExtensionV2): void;
-    /**
-     * Un-registers an exporter extension
-     * @param name The name fo the exporter extension
-     * @returns A boolean indicating whether the extension has been un-registered
-     */
+    get options(): Required<IExportOptions>;
+    static RegisterExtension(name: string, factory: (exporter: GLTFExporter) => IGLTFExporterExtensionV2): void;
     static UnregisterExtension(name: string): boolean;
-    private _reorderIndicesBasedOnPrimitiveMode;
-    /**
-     * Reorders the vertex attribute data based on the primitive mode.  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 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
-     */
-    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 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
-     */
-    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 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
-     */
-    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 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
-     */
-    private _reorderTriangleFanMode;
-    /**
-     * Writes the vertex attribute data to binary
-     * @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 binaryWriter The writer containing the binary data
-     */
-    private _writeVertexAttributeData;
-    /**
-     * Writes mesh attribute data to a data buffer
-     * Returns the bytelength of the data
-     * @param vertexBufferKind Indicates what kind of vertex data is being passed in
-     * @param attributeComponentKind
-     * @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 babylonTransformNode
-     */
-    _writeAttributeData(vertexBufferKind: string, attributeComponentKind: AccessorComponentType, meshAttributeArray: FloatArray, stride: number, binaryWriter: _BinaryWriter, babylonTransformNode: TransformNode): void;
-    private _createMorphTargetBufferViewKind;
-    /**
-     * Generates glTF json data
-     * @param shouldUseGlb Indicates whether the json should be written for a glb file
-     * @param glTFPrefix Text to use when prefixing a glTF file
-     * @param prettyPrint Indicates whether the json file should be pretty printed (true) or not (false)
-     * @returns json data as string
-     */
     private _generateJSON;
-    /**
-     * Generates data for .gltf and .bin files based on the glTF prefix string
-     * @param glTFPrefix Text to use when prefixing a glTF file
-     * @param dispose Dispose the exporter
-     * @returns GLTFData with glTF file data
-     */
-    _generateGLTFAsync(glTFPrefix: string, dispose?: boolean): Promise<GLTFData>;
-    /**
-     * Creates a binary buffer for glTF
-     * @returns array buffer for binary data
-     */
+    generateGLTFAsync(glTFPrefix: string): Promise<GLTFData>;
     private _generateBinaryAsync;
     /**
      * Pads the number to a multiple of 4
@@ -233,171 +77,26 @@ export declare class _Exporter {
      * @returns padded number
      */
     private _getPadding;
-    /**
-     * @internal
-     */
-    _generateGLBAsync(glTFPrefix: string, dispose?: boolean): Promise<GLTFData>;
-    /**
-     * 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
-     */
+    generateGLBAsync(glTFPrefix: string): Promise<GLTFData>;
     private _setNodeTransformation;
     private _setCameraTransformation;
-    private _getVertexBufferFromMesh;
-    /**
-     * Creates a bufferview based on the vertices type for the Babylon mesh
-     * @param kind Indicates the type of vertices data
-     * @param attributeComponentKind Indicates the numerical type used to store the data
-     * @param babylonTransformNode The Babylon mesh to get the vertices data from
-     * @param binaryWriter The buffer to write the bufferview data to
-     * @param byteStride
-     */
-    private _createBufferViewKind;
-    /**
-     * The primitive mode of the Babylon mesh
-     * @param babylonMesh The BabylonJS mesh
-     * @returns Unsigned integer of the primitive mode or null
-     */
-    private _getMeshPrimitiveMode;
-    /**
-     * Sets the primitive mode of the glTF mesh primitive
-     * @param meshPrimitive glTF mesh primitive
-     * @param primitiveMode The primitive mode
-     */
-    private _setPrimitiveMode;
-    /**
-     * Sets the vertex attribute accessor based of the glTF mesh primitive
-     * @param meshPrimitive glTF mesh primitive
-     * @param attributeKind vertex attribute
-     */
-    private _setAttributeKind;
-    /**
-     * Sets data for the primitive attributes of each submesh
-     * @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
-     * @returns promise that resolves when done setting the primitive attributes
-     */
-    private _setPrimitiveAttributesAsync;
-    /**
-     * Creates a glTF scene based on the array of meshes
-     * Returns the total byte offset
-     * @param binaryWriter Buffer to write binary data to
-     * @returns a promise that resolves when done
-     */
-    private _createSceneAsync;
-    /**
-     * Getting the nodes and materials that would be exported.
-     * @param nodes Babylon transform nodes
-     * @returns Set of materials which would be exported.
-     */
-    private _getExportNodes;
-    /**
-     * Creates a mapping of Node unique id to node index and handles animations
-     * @param nodes Babylon transform nodes
-     * @param binaryWriter Buffer to write binary data to
-     * @returns Node mapping of unique id to index
-     */
-    private _createNodeMapAndAnimationsAsync;
-    /**
-     * Creates a glTF node from a Babylon mesh
-     * @param babylonNode Source Babylon mesh
-     * @param binaryWriter Buffer for storing geometry data
-     * @returns glTF node
-     */
-    private _createNodeAsync;
-    /**
-     * Creates a glTF skin from a Babylon skeleton
-     * @param nodeMap Babylon transform nodes
-     * @param binaryWriter Buffer to write binary data to
-     * @returns Node mapping of unique id to index
-     */
-    private _createSkinsAsync;
-}
-/**
- * @internal
- *
- * Stores glTF binary data.  If the array buffer byte length is exceeded, it doubles in size dynamically
- */
-export declare class _BinaryWriter {
-    /**
-     * Array buffer which stores all binary data
-     */
-    private _arrayBuffer;
-    /**
-     * View of the array buffer
-     */
-    private _dataView;
-    /**
-     * byte offset of data in array buffer
-     */
-    private _byteOffset;
-    /**
-     * Initialize binary writer with an initial byte length
-     * @param byteLength Initial byte length of the array buffer
-     */
-    constructor(byteLength: number);
-    /**
-     * Resize the array buffer to the specified byte length
-     * @param byteLength The new byte length
-     * @returns The resized array buffer
-     */
-    private _resizeBuffer;
-    /**
-     * Get an array buffer with the length of the byte offset
-     * @returns ArrayBuffer resized to the byte offset
-     */
-    getArrayBuffer(): ArrayBuffer;
-    /**
-     * Get the byte offset of the array buffer
-     * @returns byte offset
-     */
-    getByteOffset(): number;
-    /**
-     * Stores an UInt8 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    setUInt8(entry: number, byteOffset?: number): void;
-    /**
-     * Stores an UInt16 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    setUInt16(entry: number, byteOffset?: number): void;
-    /**
-     * Gets an UInt32 in the array buffer
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     * @returns entry
-     */
-    getUInt32(byteOffset: number): number;
-    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
-     * @param byteOffset
-     */
-    setFloat32(entry: number, byteOffset?: number): void;
-    /**
-     * Stores an UInt32 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    setUInt32(entry: number, byteOffset?: number): void;
-    /**
-     * Stores an Int16 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    setInt16(entry: number, byteOffset?: number): void;
-    /**
-     * Stores a byte in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
+    private _listAvailableCameras;
+    private _exportAndAssignCameras;
+    private _listAvailableSkeletons;
+    private _exportAndAssignSkeletons;
+    private _exportSceneAsync;
+    private _shouldExportNode;
+    private _exportNodesAsync;
+    private _collectBuffers;
+    private _exportBuffers;
+    /**
+     * Processes a node to be exported to the glTF file
+     * @returns A promise that resolves with the node index when the processing is complete, or null if the node should not be exported
+     * @internal
      */
-    setByte(entry: number, byteOffset?: number): void;
+    private _exportNodeAsync;
+    private _exportIndices;
+    private _exportVertexBuffer;
+    private _exportMaterialAsync;
+    private _exportMeshAsync;
 }