@babylonjs/serializers 5.0.0-beta.8 → 5.0.0-beta.8-snapshot

package/glTF/2.0/glTFExporter.js

@@ -1,1943 +0,0 @@
-import { __spreadArray } from "tslib";
-import { Vector2, Vector3, Vector4, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
-import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.js";
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
-import { LinesMesh } from "@babylonjs/core/Meshes/linesMesh.js";
-import { InstancedMesh } from "@babylonjs/core/Meshes/instancedMesh.js";
-import { Material } from "@babylonjs/core/Materials/material.js";
-import { _GLTFMaterialExporter } from "./glTFMaterialExporter.js";
-import { _GLTFUtilities } from "./glTFUtilities.js";
-import { GLTFData } from "./glTFData.js";
-import { _GLTFAnimation } from "./glTFAnimation.js";
-import { Camera } from "@babylonjs/core/Cameras/camera.js";
-import { EngineStore } from "@babylonjs/core/Engines/engineStore.js";
-/**
- * Converts Babylon Scene into glTF 2.0.
- * @hidden
- */
-var _Exporter = /** @class */ (function () {
-    /**
-     * 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
-     */
-    function _Exporter(babylonScene, options) {
-        /*
-        * Specifies if root Babylon empty nodes that act as a coordinate space transform should be included in export
-        */
-        this._includeCoordinateSystemConversionNodes = false;
-        this._extensions = {};
-        this._glTF = {
-            asset: { generator: "BabylonJS", version: "2.0" }
-        };
-        babylonScene = babylonScene || EngineStore.LastCreatedScene;
-        if (!babylonScene) {
-            return;
-        }
-        this._babylonScene = babylonScene;
-        this._bufferViews = [];
-        this._accessors = [];
-        this._meshes = [];
-        this._scenes = [];
-        this._cameras = [];
-        this._nodes = [];
-        this._images = [];
-        this._materials = [];
-        this._materialMap = [];
-        this._textures = [];
-        this._samplers = [];
-        this._skins = [];
-        this._animations = [];
-        this._imageData = {};
-        this._orderedImageData = [];
-        this._options = options || {};
-        this._animationSampleRate = options && options.animationSampleRate ? options.animationSampleRate : 1 / 60;
-        this._includeCoordinateSystemConversionNodes = options && options.includeCoordinateSystemConversionNodes ? true : false;
-        this._glTFMaterialExporter = new _GLTFMaterialExporter(this);
-        this._loadExtensions();
-    }
-    _Exporter.prototype._applyExtension = function (node, extensions, index, actionAsync) {
-        var _this = this;
-        if (index >= extensions.length) {
-            return Promise.resolve(node);
-        }
-        var currentPromise = actionAsync(extensions[index], node);
-        if (!currentPromise) {
-            return this._applyExtension(node, extensions, index + 1, actionAsync);
-        }
-        return currentPromise.then(function (newNode) { return _this._applyExtension(newNode, extensions, index + 1, actionAsync); });
-    };
-    _Exporter.prototype._applyExtensions = function (node, actionAsync) {
-        var extensions = [];
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_1 = _a[_i];
-            extensions.push(this._extensions[name_1]);
-        }
-        return this._applyExtension(node, extensions, 0, actionAsync);
-    };
-    _Exporter.prototype._extensionsPreExportTextureAsync = function (context, babylonTexture, mimeType) {
-        return this._applyExtensions(babylonTexture, function (extension, node) { return extension.preExportTextureAsync && extension.preExportTextureAsync(context, node, mimeType); });
-    };
-    _Exporter.prototype._extensionsPostExportMeshPrimitiveAsync = function (context, meshPrimitive, babylonSubMesh, binaryWriter) {
-        return this._applyExtensions(meshPrimitive, function (extension, node) { return extension.postExportMeshPrimitiveAsync && extension.postExportMeshPrimitiveAsync(context, node, babylonSubMesh, binaryWriter); });
-    };
-    _Exporter.prototype._extensionsPostExportNodeAsync = function (context, node, babylonNode, nodeMap) {
-        return this._applyExtensions(node, function (extension, node) { return extension.postExportNodeAsync && extension.postExportNodeAsync(context, node, babylonNode, nodeMap); });
-    };
-    _Exporter.prototype._extensionsPostExportMaterialAsync = function (context, material, babylonMaterial) {
-        return this._applyExtensions(material, function (extension, node) { return extension.postExportMaterialAsync && extension.postExportMaterialAsync(context, node, babylonMaterial); });
-    };
-    _Exporter.prototype._extensionsPostExportMaterialAdditionalTextures = function (context, material, babylonMaterial) {
-        var output = [];
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_2 = _a[_i];
-            var extension = this._extensions[name_2];
-            if (extension.postExportMaterialAdditionalTextures) {
-                output.push.apply(output, extension.postExportMaterialAdditionalTextures(context, material, babylonMaterial));
-            }
-        }
-        return output;
-    };
-    _Exporter.prototype._extensionsPostExportTextures = function (context, textureInfo, babylonTexture) {
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_3 = _a[_i];
-            var extension = this._extensions[name_3];
-            if (extension.postExportTexture) {
-                extension.postExportTexture(context, textureInfo, babylonTexture);
-            }
-        }
-    };
-    _Exporter.prototype._forEachExtensions = function (action) {
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_4 = _a[_i];
-            var extension = this._extensions[name_4];
-            if (extension.enabled) {
-                action(extension);
-            }
-        }
-    };
-    _Exporter.prototype._extensionsOnExporting = function () {
-        var _this = this;
-        this._forEachExtensions(function (extension) {
-            if (extension.wasUsed) {
-                if (_this._glTF.extensionsUsed == null) {
-                    _this._glTF.extensionsUsed = [];
-                }
-                if (_this._glTF.extensionsUsed.indexOf(extension.name) === -1) {
-                    _this._glTF.extensionsUsed.push(extension.name);
-                }
-                if (extension.required) {
-                    if (_this._glTF.extensionsRequired == null) {
-                        _this._glTF.extensionsRequired = [];
-                    }
-                    if (_this._glTF.extensionsRequired.indexOf(extension.name) === -1) {
-                        _this._glTF.extensionsRequired.push(extension.name);
-                    }
-                }
-                if (_this._glTF.extensions == null) {
-                    _this._glTF.extensions = {};
-                }
-                if (extension.onExporting) {
-                    extension.onExporting();
-                }
-            }
-        });
-    };
-    /**
-     * Load glTF serializer extensions
-     */
-    _Exporter.prototype._loadExtensions = function () {
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_5 = _a[_i];
-            var extension = _Exporter._ExtensionFactories[name_5](this);
-            this._extensions[name_5] = extension;
-        }
-    };
-    _Exporter.prototype.dispose = function () {
-        for (var extensionKey in this._extensions) {
-            var extension = this._extensions[extensionKey];
-            extension.dispose();
-        }
-    };
-    /**
-     * Registers a glTF exporter extension
-     * @param name Name of the extension to export
-     * @param factory The factory function that creates the exporter extension
-     */
-    _Exporter.RegisterExtension = function (name, factory) {
-        if (_Exporter.UnregisterExtension(name)) {
-            Tools.Warn("Extension with the name ".concat(name, " already exists"));
-        }
-        _Exporter._ExtensionFactories[name] = factory;
-        _Exporter._ExtensionNames.push(name);
-    };
-    /**
-     * Un-registers an exporter extension
-     * @param name The name fo the exporter extension
-     * @returns A boolean indicating whether the extension has been un-registered
-     */
-    _Exporter.UnregisterExtension = function (name) {
-        if (!_Exporter._ExtensionFactories[name]) {
-            return false;
-        }
-        delete _Exporter._ExtensionFactories[name];
-        var index = _Exporter._ExtensionNames.indexOf(name);
-        if (index !== -1) {
-            _Exporter._ExtensionNames.splice(index, 1);
-        }
-        return true;
-    };
-    _Exporter.prototype.reorderIndicesBasedOnPrimitiveMode = function (submesh, primitiveMode, babylonIndices, byteOffset, binaryWriter) {
-        switch (primitiveMode) {
-            case Material.TriangleFillMode: {
-                if (!byteOffset) {
-                    byteOffset = 0;
-                }
-                for (var i = submesh.indexStart, length_1 = submesh.indexStart + submesh.indexCount; i < length_1; i = i + 3) {
-                    var index = byteOffset + i * 4;
-                    // swap the second and third indices
-                    var secondIndex = binaryWriter.getUInt32(index + 4);
-                    var thirdIndex = binaryWriter.getUInt32(index + 8);
-                    binaryWriter.setUInt32(thirdIndex, index + 4);
-                    binaryWriter.setUInt32(secondIndex, index + 8);
-                }
-                break;
-            }
-            case Material.TriangleFanDrawMode: {
-                for (var i = submesh.indexStart + submesh.indexCount - 1, start = submesh.indexStart; i >= start; --i) {
-                    binaryWriter.setUInt32(babylonIndices[i], byteOffset);
-                    byteOffset += 4;
-                }
-                break;
-            }
-            case Material.TriangleStripDrawMode: {
-                if (submesh.indexCount >= 3) {
-                    binaryWriter.setUInt32(babylonIndices[submesh.indexStart + 2], byteOffset + 4);
-                    binaryWriter.setUInt32(babylonIndices[submesh.indexStart + 1], byteOffset + 8);
-                }
-                break;
-            }
-        }
-    };
-    /**
-     * 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 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
-     */
-    _Exporter.prototype.reorderVertexAttributeDataBasedOnPrimitiveMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        if (convertToRightHandedSystem && sideOrientation === Material.ClockWiseSideOrientation) {
-            switch (primitiveMode) {
-                case Material.TriangleFillMode: {
-                    this.reorderTriangleFillMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-                case Material.TriangleStripDrawMode: {
-                    this.reorderTriangleStripDrawMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-                case Material.TriangleFanDrawMode: {
-                    this.reorderTriangleFanMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-            }
-        }
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype.reorderTriangleFillMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        var vertexBuffer = this.getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
-        if (vertexBuffer) {
-            var stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
-            if (submesh.verticesCount % 3 !== 0) {
-                Tools.Error('The submesh vertices for the triangle fill mode is not divisible by 3!');
-            }
-            else {
-                var vertexData = [];
-                var index = 0;
-                switch (vertexBufferKind) {
-                    case VertexBuffer.PositionKind:
-                    case VertexBuffer.NormalKind: {
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
-                            index = x * stride;
-                            vertexData.push(Vector3.FromArray(meshAttributeArray, index));
-                            vertexData.push(Vector3.FromArray(meshAttributeArray, index + 2 * stride));
-                            vertexData.push(Vector3.FromArray(meshAttributeArray, index + stride));
-                        }
-                        break;
-                    }
-                    case VertexBuffer.TangentKind: {
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
-                            index = x * stride;
-                            vertexData.push(Vector4.FromArray(meshAttributeArray, index));
-                            vertexData.push(Vector4.FromArray(meshAttributeArray, index + 2 * stride));
-                            vertexData.push(Vector4.FromArray(meshAttributeArray, index + stride));
-                        }
-                        break;
-                    }
-                    case VertexBuffer.ColorKind: {
-                        var size = vertexBuffer.getSize();
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + size) {
-                            index = x * stride;
-                            if (size === 4) {
-                                vertexData.push(Vector4.FromArray(meshAttributeArray, index));
-                                vertexData.push(Vector4.FromArray(meshAttributeArray, index + 2 * stride));
-                                vertexData.push(Vector4.FromArray(meshAttributeArray, index + stride));
-                            }
-                            else {
-                                vertexData.push(Vector3.FromArray(meshAttributeArray, index));
-                                vertexData.push(Vector3.FromArray(meshAttributeArray, index + 2 * stride));
-                                vertexData.push(Vector3.FromArray(meshAttributeArray, index + stride));
-                            }
-                        }
-                        break;
-                    }
-                    case VertexBuffer.UVKind:
-                    case VertexBuffer.UV2Kind: {
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
-                            index = x * stride;
-                            vertexData.push(Vector2.FromArray(meshAttributeArray, index));
-                            vertexData.push(Vector2.FromArray(meshAttributeArray, index + 2 * stride));
-                            vertexData.push(Vector2.FromArray(meshAttributeArray, index + stride));
-                        }
-                        break;
-                    }
-                    default: {
-                        Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
-                    }
-                }
-                this.writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
-            }
-        }
-        else {
-            Tools.Warn("reorderTriangleFillMode: Vertex Buffer Kind ".concat(vertexBufferKind, " not present!"));
-        }
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype.reorderTriangleStripDrawMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        var vertexBuffer = this.getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
-        if (vertexBuffer) {
-            var stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
-            var vertexData = [];
-            var index = 0;
-            switch (vertexBufferKind) {
-                case VertexBuffer.PositionKind:
-                case VertexBuffer.NormalKind: {
-                    index = submesh.verticesStart;
-                    vertexData.push(Vector3.FromArray(meshAttributeArray, index + 2 * stride));
-                    vertexData.push(Vector3.FromArray(meshAttributeArray, index + stride));
-                    break;
-                }
-                case VertexBuffer.TangentKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexData.push(Vector4.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                case VertexBuffer.ColorKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexBuffer.getSize() === 4 ? vertexData.push(Vector4.FromArray(meshAttributeArray, index)) : vertexData.push(Vector3.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                case VertexBuffer.UVKind:
-                case VertexBuffer.UV2Kind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexData.push(Vector2.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                default: {
-                    Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
-                }
-            }
-            this.writeVertexAttributeData(vertexData, byteOffset + 12, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
-        }
-        else {
-            Tools.Warn("reorderTriangleStripDrawMode: Vertex buffer kind ".concat(vertexBufferKind, " not present!"));
-        }
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype.reorderTriangleFanMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        var vertexBuffer = this.getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
-        if (vertexBuffer) {
-            var stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
-            var vertexData = [];
-            var index = 0;
-            switch (vertexBufferKind) {
-                case VertexBuffer.PositionKind:
-                case VertexBuffer.NormalKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexData.push(Vector3.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                case VertexBuffer.TangentKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexData.push(Vector4.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                case VertexBuffer.ColorKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexData.push(Vector4.FromArray(meshAttributeArray, index));
-                        vertexBuffer.getSize() === 4 ? vertexData.push(Vector4.FromArray(meshAttributeArray, index)) : vertexData.push(Vector3.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                case VertexBuffer.UVKind:
-                case VertexBuffer.UV2Kind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
-                        index = x * stride;
-                        vertexData.push(Vector2.FromArray(meshAttributeArray, index));
-                    }
-                    break;
-                }
-                default: {
-                    Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
-                }
-            }
-            this.writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
-        }
-        else {
-            Tools.Warn("reorderTriangleFanMode: Vertex buffer kind ".concat(vertexBufferKind, " not present!"));
-        }
-    };
-    /**
-     * 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 meshAttributeArray The vertex attribute data
-     * @param binaryWriter The writer containing the binary data
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     */
-    _Exporter.prototype.writeVertexAttributeData = function (vertices, byteOffset, vertexAttributeKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem) {
-        for (var _i = 0, vertices_1 = vertices; _i < vertices_1.length; _i++) {
-            var vertex = vertices_1[_i];
-            if (convertToRightHandedSystem && !(vertexAttributeKind === VertexBuffer.ColorKind) && !(vertex instanceof Vector2)) {
-                if (vertex instanceof Vector3) {
-                    if (vertexAttributeKind === VertexBuffer.NormalKind) {
-                        _GLTFUtilities._GetRightHandedNormalVector3FromRef(vertex);
-                    }
-                    else if (vertexAttributeKind === VertexBuffer.PositionKind) {
-                        _GLTFUtilities._GetRightHandedPositionVector3FromRef(vertex);
-                    }
-                    else {
-                        Tools.Error('Unsupported vertex attribute kind!');
-                    }
-                }
-                else {
-                    _GLTFUtilities._GetRightHandedVector4FromRef(vertex);
-                }
-            }
-            if (vertexAttributeKind === VertexBuffer.NormalKind) {
-                vertex.normalize();
-            }
-            else if (vertexAttributeKind === VertexBuffer.TangentKind && vertex instanceof Vector4) {
-                _GLTFUtilities._NormalizeTangentFromRef(vertex);
-            }
-            for (var _a = 0, _b = vertex.asArray(); _a < _b.length; _a++) {
-                var component = _b[_a];
-                binaryWriter.setFloat32(component, byteOffset);
-                byteOffset += 4;
-            }
-        }
-    };
-    /**
-     * 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 meshAttributeArray Array containing the attribute data
-     * @param byteStride Specifies the space between data
-     * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     */
-    _Exporter.prototype.writeAttributeData = function (vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, convertToRightHandedSystem, babylonTransformNode) {
-        var vertexAttributes = [];
-        var index;
-        switch (vertexBufferKind) {
-            case VertexBuffer.PositionKind: {
-                for (var k = 0, length_2 = meshAttributeArray.length / stride; k < length_2; ++k) {
-                    index = k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedPositionVector3FromRef(vertexData);
-                    }
-                    vertexAttributes.push(vertexData.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.NormalKind: {
-                for (var k = 0, length_3 = meshAttributeArray.length / stride; k < length_3; ++k) {
-                    index = k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedNormalVector3FromRef(vertexData);
-                    }
-                    vertexData.normalize();
-                    vertexAttributes.push(vertexData.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.TangentKind: {
-                for (var k = 0, length_4 = meshAttributeArray.length / stride; k < length_4; ++k) {
-                    index = k * stride;
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedVector4FromRef(vertexData);
-                    }
-                    _GLTFUtilities._NormalizeTangentFromRef(vertexData);
-                    vertexAttributes.push(vertexData.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.ColorKind: {
-                var meshMaterial = babylonTransformNode.material;
-                var convertToLinear = meshMaterial ? (meshMaterial.getClassName() === "StandardMaterial") : true;
-                var vertexData = stride === 3 ? new Color3() : new Color4();
-                for (var k = 0, length_5 = meshAttributeArray.length / stride; k < length_5; ++k) {
-                    index = k * stride;
-                    if (stride === 3) {
-                        Color3.FromArrayToRef(meshAttributeArray, index, vertexData);
-                        if (convertToLinear) {
-                            vertexData.toLinearSpaceToRef(vertexData);
-                        }
-                    }
-                    else {
-                        Color4.FromArrayToRef(meshAttributeArray, index, vertexData);
-                        if (convertToLinear) {
-                            vertexData.toLinearSpaceToRef(vertexData);
-                        }
-                    }
-                    vertexAttributes.push(vertexData.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.UVKind:
-            case VertexBuffer.UV2Kind: {
-                for (var k = 0, length_6 = meshAttributeArray.length / stride; k < length_6; ++k) {
-                    index = k * stride;
-                    vertexAttributes.push(convertToRightHandedSystem ? [meshAttributeArray[index], meshAttributeArray[index + 1]] : [meshAttributeArray[index], meshAttributeArray[index + 1]]);
-                }
-                break;
-            }
-            case VertexBuffer.MatricesIndicesKind:
-            case VertexBuffer.MatricesIndicesExtraKind: {
-                for (var k = 0, length_7 = meshAttributeArray.length / stride; k < length_7; ++k) {
-                    index = k * stride;
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
-                    vertexAttributes.push(vertexData.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.MatricesWeightsKind:
-            case VertexBuffer.MatricesWeightsExtraKind: {
-                for (var k = 0, length_8 = meshAttributeArray.length / stride; k < length_8; ++k) {
-                    index = k * stride;
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
-                    vertexAttributes.push(vertexData.asArray());
-                }
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Vertex Buffer Type: " + vertexBufferKind);
-                vertexAttributes = [];
-            }
-        }
-        var writeBinaryFunc;
-        switch (attributeComponentKind) {
-            case 5121 /* UNSIGNED_BYTE */: {
-                writeBinaryFunc = binaryWriter.setUInt8.bind(binaryWriter);
-                break;
-            }
-            case 5123 /* UNSIGNED_SHORT */: {
-                writeBinaryFunc = binaryWriter.setUInt16.bind(binaryWriter);
-                break;
-            }
-            case 5125 /* UNSIGNED_INT */: {
-                writeBinaryFunc = binaryWriter.setUInt32.bind(binaryWriter);
-            }
-            case 5126 /* FLOAT */: {
-                writeBinaryFunc = binaryWriter.setFloat32.bind(binaryWriter);
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Attribute Component kind: " + attributeComponentKind);
-                return;
-            }
-        }
-        for (var _i = 0, vertexAttributes_1 = vertexAttributes; _i < vertexAttributes_1.length; _i++) {
-            var vertexAttribute = vertexAttributes_1[_i];
-            for (var _a = 0, vertexAttribute_1 = vertexAttribute; _a < vertexAttribute_1.length; _a++) {
-                var component = vertexAttribute_1[_a];
-                writeBinaryFunc(component);
-            }
-        }
-    };
-    /**
-     * 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 meshAttributeArray Array containing the attribute data
-     * @param byteStride Specifies the space between data
-     * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     */
-    _Exporter.prototype.writeMorphTargetAttributeData = function (vertexBufferKind, attributeComponentKind, meshPrimitive, morphTarget, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, convertToRightHandedSystem, minMax) {
-        var vertexAttributes = [];
-        var index;
-        var difference = new Vector3();
-        var difference4 = new Vector4(0, 0, 0, 0);
-        switch (vertexBufferKind) {
-            case VertexBuffer.PositionKind: {
-                for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
-                    index = meshPrimitive.indexStart + k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    var morphData = Vector3.FromArray(morphTargetAttributeArray, index);
-                    difference = morphData.subtractToRef(vertexData, difference);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedPositionVector3FromRef(difference);
-                    }
-                    if (minMax) {
-                        minMax.min.copyFromFloats(Math.min(difference.x, minMax.min.x), Math.min(difference.y, minMax.min.y), Math.min(difference.z, minMax.min.z));
-                        minMax.max.copyFromFloats(Math.max(difference.x, minMax.max.x), Math.max(difference.y, minMax.max.y), Math.max(difference.z, minMax.max.z));
-                    }
-                    vertexAttributes.push(difference.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.NormalKind: {
-                for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
-                    index = meshPrimitive.indexStart + k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    vertexData.normalize();
-                    var morphData = Vector3.FromArray(morphTargetAttributeArray, index);
-                    morphData.normalize();
-                    difference = morphData.subtractToRef(vertexData, difference);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedNormalVector3FromRef(difference);
-                    }
-                    vertexAttributes.push(difference.asArray());
-                }
-                break;
-            }
-            case VertexBuffer.TangentKind: {
-                for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
-                    index = meshPrimitive.indexStart + k * (stride + 1);
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
-                    _GLTFUtilities._NormalizeTangentFromRef(vertexData);
-                    var morphData = Vector4.FromArray(morphTargetAttributeArray, index);
-                    _GLTFUtilities._NormalizeTangentFromRef(morphData);
-                    difference4 = morphData.subtractToRef(vertexData, difference4);
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedVector4FromRef(difference4);
-                    }
-                    vertexAttributes.push([difference4.x, difference4.y, difference4.z]);
-                }
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Vertex Buffer Type: " + vertexBufferKind);
-                vertexAttributes = [];
-            }
-        }
-        var writeBinaryFunc;
-        switch (attributeComponentKind) {
-            case 5121 /* UNSIGNED_BYTE */: {
-                writeBinaryFunc = binaryWriter.setUInt8.bind(binaryWriter);
-                break;
-            }
-            case 5123 /* UNSIGNED_SHORT */: {
-                writeBinaryFunc = binaryWriter.setUInt16.bind(binaryWriter);
-                break;
-            }
-            case 5125 /* UNSIGNED_INT */: {
-                writeBinaryFunc = binaryWriter.setUInt32.bind(binaryWriter);
-            }
-            case 5126 /* FLOAT */: {
-                writeBinaryFunc = binaryWriter.setFloat32.bind(binaryWriter);
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Attribute Component kind: " + attributeComponentKind);
-                return;
-            }
-        }
-        for (var _i = 0, vertexAttributes_2 = vertexAttributes; _i < vertexAttributes_2.length; _i++) {
-            var vertexAttribute = vertexAttributes_2[_i];
-            for (var _a = 0, vertexAttribute_2 = vertexAttribute; _a < vertexAttribute_2.length; _a++) {
-                var component = vertexAttribute_2[_a];
-                writeBinaryFunc(component);
-            }
-        }
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype.generateJSON = function (shouldUseGlb, glTFPrefix, prettyPrint) {
-        var _this = this;
-        var buffer = { byteLength: this._totalByteLength };
-        var imageName;
-        var imageData;
-        var bufferView;
-        var byteOffset = this._totalByteLength;
-        if (buffer.byteLength) {
-            this._glTF.buffers = [buffer];
-        }
-        if (this._nodes && this._nodes.length) {
-            this._glTF.nodes = this._nodes;
-        }
-        if (this._meshes && this._meshes.length) {
-            this._glTF.meshes = this._meshes;
-        }
-        if (this._scenes && this._scenes.length) {
-            this._glTF.scenes = this._scenes;
-            this._glTF.scene = 0;
-        }
-        if (this._cameras && this._cameras.length) {
-            this._glTF.cameras = this._cameras;
-        }
-        if (this._bufferViews && this._bufferViews.length) {
-            this._glTF.bufferViews = this._bufferViews;
-        }
-        if (this._accessors && this._accessors.length) {
-            this._glTF.accessors = this._accessors;
-        }
-        if (this._animations && this._animations.length) {
-            this._glTF.animations = this._animations;
-        }
-        if (this._materials && this._materials.length) {
-            this._glTF.materials = this._materials;
-        }
-        if (this._textures && this._textures.length) {
-            this._glTF.textures = this._textures;
-        }
-        if (this._samplers && this._samplers.length) {
-            this._glTF.samplers = this._samplers;
-        }
-        if (this._skins && this._skins.length) {
-            this._glTF.skins = this._skins;
-        }
-        if (this._images && this._images.length) {
-            if (!shouldUseGlb) {
-                this._glTF.images = this._images;
-            }
-            else {
-                this._glTF.images = [];
-                this._images.forEach(function (image) {
-                    if (image.uri) {
-                        imageData = _this._imageData[image.uri];
-                        _this._orderedImageData.push(imageData);
-                        imageName = image.uri.split('.')[0] + " image";
-                        bufferView = _GLTFUtilities._CreateBufferView(0, byteOffset, imageData.data.length, undefined, imageName);
-                        byteOffset += imageData.data.buffer.byteLength;
-                        _this._bufferViews.push(bufferView);
-                        image.bufferView = _this._bufferViews.length - 1;
-                        image.name = imageName;
-                        image.mimeType = imageData.mimeType;
-                        image.uri = undefined;
-                        if (!_this._glTF.images) {
-                            _this._glTF.images = [];
-                        }
-                        _this._glTF.images.push(image);
-                    }
-                });
-                // Replace uri with bufferview and mime type for glb
-                buffer.byteLength = byteOffset;
-            }
-        }
-        if (!shouldUseGlb) {
-            buffer.uri = glTFPrefix + ".bin";
-        }
-        var jsonText = prettyPrint ? JSON.stringify(this._glTF, null, 2) : JSON.stringify(this._glTF);
-        return jsonText;
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype._generateGLTFAsync = function (glTFPrefix, dispose) {
-        var _this = this;
-        if (dispose === void 0) { dispose = true; }
-        return this._generateBinaryAsync().then(function (binaryBuffer) {
-            _this._extensionsOnExporting();
-            var jsonText = _this.generateJSON(false, glTFPrefix, true);
-            var bin = new Blob([binaryBuffer], { type: 'application/octet-stream' });
-            var glTFFileName = glTFPrefix + '.gltf';
-            var glTFBinFile = glTFPrefix + '.bin';
-            var container = new GLTFData();
-            container.glTFFiles[glTFFileName] = jsonText;
-            container.glTFFiles[glTFBinFile] = bin;
-            if (_this._imageData) {
-                for (var image in _this._imageData) {
-                    container.glTFFiles[image] = new Blob([_this._imageData[image].data], { type: _this._imageData[image].mimeType });
-                }
-            }
-            if (dispose) {
-                _this.dispose();
-            }
-            return container;
-        });
-    };
-    /**
-     * Creates a binary buffer for glTF
-     * @returns array buffer for binary data
-     */
-    _Exporter.prototype._generateBinaryAsync = function () {
-        var _this = this;
-        var binaryWriter = new _BinaryWriter(4);
-        return this.createSceneAsync(this._babylonScene, binaryWriter).then(function () {
-            if (_this._localEngine) {
-                _this._localEngine.dispose();
-            }
-            return binaryWriter.getArrayBuffer();
-        });
-    };
-    /**
-     * Pads the number to a multiple of 4
-     * @param num number to pad
-     * @returns padded number
-     */
-    _Exporter.prototype._getPadding = function (num) {
-        var remainder = num % 4;
-        var padding = remainder === 0 ? remainder : 4 - remainder;
-        return padding;
-    };
-    /**
-     * @hidden
-     */
-    _Exporter.prototype._generateGLBAsync = function (glTFPrefix, dispose) {
-        var _this = this;
-        if (dispose === void 0) { dispose = true; }
-        return this._generateBinaryAsync().then(function (binaryBuffer) {
-            _this._extensionsOnExporting();
-            var jsonText = _this.generateJSON(true);
-            var glbFileName = glTFPrefix + '.glb';
-            var headerLength = 12;
-            var chunkLengthPrefix = 8;
-            var jsonLength = jsonText.length;
-            var encodedJsonText;
-            var imageByteLength = 0;
-            // make use of TextEncoder when available
-            if (typeof TextEncoder !== "undefined") {
-                var encoder = new TextEncoder();
-                encodedJsonText = encoder.encode(jsonText);
-                jsonLength = encodedJsonText.length;
-            }
-            for (var i = 0; i < _this._orderedImageData.length; ++i) {
-                imageByteLength += _this._orderedImageData[i].data.byteLength;
-            }
-            var jsonPadding = _this._getPadding(jsonLength);
-            var binPadding = _this._getPadding(binaryBuffer.byteLength);
-            var imagePadding = _this._getPadding(imageByteLength);
-            var byteLength = headerLength + (2 * chunkLengthPrefix) + jsonLength + jsonPadding + binaryBuffer.byteLength + binPadding + imageByteLength + imagePadding;
-            //header
-            var headerBuffer = new ArrayBuffer(headerLength);
-            var headerBufferView = new DataView(headerBuffer);
-            headerBufferView.setUint32(0, 0x46546C67, true); //glTF
-            headerBufferView.setUint32(4, 2, true); // version
-            headerBufferView.setUint32(8, byteLength, true); // total bytes in file
-            //json chunk
-            var jsonChunkBuffer = new ArrayBuffer(chunkLengthPrefix + jsonLength + jsonPadding);
-            var jsonChunkBufferView = new DataView(jsonChunkBuffer);
-            jsonChunkBufferView.setUint32(0, jsonLength + jsonPadding, true);
-            jsonChunkBufferView.setUint32(4, 0x4E4F534A, true);
-            //json chunk bytes
-            var jsonData = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix);
-            // if TextEncoder was available, we can simply copy the encoded array
-            if (encodedJsonText) {
-                jsonData.set(encodedJsonText);
-            }
-            else {
-                var blankCharCode = "_".charCodeAt(0);
-                for (var i = 0; i < jsonLength; ++i) {
-                    var charCode = jsonText.charCodeAt(i);
-                    // if the character doesn't fit into a single UTF-16 code unit, just put a blank character
-                    if (charCode != jsonText.codePointAt(i)) {
-                        jsonData[i] = blankCharCode;
-                    }
-                    else {
-                        jsonData[i] = charCode;
-                    }
-                }
-            }
-            //json padding
-            var jsonPaddingView = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix + jsonLength);
-            for (var i = 0; i < jsonPadding; ++i) {
-                jsonPaddingView[i] = 0x20;
-            }
-            //binary chunk
-            var binaryChunkBuffer = new ArrayBuffer(chunkLengthPrefix);
-            var binaryChunkBufferView = new DataView(binaryChunkBuffer);
-            binaryChunkBufferView.setUint32(0, binaryBuffer.byteLength + imageByteLength + imagePadding, true);
-            binaryChunkBufferView.setUint32(4, 0x004E4942, true);
-            // binary padding
-            var binPaddingBuffer = new ArrayBuffer(binPadding);
-            var binPaddingView = new Uint8Array(binPaddingBuffer);
-            for (var i = 0; i < binPadding; ++i) {
-                binPaddingView[i] = 0;
-            }
-            var imagePaddingBuffer = new ArrayBuffer(imagePadding);
-            var imagePaddingView = new Uint8Array(imagePaddingBuffer);
-            for (var i = 0; i < imagePadding; ++i) {
-                imagePaddingView[i] = 0;
-            }
-            var glbData = [headerBuffer, jsonChunkBuffer, binaryChunkBuffer, binaryBuffer];
-            // binary data
-            for (var i = 0; i < _this._orderedImageData.length; ++i) {
-                glbData.push(_this._orderedImageData[i].data.buffer);
-            }
-            glbData.push(binPaddingBuffer);
-            glbData.push(imagePaddingBuffer);
-            var glbFile = new Blob(glbData, { type: 'application/octet-stream' });
-            var container = new GLTFData();
-            container.glTFFiles[glbFileName] = glbFile;
-            if (_this._localEngine != null) {
-                _this._localEngine.dispose();
-            }
-            if (dispose) {
-                _this.dispose();
-            }
-            return container;
-        });
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype.setNodeTransformation = function (node, babylonTransformNode, convertToRightHandedSystem) {
-        if (!babylonTransformNode.getPivotPoint().equalsToFloats(0, 0, 0)) {
-            Tools.Warn("Pivot points are not supported in the glTF serializer");
-        }
-        if (!babylonTransformNode.position.equalsToFloats(0, 0, 0)) {
-            node.translation = convertToRightHandedSystem ? _GLTFUtilities._GetRightHandedPositionVector3(babylonTransformNode.position).asArray() : babylonTransformNode.position.asArray();
-        }
-        if (!babylonTransformNode.scaling.equalsToFloats(1, 1, 1)) {
-            node.scale = babylonTransformNode.scaling.asArray();
-        }
-        var rotationQuaternion = Quaternion.RotationYawPitchRoll(babylonTransformNode.rotation.y, babylonTransformNode.rotation.x, babylonTransformNode.rotation.z);
-        if (babylonTransformNode.rotationQuaternion) {
-            rotationQuaternion.multiplyInPlace(babylonTransformNode.rotationQuaternion);
-        }
-        if (!Quaternion.IsIdentity(rotationQuaternion)) {
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-            }
-            node.rotation = rotationQuaternion.normalize().asArray();
-        }
-    };
-    _Exporter.prototype.setCameraTransformation = function (node, babylonCamera, convertToRightHandedSystem) {
-        if (!babylonCamera.position.equalsToFloats(0, 0, 0)) {
-            node.translation = convertToRightHandedSystem ? _GLTFUtilities._GetRightHandedPositionVector3(babylonCamera.position).asArray() : babylonCamera.position.asArray();
-        }
-        var rotationQuaternion = babylonCamera.absoluteRotation;
-        if (!Quaternion.IsIdentity(rotationQuaternion)) {
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-            }
-            node.rotation = rotationQuaternion.normalize().asArray();
-        }
-    };
-    _Exporter.prototype.getVertexBufferFromMesh = function (attributeKind, bufferMesh) {
-        if (bufferMesh.isVerticesDataPresent(attributeKind)) {
-            var vertexBuffer = bufferMesh.getVertexBuffer(attributeKind);
-            if (vertexBuffer) {
-                return vertexBuffer;
-            }
-        }
-        return null;
-    };
-    /**
-     * Creates a bufferview based on the vertices type for the Babylon mesh
-     * @param kind Indicates the type of vertices data
-     * @param componentType 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 convertToRightHandedSystem Converts the values to right-handed
-     */
-    _Exporter.prototype.createBufferViewKind = function (kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride, convertToRightHandedSystem) {
-        var bufferMesh = babylonTransformNode instanceof Mesh ?
-            babylonTransformNode : babylonTransformNode instanceof InstancedMesh ?
-            babylonTransformNode.sourceMesh : null;
-        if (bufferMesh) {
-            var vertexBuffer = bufferMesh.getVertexBuffer(kind);
-            var vertexData = bufferMesh.getVerticesData(kind);
-            if (vertexBuffer && vertexData) {
-                var typeByteLength = VertexBuffer.GetTypeByteLength(attributeComponentKind);
-                var byteLength = vertexData.length * typeByteLength;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, kind + " - " + bufferMesh.name);
-                this._bufferViews.push(bufferView);
-                this.writeAttributeData(kind, attributeComponentKind, vertexData, byteStride / typeByteLength, binaryWriter, convertToRightHandedSystem, babylonTransformNode);
-            }
-        }
-    };
-    /**
- * Creates a bufferview based on the vertices type for the Babylon mesh
- * @param babylonSubMesh The Babylon submesh that the morph target is applied to
- * @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
- */
-    _Exporter.prototype.setMorphTargetAttributes = function (babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter, convertToRightHandedSystem) {
-        if (babylonMorphTarget) {
-            if (!meshPrimitive.targets) {
-                meshPrimitive.targets = [];
-            }
-            var target = {};
-            if (babylonMorphTarget.hasNormals) {
-                var vertexNormals = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.NormalKind);
-                var morphNormals = babylonMorphTarget.getNormals();
-                var count = babylonSubMesh.verticesCount;
-                var byteStride = 12; // 3 x 4 byte floats
-                var byteLength = count * byteStride;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
-                this._bufferViews.push(bufferView);
-                var bufferViewIndex = this._bufferViews.length - 1;
-                var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "NORMAL", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
-                this._accessors.push(accessor);
-                target.NORMAL = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.NormalKind, 5126 /* FLOAT */, babylonSubMesh, babylonMorphTarget, vertexNormals, morphNormals, byteStride / 4, binaryWriter, convertToRightHandedSystem);
-            }
-            if (babylonMorphTarget.hasPositions) {
-                var vertexPositions = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.PositionKind);
-                var morphPositions = babylonMorphTarget.getPositions();
-                var count = babylonSubMesh.verticesCount;
-                var byteStride = 12; // 3 x 4 byte floats
-                var byteLength = count * byteStride;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_POSITION");
-                this._bufferViews.push(bufferView);
-                var bufferViewIndex = this._bufferViews.length - 1;
-                var minMax = { min: new Vector3(Infinity, Infinity, Infinity), max: new Vector3(-Infinity, -Infinity, -Infinity) };
-                var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "POSITION", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
-                this._accessors.push(accessor);
-                target.POSITION = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.PositionKind, 5126 /* FLOAT */, babylonSubMesh, babylonMorphTarget, vertexPositions, morphPositions, byteStride / 4, binaryWriter, convertToRightHandedSystem, minMax);
-                accessor.min = minMax.min.asArray();
-                accessor.max = minMax.max.asArray();
-            }
-            if (babylonMorphTarget.hasTangents) {
-                var vertexTangents = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.TangentKind);
-                var morphTangents = babylonMorphTarget.getTangents();
-                var count = babylonSubMesh.verticesCount;
-                var byteStride = 12; // 3 x 4 byte floats
-                var byteLength = count * byteStride;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
-                this._bufferViews.push(bufferView);
-                var bufferViewIndex = this._bufferViews.length - 1;
-                var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "TANGENT", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
-                this._accessors.push(accessor);
-                target.TANGENT = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.TangentKind, 5126 /* FLOAT */, babylonSubMesh, babylonMorphTarget, vertexTangents, morphTangents, byteStride / 4, binaryWriter, convertToRightHandedSystem);
-            }
-            meshPrimitive.targets.push(target);
-        }
-    };
-    /**
-     * The primitive mode of the Babylon mesh
-     * @param babylonMesh The BabylonJS mesh
-     */
-    _Exporter.prototype.getMeshPrimitiveMode = function (babylonMesh) {
-        if (babylonMesh instanceof LinesMesh) {
-            return Material.LineListDrawMode;
-        }
-        return babylonMesh.material ? babylonMesh.material.fillMode : Material.TriangleFillMode;
-    };
-    /**
-     * Sets the primitive mode of the glTF mesh primitive
-     * @param meshPrimitive glTF mesh primitive
-     * @param primitiveMode The primitive mode
-     */
-    _Exporter.prototype.setPrimitiveMode = function (meshPrimitive, primitiveMode) {
-        switch (primitiveMode) {
-            case Material.TriangleFillMode: {
-                // glTF defaults to using Triangle Mode
-                break;
-            }
-            case Material.TriangleStripDrawMode: {
-                meshPrimitive.mode = 5 /* TRIANGLE_STRIP */;
-                break;
-            }
-            case Material.TriangleFanDrawMode: {
-                meshPrimitive.mode = 6 /* TRIANGLE_FAN */;
-                break;
-            }
-            case Material.PointListDrawMode: {
-                meshPrimitive.mode = 0 /* POINTS */;
-            }
-            case Material.PointFillMode: {
-                meshPrimitive.mode = 0 /* POINTS */;
-                break;
-            }
-            case Material.LineLoopDrawMode: {
-                meshPrimitive.mode = 2 /* LINE_LOOP */;
-                break;
-            }
-            case Material.LineListDrawMode: {
-                meshPrimitive.mode = 1 /* LINES */;
-                break;
-            }
-            case Material.LineStripDrawMode: {
-                meshPrimitive.mode = 3 /* LINE_STRIP */;
-                break;
-            }
-        }
-    };
-    /**
-     * Sets the vertex attribute accessor based of the glTF mesh primitive
-     * @param meshPrimitive glTF mesh primitive
-     * @param attributeKind vertex attribute
-     * @returns boolean specifying if uv coordinates are present
-     */
-    _Exporter.prototype.setAttributeKind = function (meshPrimitive, attributeKind) {
-        switch (attributeKind) {
-            case VertexBuffer.PositionKind: {
-                meshPrimitive.attributes.POSITION = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.NormalKind: {
-                meshPrimitive.attributes.NORMAL = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.ColorKind: {
-                meshPrimitive.attributes.COLOR_0 = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.TangentKind: {
-                meshPrimitive.attributes.TANGENT = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.UVKind: {
-                meshPrimitive.attributes.TEXCOORD_0 = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.UV2Kind: {
-                meshPrimitive.attributes.TEXCOORD_1 = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.MatricesIndicesKind: {
-                meshPrimitive.attributes.JOINTS_0 = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.MatricesIndicesExtraKind: {
-                meshPrimitive.attributes.JOINTS_1 = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.MatricesWeightsKind: {
-                meshPrimitive.attributes.WEIGHTS_0 = this._accessors.length - 1;
-                break;
-            }
-            case VertexBuffer.MatricesWeightsExtraKind: {
-                meshPrimitive.attributes.WEIGHTS_1 = this._accessors.length - 1;
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Vertex Buffer Type: " + attributeKind);
-            }
-        }
-    };
-    /**
-     * 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
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     */
-    _Exporter.prototype.setPrimitiveAttributesAsync = function (mesh, babylonTransformNode, binaryWriter, convertToRightHandedSystem) {
-        var _a;
-        var promises = [];
-        var bufferMesh = null;
-        var bufferView;
-        var minMax;
-        if (babylonTransformNode instanceof Mesh) {
-            bufferMesh = babylonTransformNode;
-        }
-        else if (babylonTransformNode instanceof InstancedMesh) {
-            bufferMesh = babylonTransformNode.sourceMesh;
-        }
-        var attributeData = [
-            { kind: VertexBuffer.PositionKind, accessorType: "VEC3" /* VEC3 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 12 },
-            { kind: VertexBuffer.NormalKind, accessorType: "VEC3" /* VEC3 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 12 },
-            { kind: VertexBuffer.ColorKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 16 },
-            { kind: VertexBuffer.TangentKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 16 },
-            { kind: VertexBuffer.UVKind, accessorType: "VEC2" /* VEC2 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 8 },
-            { kind: VertexBuffer.UV2Kind, accessorType: "VEC2" /* VEC2 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 8 },
-            { kind: VertexBuffer.MatricesIndicesKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5123 /* UNSIGNED_SHORT */, byteStride: 8 },
-            { kind: VertexBuffer.MatricesIndicesExtraKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5123 /* UNSIGNED_SHORT */, byteStride: 8 },
-            { kind: VertexBuffer.MatricesWeightsKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 16 },
-            { kind: VertexBuffer.MatricesWeightsExtraKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 16 },
-        ];
-        if (bufferMesh) {
-            var indexBufferViewIndex = null;
-            var primitiveMode = this.getMeshPrimitiveMode(bufferMesh);
-            var vertexAttributeBufferViews = {};
-            var morphTargetManager = bufferMesh.morphTargetManager;
-            // For each BabylonMesh, create bufferviews for each 'kind'
-            for (var _i = 0, attributeData_1 = attributeData; _i < attributeData_1.length; _i++) {
-                var attribute = attributeData_1[_i];
-                var attributeKind = attribute.kind;
-                var attributeComponentKind = attribute.accessorComponentType;
-                if (bufferMesh.isVerticesDataPresent(attributeKind)) {
-                    var vertexBuffer = this.getVertexBufferFromMesh(attributeKind, bufferMesh);
-                    attribute.byteStride = vertexBuffer ? vertexBuffer.getSize() * VertexBuffer.GetTypeByteLength(attribute.accessorComponentType) : VertexBuffer.DeduceStride(attributeKind) * 4;
-                    if (attribute.byteStride === 12) {
-                        attribute.accessorType = "VEC3" /* VEC3 */;
-                    }
-                    this.createBufferViewKind(attributeKind, attributeComponentKind, babylonTransformNode, binaryWriter, attribute.byteStride, convertToRightHandedSystem);
-                    attribute.bufferViewIndex = this._bufferViews.length - 1;
-                    vertexAttributeBufferViews[attributeKind] = attribute.bufferViewIndex;
-                }
-            }
-            if (bufferMesh.getTotalIndices()) {
-                var indices = bufferMesh.getIndices();
-                if (indices) {
-                    var byteLength = indices.length * 4;
-                    bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, "Indices - " + bufferMesh.name);
-                    this._bufferViews.push(bufferView);
-                    indexBufferViewIndex = this._bufferViews.length - 1;
-                    for (var k = 0, length_9 = indices.length; k < length_9; ++k) {
-                        binaryWriter.setUInt32(indices[k]);
-                    }
-                }
-            }
-            if (bufferMesh.subMeshes) {
-                // go through all mesh primitives (submeshes)
-                for (var _b = 0, _c = bufferMesh.subMeshes; _b < _c.length; _b++) {
-                    var submesh = _c[_b];
-                    var babylonMaterial = submesh.getMaterial() || bufferMesh.getScene().defaultMaterial;
-                    var materialIndex = null;
-                    if (babylonMaterial) {
-                        if (bufferMesh instanceof LinesMesh) {
-                            // get the color from the lines mesh and set it in the material
-                            var material = {
-                                name: bufferMesh.name + ' material'
-                            };
-                            if (!bufferMesh.color.equals(Color3.White()) || bufferMesh.alpha < 1) {
-                                material.pbrMetallicRoughness = {
-                                    baseColorFactor: bufferMesh.color.asArray().concat([bufferMesh.alpha])
-                                };
-                            }
-                            this._materials.push(material);
-                            materialIndex = this._materials.length - 1;
-                        }
-                        else if (babylonMaterial.getClassName() === "MultiMaterial") {
-                            var subMaterial = babylonMaterial.subMaterials[submesh.materialIndex];
-                            if (subMaterial) {
-                                babylonMaterial = subMaterial;
-                                materialIndex = this._materialMap[babylonMaterial.uniqueId];
-                            }
-                        }
-                        else {
-                            materialIndex = this._materialMap[babylonMaterial.uniqueId];
-                        }
-                    }
-                    var glTFMaterial = materialIndex != null ? this._materials[materialIndex] : null;
-                    var meshPrimitive = { attributes: {} };
-                    this.setPrimitiveMode(meshPrimitive, primitiveMode);
-                    for (var _d = 0, attributeData_2 = attributeData; _d < attributeData_2.length; _d++) {
-                        var attribute = attributeData_2[_d];
-                        var attributeKind = attribute.kind;
-                        if ((attributeKind === VertexBuffer.UVKind || attributeKind === VertexBuffer.UV2Kind) && !this._options.exportUnusedUVs) {
-                            if (!glTFMaterial || !this._glTFMaterialExporter._hasTexturesPresent(glTFMaterial)) {
-                                continue;
-                            }
-                        }
-                        var vertexData = bufferMesh.getVerticesData(attributeKind);
-                        if (vertexData) {
-                            var vertexBuffer = this.getVertexBufferFromMesh(attributeKind, bufferMesh);
-                            if (vertexBuffer) {
-                                var stride = vertexBuffer.getSize();
-                                var bufferViewIndex = attribute.bufferViewIndex;
-                                if (bufferViewIndex != undefined) { // check to see if bufferviewindex has a numeric value assigned.
-                                    minMax = { min: null, max: null };
-                                    if (attributeKind == VertexBuffer.PositionKind) {
-                                        minMax = _GLTFUtilities._CalculateMinMaxPositions(vertexData, 0, vertexData.length / stride, convertToRightHandedSystem);
-                                    }
-                                    var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, attributeKind + " - " + babylonTransformNode.name, attribute.accessorType, attribute.accessorComponentType, vertexData.length / stride, 0, minMax.min, minMax.max);
-                                    this._accessors.push(accessor);
-                                    this.setAttributeKind(meshPrimitive, attributeKind);
-                                }
-                            }
-                        }
-                    }
-                    if (indexBufferViewIndex) {
-                        // Create accessor
-                        var accessor = _GLTFUtilities._CreateAccessor(indexBufferViewIndex, "indices - " + babylonTransformNode.name, "SCALAR" /* SCALAR */, 5125 /* UNSIGNED_INT */, submesh.indexCount, submesh.indexStart * 4, null, null);
-                        this._accessors.push(accessor);
-                        meshPrimitive.indices = this._accessors.length - 1;
-                    }
-                    if (materialIndex != null && Object.keys(meshPrimitive.attributes).length > 0) {
-                        var sideOrientation = bufferMesh.overrideMaterialSideOrientation !== null ? bufferMesh.overrideMaterialSideOrientation : babylonMaterial.sideOrientation;
-                        if ((sideOrientation == Material.ClockWiseSideOrientation && this._babylonScene.useRightHandedSystem)
-                            || (sideOrientation == Material.ClockWiseSideOrientation && convertToRightHandedSystem && bufferMesh.overrideMaterialSideOrientation !== ((_a = bufferMesh.material) === null || _a === void 0 ? void 0 : _a.sideOrientation))) {
-                            var byteOffset = indexBufferViewIndex != null ? this._bufferViews[indexBufferViewIndex].byteOffset : null;
-                            if (byteOffset == null) {
-                                byteOffset = 0;
-                            }
-                            var babylonIndices = null;
-                            if (indexBufferViewIndex != null) {
-                                babylonIndices = bufferMesh.getIndices();
-                            }
-                            if (babylonIndices) {
-                                this.reorderIndicesBasedOnPrimitiveMode(submesh, primitiveMode, babylonIndices, byteOffset, binaryWriter);
-                            }
-                            else {
-                                for (var _e = 0, attributeData_3 = attributeData; _e < attributeData_3.length; _e++) {
-                                    var attribute = attributeData_3[_e];
-                                    var vertexData = bufferMesh.getVerticesData(attribute.kind);
-                                    if (vertexData) {
-                                        var byteOffset_1 = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset;
-                                        if (!byteOffset_1) {
-                                            byteOffset_1 = 0;
-                                        }
-                                        this.reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, attribute.kind, vertexData, byteOffset_1, binaryWriter, convertToRightHandedSystem);
-                                    }
-                                }
-                            }
-                        }
-                        meshPrimitive.material = materialIndex;
-                    }
-                    if (morphTargetManager) {
-                        var target = void 0;
-                        for (var i = 0; i < morphTargetManager.numTargets; ++i) {
-                            target = morphTargetManager.getTarget(i);
-                            this.setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter, convertToRightHandedSystem);
-                        }
-                    }
-                    mesh.primitives.push(meshPrimitive);
-                    this._extensionsPostExportMeshPrimitiveAsync("postExport", meshPrimitive, submesh, binaryWriter);
-                    promises.push();
-                }
-            }
-        }
-        return Promise.all(promises).then(function () {
-            /* do nothing */
-        });
-    };
-    /**
-     * Check if the node is used to convert its descendants from a right handed coordinate system to the Babylon scene's coordinate system.
-     * @param node The node to check
-     * @returns True if the node is used to convert its descendants from right-handed to left-handed. False otherwise
-     */
-    _Exporter.prototype.isBabylonCoordinateSystemConvertingNode = function (node) {
-        if (node instanceof TransformNode) {
-            if (node.name !== "__root__") {
-                return false;
-            }
-            // Transform
-            var matrix = node.getWorldMatrix();
-            if (matrix.determinant() === 1) {
-                return false;
-            }
-            // Geometry
-            if ((node instanceof Mesh && node.geometry !== null) ||
-                (node instanceof InstancedMesh && node.sourceMesh.geometry !== null)) {
-                return false;
-            }
-            if (this._includeCoordinateSystemConversionNodes) {
-                return false;
-            }
-            return true;
-        }
-        return false;
-    };
-    /**
-     * Creates a glTF scene based on the array of meshes
-     * Returns the the total byte offset
-     * @param babylonScene Babylon scene to get the mesh data from
-     * @param binaryWriter Buffer to write binary data to
-     */
-    _Exporter.prototype.createSceneAsync = function (babylonScene, binaryWriter) {
-        var _this = this;
-        var scene = { nodes: [] };
-        var glTFNodeIndex;
-        var glTFNode;
-        var directDescendents;
-        var nodes = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], babylonScene.transformNodes, true), babylonScene.meshes, true), babylonScene.lights, true), babylonScene.cameras, true);
-        var rootNodesToLeftHanded = [];
-        this._convertToRightHandedSystem = !babylonScene.useRightHandedSystem;
-        this._convertToRightHandedSystemMap = {};
-        // Set default values for all nodes
-        babylonScene.rootNodes.forEach(function (rootNode) {
-            _this._convertToRightHandedSystemMap[rootNode.uniqueId] = _this._convertToRightHandedSystem;
-            rootNode.getDescendants(false).forEach(function (descendant) {
-                _this._convertToRightHandedSystemMap[descendant.uniqueId] = _this._convertToRightHandedSystem;
-            });
-        });
-        // Check if root nodes converting to left-handed are present
-        babylonScene.rootNodes.forEach(function (rootNode) {
-            if (_this.isBabylonCoordinateSystemConvertingNode(rootNode)) {
-                rootNodesToLeftHanded.push(rootNode);
-                // Exclude the node from list of nodes to export
-                var indexRootNode = nodes.indexOf(rootNode);
-                if (indexRootNode !== -1) { // should always be true
-                    nodes.splice(indexRootNode, 1);
-                }
-                // Cancel conversion to right handed system
-                rootNode.getDescendants(false).forEach(function (descendant) {
-                    _this._convertToRightHandedSystemMap[descendant.uniqueId] = false;
-                });
-            }
-        });
-        // Export babylon cameras to glTFCamera
-        var cameraHash = new Map();
-        babylonScene.cameras.forEach(function (camera) {
-            var glTFCamera = {
-                type: camera.mode === Camera.PERSPECTIVE_CAMERA ? "perspective" /* PERSPECTIVE */ : "orthographic" /* ORTHOGRAPHIC */
-            };
-            if (camera.name) {
-                glTFCamera.name = camera.name;
-            }
-            if (glTFCamera.type === "perspective" /* PERSPECTIVE */) {
-                glTFCamera.perspective = {
-                    aspectRatio: camera.getEngine().getAspectRatio(camera),
-                    yfov: camera._cache.fovMode === Camera.FOVMODE_VERTICAL_FIXED ? camera.fov : camera.fov * camera._cache.aspectRatio,
-                    znear: camera.minZ, zfar: camera.maxZ
-                };
-            }
-            else if (glTFCamera.type === "orthographic" /* ORTHOGRAPHIC */) {
-                var halfWidth = camera.orthoLeft && camera.orthoRight ?
-                    0.5 * (camera.orthoRight - camera.orthoLeft) : camera.getEngine().getRenderWidth() * 0.5;
-                var halfHeight = camera.orthoBottom && camera.orthoTop ?
-                    0.5 * (camera.orthoTop - camera.orthoBottom) : camera.getEngine().getRenderHeight() * 0.5;
-                glTFCamera.orthographic = {
-                    xmag: halfWidth, ymag: halfHeight,
-                    znear: camera.minZ, zfar: camera.maxZ
-                };
-            }
-            cameraHash.set(camera, _this._cameras.length);
-            _this._cameras.push(glTFCamera);
-        });
-        var _a = this.getExportNodes(nodes), exportNodes = _a[0], exportMaterials = _a[1];
-        return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(exportMaterials, "image/png" /* PNG */, true).then(function () {
-            return _this.createNodeMapAndAnimationsAsync(babylonScene, exportNodes, binaryWriter).then(function (nodeMap) {
-                return _this.createSkinsAsync(babylonScene, nodeMap, binaryWriter).then(function (skinMap) {
-                    _this._nodeMap = nodeMap;
-                    _this._totalByteLength = binaryWriter.getByteOffset();
-                    if (_this._totalByteLength == undefined) {
-                        throw new Error("undefined byte length!");
-                    }
-                    // Build Hierarchy with the node map.
-                    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-                        var babylonNode = nodes_1[_i];
-                        glTFNodeIndex = _this._nodeMap[babylonNode.uniqueId];
-                        if (glTFNodeIndex !== undefined) {
-                            glTFNode = _this._nodes[glTFNodeIndex];
-                            if (babylonNode.metadata) {
-                                if (_this._options.metadataSelector) {
-                                    glTFNode.extras = _this._options.metadataSelector(babylonNode.metadata);
-                                }
-                                else if (babylonNode.metadata.gltf) {
-                                    glTFNode.extras = babylonNode.metadata.gltf.extras;
-                                }
-                            }
-                            if (babylonNode instanceof Camera) {
-                                glTFNode.camera = cameraHash.get(babylonNode);
-                            }
-                            if (!babylonNode.parent || rootNodesToLeftHanded.indexOf(babylonNode.parent) !== -1) {
-                                if (_this._options.shouldExportNode && !_this._options.shouldExportNode(babylonNode)) {
-                                    Tools.Log("Omitting " + babylonNode.name + " from scene.");
-                                }
-                                else {
-                                    var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                                    if (convertToRightHandedSystem) {
-                                        if (glTFNode.translation) {
-                                            glTFNode.translation[2] *= -1;
-                                            glTFNode.translation[0] *= -1;
-                                        }
-                                        glTFNode.rotation = glTFNode.rotation ? Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(glTFNode.rotation)).asArray() : (Quaternion.FromArray([0, 1, 0, 0])).asArray();
-                                    }
-                                    scene.nodes.push(glTFNodeIndex);
-                                }
-                            }
-                            if (babylonNode instanceof Mesh) {
-                                var babylonMesh = babylonNode;
-                                if (babylonMesh.skeleton) {
-                                    glTFNode.skin = skinMap[babylonMesh.skeleton.uniqueId];
-                                }
-                            }
-                            directDescendents = babylonNode.getDescendants(true);
-                            if (!glTFNode.children && directDescendents && directDescendents.length) {
-                                var children = [];
-                                for (var _a = 0, directDescendents_1 = directDescendents; _a < directDescendents_1.length; _a++) {
-                                    var descendent = directDescendents_1[_a];
-                                    if (_this._nodeMap[descendent.uniqueId] != null) {
-                                        children.push(_this._nodeMap[descendent.uniqueId]);
-                                    }
-                                }
-                                if (children.length) {
-                                    glTFNode.children = children;
-                                }
-                            }
-                        }
-                    }
-                    if (scene.nodes.length) {
-                        _this._scenes.push(scene);
-                    }
-                });
-            });
-        });
-    };
-    /**
-     * Getting the nodes and materials that would be exported.
-     * @param nodes Babylon transform nodes
-     * @returns Array of nodes which would be exported.
-     * @returns Set of materials which would be exported.
-     */
-    _Exporter.prototype.getExportNodes = function (nodes) {
-        var exportNodes = [];
-        var exportMaterials = new Set();
-        for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-            var babylonNode = nodes_2[_i];
-            if (!this._options.shouldExportNode || this._options.shouldExportNode(babylonNode)) {
-                exportNodes.push(babylonNode);
-                if (babylonNode.getClassName() === "Mesh") {
-                    var mesh = babylonNode;
-                    if (mesh.material) {
-                        exportMaterials.add(mesh.material);
-                    }
-                }
-                else {
-                    var meshes = babylonNode.getChildMeshes(false);
-                    for (var _a = 0, meshes_1 = meshes; _a < meshes_1.length; _a++) {
-                        var mesh = meshes_1[_a];
-                        if (mesh.material) {
-                            exportMaterials.add(mesh.material);
-                        }
-                    }
-                }
-            }
-            else {
-                "Excluding node ".concat(babylonNode.name);
-            }
-        }
-        return [exportNodes, exportMaterials];
-    };
-    /**
-     * 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
-     */
-    _Exporter.prototype.createNodeMapAndAnimationsAsync = function (babylonScene, nodes, binaryWriter) {
-        var _this = this;
-        var promiseChain = Promise.resolve();
-        var nodeMap = {};
-        var nodeIndex;
-        var runtimeGLTFAnimation = {
-            name: 'runtime animations',
-            channels: [],
-            samplers: []
-        };
-        var idleGLTFAnimations = [];
-        var _loop_1 = function (babylonNode) {
-            promiseChain = promiseChain.then(function () {
-                var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                return _this.createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem, nodeMap).then(function (node) {
-                    var promise = _this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap);
-                    if (promise == null) {
-                        Tools.Warn("Not exporting node ".concat(babylonNode.name));
-                        return Promise.resolve();
-                    }
-                    else {
-                        return promise.then(function (node) {
-                            if (!node) {
-                                return;
-                            }
-                            _this._nodes.push(node);
-                            nodeIndex = _this._nodes.length - 1;
-                            nodeMap[babylonNode.uniqueId] = nodeIndex;
-                            if (!babylonScene.animationGroups.length) {
-                                _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
-                                if (babylonNode.animations.length) {
-                                    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
-                                }
-                            }
-                        });
-                    }
-                });
-            });
-        };
-        for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
-            var babylonNode = nodes_3[_i];
-            _loop_1(babylonNode);
-        }
-        return promiseChain.then(function () {
-            if (runtimeGLTFAnimation.channels.length && runtimeGLTFAnimation.samplers.length) {
-                _this._animations.push(runtimeGLTFAnimation);
-            }
-            idleGLTFAnimations.forEach(function (idleGLTFAnimation) {
-                if (idleGLTFAnimation.channels.length && idleGLTFAnimation.samplers.length) {
-                    _this._animations.push(idleGLTFAnimation);
-                }
-            });
-            if (babylonScene.animationGroups.length) {
-                _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, _this._animations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, _this._convertToRightHandedSystemMap, _this._animationSampleRate);
-            }
-            return nodeMap;
-        });
-    };
-    /**
-     * Creates a glTF node from a Babylon mesh
-     * @param babylonMesh Source Babylon mesh
-     * @param binaryWriter Buffer for storing geometry data
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     * @param nodeMap Node mapping of unique id to glTF node index
-     * @returns glTF node
-     */
-    _Exporter.prototype.createNodeAsync = function (babylonNode, binaryWriter, convertToRightHandedSystem, nodeMap) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            // create node to hold translation/rotation/scale and the mesh
-            var node = {};
-            // create mesh
-            var mesh = { primitives: [] };
-            if (babylonNode.name) {
-                node.name = babylonNode.name;
-            }
-            if (babylonNode instanceof TransformNode) {
-                // Set transformation
-                _this.setNodeTransformation(node, babylonNode, convertToRightHandedSystem);
-                if (babylonNode instanceof Mesh) {
-                    var morphTargetManager = babylonNode.morphTargetManager;
-                    if (morphTargetManager && morphTargetManager.numTargets > 0) {
-                        mesh.weights = [];
-                        for (var i = 0; i < morphTargetManager.numTargets; ++i) {
-                            mesh.weights.push(morphTargetManager.getTarget(i).influence);
-                        }
-                    }
-                }
-                return _this.setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter, convertToRightHandedSystem).then(function () {
-                    if (mesh.primitives.length) {
-                        _this._meshes.push(mesh);
-                        node.mesh = _this._meshes.length - 1;
-                    }
-                    return node;
-                });
-            }
-            else if (babylonNode instanceof Camera) {
-                _this.setCameraTransformation(node, babylonNode, convertToRightHandedSystem);
-                return node;
-            }
-            else {
-                return node;
-            }
-        });
-    };
-    /**
-     * Creates a glTF skin from a Babylon skeleton
-     * @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
-     */
-    _Exporter.prototype.createSkinsAsync = function (babylonScene, nodeMap, binaryWriter) {
-        var _a;
-        var promiseChain = Promise.resolve();
-        var skinMap = {};
-        for (var _i = 0, _b = babylonScene.skeletons; _i < _b.length; _i++) {
-            var skeleton = _b[_i];
-            // create skin
-            var skin = { joints: [] };
-            var inverseBindMatrices = [];
-            var boneIndexMap = {};
-            var maxBoneIndex = -1;
-            for (var i = 0; i < skeleton.bones.length; ++i) {
-                var bone = skeleton.bones[i];
-                var boneIndex = (_a = bone.getIndex()) !== null && _a !== void 0 ? _a : i;
-                if (boneIndex !== -1) {
-                    boneIndexMap[boneIndex] = bone;
-                    if (boneIndex > maxBoneIndex) {
-                        maxBoneIndex = boneIndex;
-                    }
-                }
-            }
-            for (var boneIndex = 0; boneIndex <= maxBoneIndex; ++boneIndex) {
-                var bone = boneIndexMap[boneIndex];
-                inverseBindMatrices.push(bone.getInvertedAbsoluteTransform());
-                var transformNode = bone.getTransformNode();
-                if (transformNode) {
-                    skin.joints.push(nodeMap[transformNode.uniqueId]);
-                }
-                else {
-                    Tools.Warn("Exporting a bone without a linked transform node is currently unsupported");
-                }
-            }
-            // create buffer view for inverse bind matrices
-            var byteStride = 64; // 4 x 4 matrix of 32 bit float
-            var byteLength = inverseBindMatrices.length * byteStride;
-            var bufferViewOffset = binaryWriter.getByteOffset();
-            var bufferView = _GLTFUtilities._CreateBufferView(0, bufferViewOffset, byteLength, undefined, "InverseBindMatrices" + " - " + skeleton.name);
-            this._bufferViews.push(bufferView);
-            var bufferViewIndex = this._bufferViews.length - 1;
-            var bindMatrixAccessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, "InverseBindMatrices" + " - " + skeleton.name, "MAT4" /* MAT4 */, 5126 /* FLOAT */, inverseBindMatrices.length, null, null, null);
-            var inverseBindAccessorIndex = this._accessors.push(bindMatrixAccessor) - 1;
-            skin.inverseBindMatrices = inverseBindAccessorIndex;
-            this._skins.push(skin);
-            skinMap[skeleton.uniqueId] = this._skins.length - 1;
-            inverseBindMatrices.forEach(function (mat) {
-                mat.m.forEach(function (cell) {
-                    binaryWriter.setFloat32(cell);
-                });
-            });
-        }
-        return promiseChain.then(function () {
-            return skinMap;
-        });
-    };
-    _Exporter._ExtensionNames = new Array();
-    _Exporter._ExtensionFactories = {};
-    return _Exporter;
-}());
-export { _Exporter };
-/**
- * @hidden
- *
- * Stores glTF binary data.  If the array buffer byte length is exceeded, it doubles in size dynamically
- */
-var _BinaryWriter = /** @class */ (function () {
-    /**
-     * Initialize binary writer with an initial byte length
-     * @param byteLength Initial byte length of the array buffer
-     */
-    function _BinaryWriter(byteLength) {
-        this._arrayBuffer = new ArrayBuffer(byteLength);
-        this._dataView = new DataView(this._arrayBuffer);
-        this._byteOffset = 0;
-    }
-    /**
-     * Resize the array buffer to the specified byte length
-     * @param byteLength
-     */
-    _BinaryWriter.prototype.resizeBuffer = function (byteLength) {
-        var newBuffer = new ArrayBuffer(byteLength);
-        var oldUint8Array = new Uint8Array(this._arrayBuffer);
-        var newUint8Array = new Uint8Array(newBuffer);
-        for (var i = 0, length_10 = newUint8Array.byteLength; i < length_10; ++i) {
-            newUint8Array[i] = oldUint8Array[i];
-        }
-        this._arrayBuffer = newBuffer;
-        this._dataView = new DataView(this._arrayBuffer);
-        return newBuffer;
-    };
-    /**
-     * Get an array buffer with the length of the byte offset
-     * @returns ArrayBuffer resized to the byte offset
-     */
-    _BinaryWriter.prototype.getArrayBuffer = function () {
-        return this.resizeBuffer(this.getByteOffset());
-    };
-    /**
-     * Get the byte offset of the array buffer
-     * @returns byte offset
-     */
-    _BinaryWriter.prototype.getByteOffset = function () {
-        if (this._byteOffset == undefined) {
-            throw new Error("Byte offset is undefined!");
-        }
-        return this._byteOffset;
-    };
-    /**
-     * Stores an UInt8 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    _BinaryWriter.prototype.setUInt8 = function (entry, byteOffset) {
-        if (byteOffset != null) {
-            if (byteOffset < this._byteOffset) {
-                this._dataView.setUint8(byteOffset, entry);
-            }
-            else {
-                Tools.Error('BinaryWriter: byteoffset is greater than the current binary buffer length!');
-            }
-        }
-        else {
-            if (this._byteOffset + 1 > this._arrayBuffer.byteLength) {
-                this.resizeBuffer(this._arrayBuffer.byteLength * 2);
-            }
-            this._dataView.setUint8(this._byteOffset, entry);
-            this._byteOffset += 1;
-        }
-    };
-    /**
-     * Stores an UInt16 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    _BinaryWriter.prototype.setUInt16 = function (entry, byteOffset) {
-        if (byteOffset != null) {
-            if (byteOffset < this._byteOffset) {
-                this._dataView.setUint16(byteOffset, entry, true);
-            }
-            else {
-                Tools.Error('BinaryWriter: byteoffset is greater than the current binary buffer length!');
-            }
-        }
-        else {
-            if (this._byteOffset + 2 > this._arrayBuffer.byteLength) {
-                this.resizeBuffer(this._arrayBuffer.byteLength * 2);
-            }
-            this._dataView.setUint16(this._byteOffset, entry, true);
-            this._byteOffset += 2;
-        }
-    };
-    /**
-     * Gets an UInt32 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    _BinaryWriter.prototype.getUInt32 = function (byteOffset) {
-        if (byteOffset < this._byteOffset) {
-            return this._dataView.getUint32(byteOffset, true);
-        }
-        else {
-            Tools.Error('BinaryWriter: byteoffset is greater than the current binary buffer length!');
-            throw new Error('BinaryWriter: byteoffset is greater than the current binary buffer length!');
-        }
-    };
-    _BinaryWriter.prototype.getVector3Float32FromRef = function (vector3, byteOffset) {
-        if (byteOffset + 8 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
-        }
-        else {
-            vector3.x = this._dataView.getFloat32(byteOffset, true);
-            vector3.y = this._dataView.getFloat32(byteOffset + 4, true);
-            vector3.z = this._dataView.getFloat32(byteOffset + 8, true);
-        }
-    };
-    _BinaryWriter.prototype.setVector3Float32FromRef = function (vector3, byteOffset) {
-        if (byteOffset + 8 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
-        }
-        else {
-            this._dataView.setFloat32(byteOffset, vector3.x, true);
-            this._dataView.setFloat32(byteOffset + 4, vector3.y, true);
-            this._dataView.setFloat32(byteOffset + 8, vector3.z, true);
-        }
-    };
-    _BinaryWriter.prototype.getVector4Float32FromRef = function (vector4, byteOffset) {
-        if (byteOffset + 12 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
-        }
-        else {
-            vector4.x = this._dataView.getFloat32(byteOffset, true);
-            vector4.y = this._dataView.getFloat32(byteOffset + 4, true);
-            vector4.z = this._dataView.getFloat32(byteOffset + 8, true);
-            vector4.w = this._dataView.getFloat32(byteOffset + 12, true);
-        }
-    };
-    _BinaryWriter.prototype.setVector4Float32FromRef = function (vector4, byteOffset) {
-        if (byteOffset + 12 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
-        }
-        else {
-            this._dataView.setFloat32(byteOffset, vector4.x, true);
-            this._dataView.setFloat32(byteOffset + 4, vector4.y, true);
-            this._dataView.setFloat32(byteOffset + 8, vector4.z, true);
-            this._dataView.setFloat32(byteOffset + 12, vector4.w, true);
-        }
-    };
-    /**
-     * Stores a Float32 in the array buffer
-     * @param entry
-     */
-    _BinaryWriter.prototype.setFloat32 = function (entry, byteOffset) {
-        if (isNaN(entry)) {
-            Tools.Error('Invalid data being written!');
-        }
-        if (byteOffset != null) {
-            if (byteOffset < this._byteOffset) {
-                this._dataView.setFloat32(byteOffset, entry, true);
-            }
-            else {
-                Tools.Error('BinaryWriter: byteoffset is greater than the current binary length!');
-            }
-        }
-        if (this._byteOffset + 4 > this._arrayBuffer.byteLength) {
-            this.resizeBuffer(this._arrayBuffer.byteLength * 2);
-        }
-        this._dataView.setFloat32(this._byteOffset, entry, true);
-        this._byteOffset += 4;
-    };
-    /**
-     * Stores an UInt32 in the array buffer
-     * @param entry
-     * @param byteOffset If defined, specifies where to set the value as an offset.
-     */
-    _BinaryWriter.prototype.setUInt32 = function (entry, byteOffset) {
-        if (byteOffset != null) {
-            if (byteOffset < this._byteOffset) {
-                this._dataView.setUint32(byteOffset, entry, true);
-            }
-            else {
-                Tools.Error('BinaryWriter: byteoffset is greater than the current binary buffer length!');
-            }
-        }
-        else {
-            if (this._byteOffset + 4 > this._arrayBuffer.byteLength) {
-                this.resizeBuffer(this._arrayBuffer.byteLength * 2);
-            }
-            this._dataView.setUint32(this._byteOffset, entry, true);
-            this._byteOffset += 4;
-        }
-    };
-    return _BinaryWriter;
-}());
-export { _BinaryWriter };
-//# sourceMappingURL=glTFExporter.js.map