@babylonjs/serializers 5.0.0-rc.6 → 5.0.0

package/glTF/2.0/glTFExporter.js

@@ -1,1973 +1,1976 @@
-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 { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.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";
-import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.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 attributeComponentKind
-     * @param meshAttributeArray Array containing the attribute data
-     * @param stride Specifies the space between data
-     * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     * @param babylonTransformNode
-     */
-    _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);
-                break;
-            }
-            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 attributeComponentKind
-     * @param meshPrimitive
-     * @param morphTarget
-     * @param meshAttributeArray Array containing the attribute data
-     * @param morphTargetAttributeArray
-     * @param stride Specifies the space between data
-     * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     * @param minMax
-     */
-    _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);
-                break;
-            }
-            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;
-    };
-    /**
-     * @param glTFPrefix
-     * @param dispose
-     * @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 attributeComponentKind Indicates the numerical type used to store the data
-     * @param babylonTransformNode The Babylon mesh to get the vertices data from
-     * @param binaryWriter The buffer to write the bufferview data to
-     * @param byteStride
-     * @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 meshPrimitive
-     * @param babylonMorphTarget the morph target to be exported
-     * @param binaryWriter The buffer to write the bufferview data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     */
-    _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 */;
-                break;
-            }
-            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 instanceof 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 instanceof AbstractMesh) {
-                    var material = babylonNode.material || babylonNode.getScene().defaultMaterial;
-                    if (material instanceof MultiMaterial) {
-                        for (var _a = 0, _b = material.subMaterials; _a < _b.length; _a++) {
-                            var subMaterial = _b[_a];
-                            if (subMaterial) {
-                                exportMaterials.add(subMaterial);
-                            }
-                        }
-                    }
-                    else {
-                        exportMaterials.add(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).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 babylonNode Source Babylon mesh
-     * @param binaryWriter Buffer for storing geometry data
-     * @param convertToRightHandedSystem Converts the values to right-handed
-     * @returns glTF node
-     */
-    _Exporter.prototype._createNodeAsync = function (babylonNode, binaryWriter, convertToRightHandedSystem) {
-        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 nodeMap 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 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
-     * @param byteOffset
-     */
-    _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 };
+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 { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.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 { Engine } from "@babylonjs/core/Engines/engine.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";
+import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.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: "Babylon.js v".concat(Engine.Version), 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 attributeComponentKind
+     * @param meshAttributeArray Array containing the attribute data
+     * @param stride Specifies the space between data
+     * @param binaryWriter The buffer to write the binary data to
+     * @param convertToRightHandedSystem Converts the values to right-handed
+     * @param babylonTransformNode
+     */
+    _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);
+                break;
+            }
+            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 attributeComponentKind
+     * @param meshPrimitive
+     * @param morphTarget
+     * @param meshAttributeArray Array containing the attribute data
+     * @param morphTargetAttributeArray
+     * @param stride Specifies the space between data
+     * @param binaryWriter The buffer to write the binary data to
+     * @param convertToRightHandedSystem Converts the values to right-handed
+     * @param minMax
+     */
+    _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);
+                break;
+            }
+            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;
+    };
+    /**
+     * @param glTFPrefix
+     * @param dispose
+     * @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 attributeComponentKind Indicates the numerical type used to store the data
+     * @param babylonTransformNode The Babylon mesh to get the vertices data from
+     * @param binaryWriter The buffer to write the bufferview data to
+     * @param byteStride
+     * @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 meshPrimitive
+     * @param babylonMorphTarget the morph target to be exported
+     * @param binaryWriter The buffer to write the bufferview data to
+     * @param convertToRightHandedSystem Converts the values to right-handed
+     */
+    _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 */;
+                break;
+            }
+            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 instanceof 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 cameraMap = new Map();
+        babylonScene.cameras.forEach(function (camera) {
+            if (!_this._options.shouldExportNode || _this._options.shouldExportNode(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.fovMode === Camera.FOVMODE_VERTICAL_FIXED ? camera.fov : camera.fov * camera.getEngine().getAspectRatio(camera),
+                        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,
+                    };
+                }
+                cameraMap.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 = cameraMap.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 instanceof AbstractMesh) {
+                    var material = babylonNode.material || babylonNode.getScene().defaultMaterial;
+                    if (material instanceof MultiMaterial) {
+                        for (var _a = 0, _b = material.subMaterials; _a < _b.length; _a++) {
+                            var subMaterial = _b[_a];
+                            if (subMaterial) {
+                                exportMaterials.add(subMaterial);
+                            }
+                        }
+                    }
+                    else {
+                        exportMaterials.add(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).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 babylonNode Source Babylon mesh
+     * @param binaryWriter Buffer for storing geometry data
+     * @param convertToRightHandedSystem Converts the values to right-handed
+     * @returns glTF node
+     */
+    _Exporter.prototype._createNodeAsync = function (babylonNode, binaryWriter, convertToRightHandedSystem) {
+        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 nodeMap 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 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
+     * @param byteOffset
+     */
+    _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