babylonjs-loaders 5.0.0-rc.9 → 5.0.2

package/babylon.glTF1FileLoader.js

@@ -0,0 +1,4063 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("babylonjs"));
+	else if(typeof define === 'function' && define.amd)
+		define("babylonjs-loaders", ["babylonjs"], factory);
+	else if(typeof exports === 'object')
+		exports["babylonjs-loaders"] = factory(require("babylonjs"));
+	else
+		root["LOADERS"] = factory(root["BABYLON"]);
+})((typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this), function(__WEBPACK_EXTERNAL_MODULE_core_Misc_observable__) {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "../../../../node_modules/tslib/tslib.es6.js":
+/*!***************************************************!*\
+  !*** ../../../../node_modules/tslib/tslib.es6.js ***!
+  \***************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "__assign": () => (/* binding */ __assign),
+/* harmony export */   "__asyncDelegator": () => (/* binding */ __asyncDelegator),
+/* harmony export */   "__asyncGenerator": () => (/* binding */ __asyncGenerator),
+/* harmony export */   "__asyncValues": () => (/* binding */ __asyncValues),
+/* harmony export */   "__await": () => (/* binding */ __await),
+/* harmony export */   "__awaiter": () => (/* binding */ __awaiter),
+/* harmony export */   "__classPrivateFieldGet": () => (/* binding */ __classPrivateFieldGet),
+/* harmony export */   "__classPrivateFieldSet": () => (/* binding */ __classPrivateFieldSet),
+/* harmony export */   "__createBinding": () => (/* binding */ __createBinding),
+/* harmony export */   "__decorate": () => (/* binding */ __decorate),
+/* harmony export */   "__exportStar": () => (/* binding */ __exportStar),
+/* harmony export */   "__extends": () => (/* binding */ __extends),
+/* harmony export */   "__generator": () => (/* binding */ __generator),
+/* harmony export */   "__importDefault": () => (/* binding */ __importDefault),
+/* harmony export */   "__importStar": () => (/* binding */ __importStar),
+/* harmony export */   "__makeTemplateObject": () => (/* binding */ __makeTemplateObject),
+/* harmony export */   "__metadata": () => (/* binding */ __metadata),
+/* harmony export */   "__param": () => (/* binding */ __param),
+/* harmony export */   "__read": () => (/* binding */ __read),
+/* harmony export */   "__rest": () => (/* binding */ __rest),
+/* harmony export */   "__spread": () => (/* binding */ __spread),
+/* harmony export */   "__spreadArray": () => (/* binding */ __spreadArray),
+/* harmony export */   "__spreadArrays": () => (/* binding */ __spreadArrays),
+/* harmony export */   "__values": () => (/* binding */ __values)
+/* harmony export */ });
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var __createBinding = Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+
+function __exportStar(m, o) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+/** @deprecated */
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+var __setModuleDefault = Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/1.0/glTFBinaryExtension.js":
+/*!*****************************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/1.0/glTFBinaryExtension.js ***!
+  \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFBinaryExtension": () => (/* binding */ GLTFBinaryExtension)
+/* harmony export */ });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../../../node_modules/tslib/tslib.es6.js");
+/* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoader */ "../../../lts/loaders/dist/glTF/1.0/glTFLoader.js");
+/* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderUtils */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderUtils.js");
+/* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderInterfaces.js");
+
+
+
+
+var BinaryExtensionBufferName = "binary_glTF";
+/** @hidden */
+var GLTFBinaryExtension = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(GLTFBinaryExtension, _super);
+    function GLTFBinaryExtension() {
+        return _super.call(this, "KHR_binary_glTF") || this;
+    }
+    GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess) {
+        var extensionsUsed = data.json.extensionsUsed;
+        if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) {
+            return false;
+        }
+        this._bin = data.bin;
+        onSuccess(_glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
+        return true;
+    };
+    GLTFBinaryExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        if (gltfRuntime.extensionsUsed.indexOf(this.name) === -1) {
+            return false;
+        }
+        if (id !== BinaryExtensionBufferName) {
+            return false;
+        }
+        this._bin.readAsync(0, this._bin.byteLength).then(onSuccess, function (error) { return onError(error.message); });
+        return true;
+    };
+    GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess) {
+        var texture = gltfRuntime.textures[id];
+        var source = gltfRuntime.images[texture.source];
+        if (!source.extensions || !(this.name in source.extensions)) {
+            return false;
+        }
+        var sourceExt = source.extensions[this.name];
+        var bufferView = gltfRuntime.bufferViews[sourceExt.bufferView];
+        var buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_3__.EComponentType.UNSIGNED_BYTE);
+        onSuccess(buffer);
+        return true;
+    };
+    GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess) {
+        var shader = gltfRuntime.shaders[id];
+        if (!shader.extensions || !(this.name in shader.extensions)) {
+            return false;
+        }
+        var binaryExtensionShader = shader.extensions[this.name];
+        var bufferView = gltfRuntime.bufferViews[binaryExtensionShader.bufferView];
+        var shaderBytes = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_3__.EComponentType.UNSIGNED_BYTE);
+        setTimeout(function () {
+            var shaderString = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.DecodeBufferToText(shaderBytes);
+            onSuccess(shaderString);
+        });
+        return true;
+    };
+    return GLTFBinaryExtension;
+}(_glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderExtension));
+
+_glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoader.RegisterExtension(new GLTFBinaryExtension());
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/1.0/glTFLoader.js":
+/*!********************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/1.0/glTFLoader.js ***!
+  \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFLoader": () => (/* binding */ GLTFLoader),
+/* harmony export */   "GLTFLoaderBase": () => (/* binding */ GLTFLoaderBase),
+/* harmony export */   "GLTFLoaderExtension": () => (/* binding */ GLTFLoaderExtension)
+/* harmony export */ });
+/* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderInterfaces.js");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Engines/constants */ "core/Misc/observable");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderUtils */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderUtils.js");
+/* harmony import */ var _glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../glTFFileLoader */ "../../../lts/loaders/dist/glTF/glTFFileLoader.js");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Tokenizer. Used for shaders compatibility
+ * Automatically map world, view, projection, worldViewProjection, attributes and so on
+ */
+var ETokenType;
+(function (ETokenType) {
+    ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
+    ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
+    ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
+})(ETokenType || (ETokenType = {}));
+var Tokenizer = /** @class */ (function () {
+    function Tokenizer(toParse) {
+        this._pos = 0;
+        this.currentToken = ETokenType.UNKNOWN;
+        this.currentIdentifier = "";
+        this.currentString = "";
+        this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/;
+        this._toParse = toParse;
+        this._maxPos = toParse.length;
+    }
+    Tokenizer.prototype.getNextToken = function () {
+        if (this.isEnd()) {
+            return ETokenType.END_OF_INPUT;
+        }
+        this.currentString = this.read();
+        this.currentToken = ETokenType.UNKNOWN;
+        if (this.currentString === "_" || this.isLetterOrDigitPattern.test(this.currentString)) {
+            this.currentToken = ETokenType.IDENTIFIER;
+            this.currentIdentifier = this.currentString;
+            while (!this.isEnd() && (this.isLetterOrDigitPattern.test((this.currentString = this.peek())) || this.currentString === "_")) {
+                this.currentIdentifier += this.currentString;
+                this.forward();
+            }
+        }
+        return this.currentToken;
+    };
+    Tokenizer.prototype.peek = function () {
+        return this._toParse[this._pos];
+    };
+    Tokenizer.prototype.read = function () {
+        return this._toParse[this._pos++];
+    };
+    Tokenizer.prototype.forward = function () {
+        this._pos++;
+    };
+    Tokenizer.prototype.isEnd = function () {
+        return this._pos >= this._maxPos;
+    };
+    return Tokenizer;
+}());
+/**
+ * Values
+ */
+var glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
+var babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
+var glTFAnimationPaths = ["translation", "rotation", "scale"];
+var babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
+/**
+ * Parse
+ * @param parsedBuffers
+ * @param gltfRuntime
+ */
+var parseBuffers = function (parsedBuffers, gltfRuntime) {
+    for (var buf in parsedBuffers) {
+        var parsedBuffer = parsedBuffers[buf];
+        gltfRuntime.buffers[buf] = parsedBuffer;
+        gltfRuntime.buffersCount++;
+    }
+};
+var parseShaders = function (parsedShaders, gltfRuntime) {
+    for (var sha in parsedShaders) {
+        var parsedShader = parsedShaders[sha];
+        gltfRuntime.shaders[sha] = parsedShader;
+        gltfRuntime.shaderscount++;
+    }
+};
+var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
+    for (var object in parsedObjects) {
+        var parsedObject = parsedObjects[object];
+        gltfRuntime[runtimeProperty][object] = parsedObject;
+    }
+};
+/**
+ * Utils
+ * @param buffer
+ */
+var normalizeUVs = function (buffer) {
+    if (!buffer) {
+        return;
+    }
+    for (var i = 0; i < buffer.length / 2; i++) {
+        buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
+    }
+};
+var getAttribute = function (attributeParameter) {
+    if (attributeParameter.semantic === "NORMAL") {
+        return "normal";
+    }
+    else if (attributeParameter.semantic === "POSITION") {
+        return "position";
+    }
+    else if (attributeParameter.semantic === "JOINT") {
+        return "matricesIndices";
+    }
+    else if (attributeParameter.semantic === "WEIGHT") {
+        return "matricesWeights";
+    }
+    else if (attributeParameter.semantic === "COLOR") {
+        return "color";
+    }
+    else if (attributeParameter.semantic && attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
+        var channel = Number(attributeParameter.semantic.split("_")[1]);
+        return "uv" + (channel === 0 ? "" : channel + 1);
+    }
+    return null;
+};
+/**
+ * Loads and creates animations
+ * @param gltfRuntime
+ */
+var loadAnimations = function (gltfRuntime) {
+    for (var anim in gltfRuntime.animations) {
+        var animation = gltfRuntime.animations[anim];
+        if (!animation.channels || !animation.samplers) {
+            continue;
+        }
+        var lastAnimation = null;
+        for (var i = 0; i < animation.channels.length; i++) {
+            // Get parameters and load buffers
+            var channel = animation.channels[i];
+            var sampler = animation.samplers[channel.sampler];
+            if (!sampler) {
+                continue;
+            }
+            var inputData = null;
+            var outputData = null;
+            if (animation.parameters) {
+                inputData = animation.parameters[sampler.input];
+                outputData = animation.parameters[sampler.output];
+            }
+            else {
+                inputData = sampler.input;
+                outputData = sampler.output;
+            }
+            var bufferInput = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
+            var bufferOutput = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[outputData]);
+            var targetId = channel.target.id;
+            var targetNode = gltfRuntime.scene.getNodeById(targetId);
+            if (targetNode === null) {
+                targetNode = gltfRuntime.scene.getNodeByName(targetId);
+            }
+            if (targetNode === null) {
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetId + " to attach to");
+                continue;
+            }
+            var isBone = targetNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Bone;
+            // Get target path (position, rotation or scaling)
+            var targetPath = channel.target.path;
+            var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
+            if (targetPathIndex !== -1) {
+                targetPath = babylonAnimationPaths[targetPathIndex];
+            }
+            // Determine animation type
+            var animationType = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_MATRIX;
+            if (!isBone) {
+                if (targetPath === "rotationQuaternion") {
+                    animationType = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_QUATERNION;
+                    targetNode.rotationQuaternion = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion();
+                }
+                else {
+                    animationType = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_VECTOR3;
+                }
+            }
+            // Create animation and key frames
+            var babylonAnimation = null;
+            var keys = [];
+            var arrayOffset = 0;
+            var modifyKey = false;
+            if (isBone && lastAnimation && lastAnimation.getKeys().length === bufferInput.length) {
+                babylonAnimation = lastAnimation;
+                modifyKey = true;
+            }
+            if (!modifyKey) {
+                gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+                babylonAnimation = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONLOOPMODE_CYCLE);
+                gltfRuntime.scene._blockEntityCollection = false;
+            }
+            // For each frame
+            for (var j = 0; j < bufferInput.length; j++) {
+                var value = null;
+                if (targetPath === "rotationQuaternion") {
+                    // VEC4
+                    value = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
+                    arrayOffset += 4;
+                }
+                else {
+                    // Position and scaling are VEC3
+                    value = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
+                    arrayOffset += 3;
+                }
+                if (isBone) {
+                    var bone = targetNode;
+                    var translation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero();
+                    var rotationQuaternion = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion();
+                    var scaling = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero();
+                    // Warning on decompose
+                    var mat = bone.getBaseMatrix();
+                    if (modifyKey && lastAnimation) {
+                        mat = lastAnimation.getKeys()[j].value;
+                    }
+                    mat.decompose(scaling, rotationQuaternion, translation);
+                    if (targetPath === "position") {
+                        translation = value;
+                    }
+                    else if (targetPath === "rotationQuaternion") {
+                        rotationQuaternion = value;
+                    }
+                    else {
+                        scaling = value;
+                    }
+                    value = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Compose(scaling, rotationQuaternion, translation);
+                }
+                if (!modifyKey) {
+                    keys.push({
+                        frame: bufferInput[j],
+                        value: value,
+                    });
+                }
+                else if (lastAnimation) {
+                    lastAnimation.getKeys()[j].value = value;
+                }
+            }
+            // Finish
+            if (!modifyKey && babylonAnimation) {
+                babylonAnimation.setKeys(keys);
+                targetNode.animations.push(babylonAnimation);
+            }
+            lastAnimation = babylonAnimation;
+            gltfRuntime.scene.stopAnimation(targetNode);
+            gltfRuntime.scene.beginAnimation(targetNode, 0, bufferInput[bufferInput.length - 1], true, 1.0);
+        }
+    }
+};
+/**
+ * Returns the bones transformation matrix
+ * @param node
+ */
+var configureBoneTransformation = function (node) {
+    var mat = null;
+    if (node.translation || node.rotation || node.scale) {
+        var scale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.scale || [1, 1, 1]);
+        var rotation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(node.rotation || [0, 0, 0, 1]);
+        var position = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.translation || [0, 0, 0]);
+        mat = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Compose(scale, rotation, position);
+    }
+    else {
+        mat = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.FromArray(node.matrix);
+    }
+    return mat;
+};
+/**
+ * Returns the parent bone
+ * @param gltfRuntime
+ * @param skins
+ * @param jointName
+ * @param newSkeleton
+ */
+var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
+    // Try to find
+    for (var i = 0; i < newSkeleton.bones.length; i++) {
+        if (newSkeleton.bones[i].name === jointName) {
+            return newSkeleton.bones[i];
+        }
+    }
+    // Not found, search in gltf nodes
+    var nodes = gltfRuntime.nodes;
+    for (var nde in nodes) {
+        var node = nodes[nde];
+        if (!node.jointName) {
+            continue;
+        }
+        var children = node.children;
+        for (var i = 0; i < children.length; i++) {
+            var child = gltfRuntime.nodes[children[i]];
+            if (!child.jointName) {
+                continue;
+            }
+            if (child.jointName === jointName) {
+                var mat = configureBoneTransformation(node);
+                var bone = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Bone(node.name || "", newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
+                bone.id = nde;
+                return bone;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Returns the appropriate root node
+ * @param nodesToRoot
+ * @param id
+ */
+var getNodeToRoot = function (nodesToRoot, id) {
+    for (var i = 0; i < nodesToRoot.length; i++) {
+        var nodeToRoot = nodesToRoot[i];
+        for (var j = 0; j < nodeToRoot.node.children.length; j++) {
+            var child = nodeToRoot.node.children[j];
+            if (child === id) {
+                return nodeToRoot.bone;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Returns the node with the joint name
+ * @param gltfRuntime
+ * @param jointName
+ */
+var getJointNode = function (gltfRuntime, jointName) {
+    var nodes = gltfRuntime.nodes;
+    var node = nodes[jointName];
+    if (node) {
+        return {
+            node: node,
+            id: jointName,
+        };
+    }
+    for (var nde in nodes) {
+        node = nodes[nde];
+        if (node.jointName === jointName) {
+            return {
+                node: node,
+                id: nde,
+            };
+        }
+    }
+    return null;
+};
+/**
+ * Checks if a nodes is in joints
+ * @param skins
+ * @param id
+ */
+var nodeIsInJoints = function (skins, id) {
+    for (var i = 0; i < skins.jointNames.length; i++) {
+        if (skins.jointNames[i] === id) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Fills the nodes to root for bones and builds hierarchy
+ * @param gltfRuntime
+ * @param newSkeleton
+ * @param skins
+ * @param nodesToRoot
+ */
+var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
+    // Creates nodes for root
+    for (var nde in gltfRuntime.nodes) {
+        var node = gltfRuntime.nodes[nde];
+        var id = nde;
+        if (!node.jointName || nodeIsInJoints(skins, node.jointName)) {
+            continue;
+        }
+        // Create node to root bone
+        var mat = configureBoneTransformation(node);
+        var bone = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Bone(node.name || "", newSkeleton, null, mat);
+        bone.id = id;
+        nodesToRoot.push({ bone: bone, node: node, id: id });
+    }
+    // Parenting
+    for (var i = 0; i < nodesToRoot.length; i++) {
+        var nodeToRoot = nodesToRoot[i];
+        var children = nodeToRoot.node.children;
+        for (var j = 0; j < children.length; j++) {
+            var child = null;
+            for (var k = 0; k < nodesToRoot.length; k++) {
+                if (nodesToRoot[k].id === children[j]) {
+                    child = nodesToRoot[k];
+                    break;
+                }
+            }
+            if (child) {
+                child.bone._parent = nodeToRoot.bone;
+                nodeToRoot.bone.children.push(child.bone);
+            }
+        }
+    }
+};
+/**
+ * Imports a skeleton
+ * @param gltfRuntime
+ * @param skins
+ * @param mesh
+ * @param newSkeleton
+ */
+var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
+    if (!newSkeleton) {
+        newSkeleton = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Skeleton(skins.name || "", "", gltfRuntime.scene);
+    }
+    if (!skins.babylonSkeleton) {
+        return newSkeleton;
+    }
+    // Find the root bones
+    var nodesToRoot = [];
+    var nodesToRootToAdd = [];
+    getNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
+    newSkeleton.bones = [];
+    // Joints
+    for (var i = 0; i < skins.jointNames.length; i++) {
+        var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+        if (!jointNode) {
+            continue;
+        }
+        var node = jointNode.node;
+        if (!node) {
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Joint named " + skins.jointNames[i] + " does not exist");
+            continue;
+        }
+        var id = jointNode.id;
+        // Optimize, if the bone already exists...
+        var existingBone = gltfRuntime.scene.getBoneById(id);
+        if (existingBone) {
+            newSkeleton.bones.push(existingBone);
+            continue;
+        }
+        // Search for parent bone
+        var foundBone = false;
+        var parentBone = null;
+        for (var j = 0; j < i; j++) {
+            var jointNode_1 = getJointNode(gltfRuntime, skins.jointNames[j]);
+            if (!jointNode_1) {
+                continue;
+            }
+            var joint = jointNode_1.node;
+            if (!joint) {
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
+                continue;
+            }
+            var children = joint.children;
+            if (!children) {
+                continue;
+            }
+            foundBone = false;
+            for (var k = 0; k < children.length; k++) {
+                if (children[k] === id) {
+                    parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
+                    foundBone = true;
+                    break;
+                }
+            }
+            if (foundBone) {
+                break;
+            }
+        }
+        // Create bone
+        var mat = configureBoneTransformation(node);
+        if (!parentBone && nodesToRoot.length > 0) {
+            parentBone = getNodeToRoot(nodesToRoot, id);
+            if (parentBone) {
+                if (nodesToRootToAdd.indexOf(parentBone) === -1) {
+                    nodesToRootToAdd.push(parentBone);
+                }
+            }
+        }
+        var bone = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Bone(node.jointName || "", newSkeleton, parentBone, mat);
+        bone.id = id;
+    }
+    // Polish
+    var bones = newSkeleton.bones;
+    newSkeleton.bones = [];
+    for (var i = 0; i < skins.jointNames.length; i++) {
+        var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+        if (!jointNode) {
+            continue;
+        }
+        for (var j = 0; j < bones.length; j++) {
+            if (bones[j].id === jointNode.id) {
+                newSkeleton.bones.push(bones[j]);
+                break;
+            }
+        }
+    }
+    newSkeleton.prepare();
+    // Finish
+    for (var i = 0; i < nodesToRootToAdd.length; i++) {
+        newSkeleton.bones.push(nodesToRootToAdd[i]);
+    }
+    return newSkeleton;
+};
+/**
+ * Imports a mesh and its geometries
+ * @param gltfRuntime
+ * @param node
+ * @param meshes
+ * @param id
+ * @param newMesh
+ */
+var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
+    if (!newMesh) {
+        gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+        newMesh = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh(node.name || "", gltfRuntime.scene);
+        newMesh._parentContainer = gltfRuntime.assetContainer;
+        gltfRuntime.scene._blockEntityCollection = false;
+        newMesh.id = id;
+    }
+    if (!node.babylonNode) {
+        return newMesh;
+    }
+    var subMaterials = [];
+    var vertexData = null;
+    var verticesStarts = new Array();
+    var verticesCounts = new Array();
+    var indexStarts = new Array();
+    var indexCounts = new Array();
+    for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
+        var meshId = meshes[meshIndex];
+        var mesh = gltfRuntime.meshes[meshId];
+        if (!mesh) {
+            continue;
+        }
+        // Positions, normals and UVs
+        for (var i = 0; i < mesh.primitives.length; i++) {
+            // Temporary vertex data
+            var tempVertexData = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexData();
+            var primitive = mesh.primitives[i];
+            if (primitive.mode !== 4) {
+                // continue;
+            }
+            var attributes = primitive.attributes;
+            var accessor = null;
+            var buffer = null;
+            // Set positions, normal and uvs
+            for (var semantic in attributes) {
+                // Link accessor and buffer view
+                accessor = gltfRuntime.accessors[attributes[semantic]];
+                buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
+                if (semantic === "NORMAL") {
+                    tempVertexData.normals = new Float32Array(buffer.length);
+                    tempVertexData.normals.set(buffer);
+                }
+                else if (semantic === "POSITION") {
+                    if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.GLTFFileLoader.HomogeneousCoordinates) {
+                        tempVertexData.positions = new Float32Array(buffer.length - buffer.length / 4);
+                        for (var j = 0; j < buffer.length; j += 4) {
+                            tempVertexData.positions[j] = buffer[j];
+                            tempVertexData.positions[j + 1] = buffer[j + 1];
+                            tempVertexData.positions[j + 2] = buffer[j + 2];
+                        }
+                    }
+                    else {
+                        tempVertexData.positions = new Float32Array(buffer.length);
+                        tempVertexData.positions.set(buffer);
+                    }
+                    verticesCounts.push(tempVertexData.positions.length);
+                }
+                else if (semantic.indexOf("TEXCOORD_") !== -1) {
+                    var channel = Number(semantic.split("_")[1]);
+                    var uvKind = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.UVKind + (channel === 0 ? "" : channel + 1);
+                    var uvs = new Float32Array(buffer.length);
+                    uvs.set(buffer);
+                    normalizeUVs(uvs);
+                    tempVertexData.set(uvs, uvKind);
+                }
+                else if (semantic === "JOINT") {
+                    tempVertexData.matricesIndices = new Float32Array(buffer.length);
+                    tempVertexData.matricesIndices.set(buffer);
+                }
+                else if (semantic === "WEIGHT") {
+                    tempVertexData.matricesWeights = new Float32Array(buffer.length);
+                    tempVertexData.matricesWeights.set(buffer);
+                }
+                else if (semantic === "COLOR") {
+                    tempVertexData.colors = new Float32Array(buffer.length);
+                    tempVertexData.colors.set(buffer);
+                }
+            }
+            // Indices
+            accessor = gltfRuntime.accessors[primitive.indices];
+            if (accessor) {
+                buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
+                tempVertexData.indices = new Int32Array(buffer.length);
+                tempVertexData.indices.set(buffer);
+                indexCounts.push(tempVertexData.indices.length);
+            }
+            else {
+                // Set indices on the fly
+                var indices = [];
+                for (var j = 0; j < tempVertexData.positions.length / 3; j++) {
+                    indices.push(j);
+                }
+                tempVertexData.indices = new Int32Array(indices);
+                indexCounts.push(tempVertexData.indices.length);
+            }
+            if (!vertexData) {
+                vertexData = tempVertexData;
+            }
+            else {
+                vertexData.merge(tempVertexData);
+            }
+            // Sub material
+            var material_1 = gltfRuntime.scene.getMaterialById(primitive.material);
+            subMaterials.push(material_1 === null ? _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material_1);
+            // Update vertices start and index start
+            verticesStarts.push(verticesStarts.length === 0 ? 0 : verticesStarts[verticesStarts.length - 1] + verticesCounts[verticesCounts.length - 2]);
+            indexStarts.push(indexStarts.length === 0 ? 0 : indexStarts[indexStarts.length - 1] + indexCounts[indexCounts.length - 2]);
+        }
+    }
+    var material;
+    gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+    if (subMaterials.length > 1) {
+        material = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.MultiMaterial("multimat" + id, gltfRuntime.scene);
+        material.subMaterials = subMaterials;
+    }
+    else {
+        material = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.StandardMaterial("multimat" + id, gltfRuntime.scene);
+    }
+    if (subMaterials.length === 1) {
+        material = subMaterials[0];
+    }
+    material._parentContainer = gltfRuntime.assetContainer;
+    if (!newMesh.material) {
+        newMesh.material = material;
+    }
+    // Apply geometry
+    new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
+    newMesh.computeWorldMatrix(true);
+    gltfRuntime.scene._blockEntityCollection = false;
+    // Apply submeshes
+    newMesh.subMeshes = [];
+    var index = 0;
+    for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
+        var meshId = meshes[meshIndex];
+        var mesh = gltfRuntime.meshes[meshId];
+        if (!mesh) {
+            continue;
+        }
+        for (var i = 0; i < mesh.primitives.length; i++) {
+            if (mesh.primitives[i].mode !== 4) {
+                //continue;
+            }
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.SubMesh.AddToMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
+            index++;
+        }
+    }
+    // Finish
+    return newMesh;
+};
+/**
+ * Configure node transformation from position, rotation and scaling
+ * @param newNode
+ * @param position
+ * @param rotation
+ * @param scaling
+ */
+var configureNode = function (newNode, position, rotation, scaling) {
+    if (newNode.position) {
+        newNode.position = position;
+    }
+    if (newNode.rotationQuaternion || newNode.rotation) {
+        newNode.rotationQuaternion = rotation;
+    }
+    if (newNode.scaling) {
+        newNode.scaling = scaling;
+    }
+};
+/**
+ * Configures node from transformation matrix
+ * @param newNode
+ * @param node
+ */
+var configureNodeFromMatrix = function (newNode, node) {
+    if (node.matrix) {
+        var position = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3(0, 0, 0);
+        var rotation = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion();
+        var scaling = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3(0, 0, 0);
+        var mat = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.FromArray(node.matrix);
+        mat.decompose(scaling, rotation, position);
+        configureNode(newNode, position, rotation, scaling);
+    }
+    else if (node.translation && node.rotation && node.scale) {
+        configureNode(newNode, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.translation), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(node.rotation), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.scale));
+    }
+    newNode.computeWorldMatrix(true);
+};
+/**
+ * Imports a node
+ * @param gltfRuntime
+ * @param node
+ * @param id
+ */
+var importNode = function (gltfRuntime, node, id) {
+    var lastNode = null;
+    if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
+        if (gltfRuntime.importMeshesNames && gltfRuntime.importMeshesNames.length > 0 && gltfRuntime.importMeshesNames.indexOf(node.name || "") === -1) {
+            return null;
+        }
+    }
+    // Meshes
+    if (node.skin) {
+        if (node.meshes) {
+            var skin = gltfRuntime.skins[node.skin];
+            var newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
+            newMesh.skeleton = gltfRuntime.scene.getLastSkeletonById(node.skin);
+            if (newMesh.skeleton === null) {
+                newMesh.skeleton = importSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton);
+                if (!skin.babylonSkeleton) {
+                    skin.babylonSkeleton = newMesh.skeleton;
+                }
+            }
+            lastNode = newMesh;
+        }
+    }
+    else if (node.meshes) {
+        /**
+         * Improve meshes property
+         */
+        var newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
+        lastNode = newMesh;
+    }
+    // Lights
+    else if (node.light && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
+        var light = gltfRuntime.lights[node.light];
+        if (light) {
+            if (light.type === "ambient") {
+                var ambienLight = light[light.type];
+                var hemiLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.HemisphericLight(node.light, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene);
+                hemiLight.name = node.name || "";
+                if (ambienLight.color) {
+                    hemiLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(ambienLight.color);
+                }
+                lastNode = hemiLight;
+            }
+            else if (light.type === "directional") {
+                var directionalLight = light[light.type];
+                var dirLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.DirectionalLight(node.light, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene);
+                dirLight.name = node.name || "";
+                if (directionalLight.color) {
+                    dirLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(directionalLight.color);
+                }
+                lastNode = dirLight;
+            }
+            else if (light.type === "point") {
+                var pointLight = light[light.type];
+                var ptLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.PointLight(node.light, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene);
+                ptLight.name = node.name || "";
+                if (pointLight.color) {
+                    ptLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(pointLight.color);
+                }
+                lastNode = ptLight;
+            }
+            else if (light.type === "spot") {
+                var spotLight = light[light.type];
+                var spLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.SpotLight(node.light, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), 0, 0, gltfRuntime.scene);
+                spLight.name = node.name || "";
+                if (spotLight.color) {
+                    spLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(spotLight.color);
+                }
+                if (spotLight.fallOfAngle) {
+                    spLight.angle = spotLight.fallOfAngle;
+                }
+                if (spotLight.fallOffExponent) {
+                    spLight.exponent = spotLight.fallOffExponent;
+                }
+                lastNode = spLight;
+            }
+        }
+    }
+    // Cameras
+    else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
+        var camera = gltfRuntime.cameras[node.camera];
+        if (camera) {
+            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+            if (camera.type === "orthographic") {
+                var orthoCamera = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.FreeCamera(node.camera, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene, false);
+                orthoCamera.name = node.name || "";
+                orthoCamera.mode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Camera.ORTHOGRAPHIC_CAMERA;
+                orthoCamera.attachControl();
+                lastNode = orthoCamera;
+                orthoCamera._parentContainer = gltfRuntime.assetContainer;
+            }
+            else if (camera.type === "perspective") {
+                var perspectiveCamera = camera[camera.type];
+                var persCamera = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.FreeCamera(node.camera, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene, false);
+                persCamera.name = node.name || "";
+                persCamera.attachControl();
+                if (!perspectiveCamera.aspectRatio) {
+                    perspectiveCamera.aspectRatio = gltfRuntime.scene.getEngine().getRenderWidth() / gltfRuntime.scene.getEngine().getRenderHeight();
+                }
+                if (perspectiveCamera.znear && perspectiveCamera.zfar) {
+                    persCamera.maxZ = perspectiveCamera.zfar;
+                    persCamera.minZ = perspectiveCamera.znear;
+                }
+                lastNode = persCamera;
+                persCamera._parentContainer = gltfRuntime.assetContainer;
+            }
+            gltfRuntime.scene._blockEntityCollection = false;
+        }
+    }
+    // Empty node
+    if (!node.jointName) {
+        if (node.babylonNode) {
+            return node.babylonNode;
+        }
+        else if (lastNode === null) {
+            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+            var dummy = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh(node.name || "", gltfRuntime.scene);
+            dummy._parentContainer = gltfRuntime.assetContainer;
+            gltfRuntime.scene._blockEntityCollection = false;
+            node.babylonNode = dummy;
+            lastNode = dummy;
+        }
+    }
+    if (lastNode !== null) {
+        if (node.matrix && lastNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh) {
+            configureNodeFromMatrix(lastNode, node);
+        }
+        else {
+            var translation = node.translation || [0, 0, 0];
+            var rotation = node.rotation || [0, 0, 0, 1];
+            var scale = node.scale || [1, 1, 1];
+            configureNode(lastNode, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(translation), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(rotation), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(scale));
+        }
+        lastNode.updateCache(true);
+        node.babylonNode = lastNode;
+    }
+    return lastNode;
+};
+/**
+ * Traverses nodes and creates them
+ * @param gltfRuntime
+ * @param id
+ * @param parent
+ * @param meshIncluded
+ */
+var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
+    if (meshIncluded === void 0) { meshIncluded = false; }
+    var node = gltfRuntime.nodes[id];
+    var newNode = null;
+    if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
+        if (gltfRuntime.importMeshesNames.indexOf(node.name || "") !== -1 || gltfRuntime.importMeshesNames.length === 0) {
+            meshIncluded = true;
+        }
+        else {
+            meshIncluded = false;
+        }
+    }
+    else {
+        meshIncluded = true;
+    }
+    if (!node.jointName && meshIncluded) {
+        newNode = importNode(gltfRuntime, node, id);
+        if (newNode !== null) {
+            newNode.id = id;
+            newNode.parent = parent;
+        }
+    }
+    if (node.children) {
+        for (var i = 0; i < node.children.length; i++) {
+            traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
+        }
+    }
+};
+/**
+ * do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
+ * @param gltfRuntime
+ */
+var postLoad = function (gltfRuntime) {
+    // Nodes
+    var currentScene = gltfRuntime.currentScene;
+    if (currentScene) {
+        for (var i = 0; i < currentScene.nodes.length; i++) {
+            traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+        }
+    }
+    else {
+        for (var thing in gltfRuntime.scenes) {
+            currentScene = gltfRuntime.scenes[thing];
+            for (var i = 0; i < currentScene.nodes.length; i++) {
+                traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+            }
+        }
+    }
+    // Set animations
+    loadAnimations(gltfRuntime);
+    for (var i = 0; i < gltfRuntime.scene.skeletons.length; i++) {
+        var skeleton = gltfRuntime.scene.skeletons[i];
+        gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
+    }
+};
+/**
+ * onBind shaderrs callback to set uniforms and matrices
+ * @param mesh
+ * @param gltfRuntime
+ * @param unTreatedUniforms
+ * @param shaderMaterial
+ * @param technique
+ * @param material
+ * @param onSuccess
+ */
+var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) {
+    var materialValues = material.values || technique.parameters;
+    for (var unif in unTreatedUniforms) {
+        var uniform = unTreatedUniforms[unif];
+        var type = uniform.type;
+        if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT2 || type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT3 || type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT4) {
+            if (uniform.semantic && !uniform.source && !uniform.node) {
+                _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetMatrix(gltfRuntime.scene, mesh, uniform, unif, shaderMaterial.getEffect());
+            }
+            else if (uniform.semantic && (uniform.source || uniform.node)) {
+                var source = gltfRuntime.scene.getNodeByName(uniform.source || uniform.node || "");
+                if (source === null) {
+                    source = gltfRuntime.scene.getNodeById(uniform.source || uniform.node || "");
+                }
+                if (source === null) {
+                    continue;
+                }
+                _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
+            }
+        }
+        else {
+            var value = materialValues[technique.uniforms[unif]];
+            if (!value) {
+                continue;
+            }
+            if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.SAMPLER_2D) {
+                var texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
+                if (texture === null || texture === undefined) {
+                    continue;
+                }
+                shaderMaterial.getEffect().setTexture(unif, texture);
+            }
+            else {
+                _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetUniform(shaderMaterial.getEffect(), unif, value, type);
+            }
+        }
+    }
+    onSuccess(shaderMaterial);
+};
+/**
+ * Prepare uniforms to send the only one time
+ * Loads the appropriate textures
+ * @param gltfRuntime
+ * @param shaderMaterial
+ * @param technique
+ * @param material
+ */
+var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
+    var materialValues = material.values || technique.parameters;
+    var techniqueUniforms = technique.uniforms;
+    var _loop_1 = function (unif) {
+        var uniform = unTreatedUniforms[unif];
+        var type = uniform.type;
+        var value = materialValues[techniqueUniforms[unif]];
+        if (value === undefined) {
+            // In case the value is the same for all materials
+            value = uniform.value;
+        }
+        if (!value) {
+            return "continue";
+        }
+        var onLoadTexture = function (uniformName) {
+            return function (texture) {
+                if (uniform.value && uniformName) {
+                    // Static uniform
+                    shaderMaterial.setTexture(uniformName, texture);
+                    delete unTreatedUniforms[uniformName];
+                }
+            };
+        };
+        // Texture (sampler2D)
+        if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.SAMPLER_2D) {
+            GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
+        }
+        // Others
+        else {
+            if (uniform.value && _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) {
+                // Static uniform
+                delete unTreatedUniforms[unif];
+            }
+        }
+    };
+    /**
+     * Prepare values here (not matrices)
+     */
+    for (var unif in unTreatedUniforms) {
+        _loop_1(unif);
+    }
+};
+/**
+ * Shader compilation failed
+ * @param program
+ * @param shaderMaterial
+ * @param onError
+ */
+var onShaderCompileError = function (program, shaderMaterial, onError) {
+    return function (effect, error) {
+        shaderMaterial.dispose(true);
+        onError("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
+    };
+};
+/**
+ * Shader compilation success
+ * @param gltfRuntime
+ * @param shaderMaterial
+ * @param technique
+ * @param material
+ * @param unTreatedUniforms
+ * @param onSuccess
+ */
+var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) {
+    return function (_) {
+        prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
+        shaderMaterial.onBind = function (mesh) {
+            onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
+        };
+    };
+};
+/**
+ * Returns the appropriate uniform if already handled by babylon
+ * @param tokenizer
+ * @param technique
+ */
+var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
+    for (var unif in technique.uniforms) {
+        var uniform = technique.uniforms[unif];
+        var uniformParameter = technique.parameters[uniform];
+        if (tokenizer.currentIdentifier === unif) {
+            if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) {
+                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
+                if (transformIndex !== -1) {
+                    delete unTreatedUniforms[unif];
+                    return babylonTransforms[transformIndex];
+                }
+            }
+        }
+    }
+    return tokenizer.currentIdentifier;
+};
+/**
+ * All shaders loaded. Create materials one by one
+ * @param gltfRuntime
+ */
+var importMaterials = function (gltfRuntime) {
+    // Create materials
+    for (var mat in gltfRuntime.materials) {
+        GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function () { }, function () { });
+    }
+};
+/**
+ * Implementation of the base glTF spec
+ * @hidden
+ */
+var GLTFLoaderBase = /** @class */ (function () {
+    function GLTFLoaderBase() {
+    }
+    GLTFLoaderBase.CreateRuntime = function (parsedData, scene, rootUrl) {
+        var gltfRuntime = {
+            extensions: {},
+            accessors: {},
+            buffers: {},
+            bufferViews: {},
+            meshes: {},
+            lights: {},
+            cameras: {},
+            nodes: {},
+            images: {},
+            textures: {},
+            shaders: {},
+            programs: {},
+            samplers: {},
+            techniques: {},
+            materials: {},
+            animations: {},
+            skins: {},
+            extensionsUsed: [],
+            scenes: {},
+            buffersCount: 0,
+            shaderscount: 0,
+            scene: scene,
+            rootUrl: rootUrl,
+            loadedBufferCount: 0,
+            loadedBufferViews: {},
+            loadedShaderCount: 0,
+            importOnlyMeshes: false,
+            dummyNodes: [],
+            assetContainer: null,
+        };
+        // Parse
+        if (parsedData.extensions) {
+            parseObject(parsedData.extensions, "extensions", gltfRuntime);
+        }
+        if (parsedData.extensionsUsed) {
+            parseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime);
+        }
+        if (parsedData.buffers) {
+            parseBuffers(parsedData.buffers, gltfRuntime);
+        }
+        if (parsedData.bufferViews) {
+            parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
+        }
+        if (parsedData.accessors) {
+            parseObject(parsedData.accessors, "accessors", gltfRuntime);
+        }
+        if (parsedData.meshes) {
+            parseObject(parsedData.meshes, "meshes", gltfRuntime);
+        }
+        if (parsedData.lights) {
+            parseObject(parsedData.lights, "lights", gltfRuntime);
+        }
+        if (parsedData.cameras) {
+            parseObject(parsedData.cameras, "cameras", gltfRuntime);
+        }
+        if (parsedData.nodes) {
+            parseObject(parsedData.nodes, "nodes", gltfRuntime);
+        }
+        if (parsedData.images) {
+            parseObject(parsedData.images, "images", gltfRuntime);
+        }
+        if (parsedData.textures) {
+            parseObject(parsedData.textures, "textures", gltfRuntime);
+        }
+        if (parsedData.shaders) {
+            parseShaders(parsedData.shaders, gltfRuntime);
+        }
+        if (parsedData.programs) {
+            parseObject(parsedData.programs, "programs", gltfRuntime);
+        }
+        if (parsedData.samplers) {
+            parseObject(parsedData.samplers, "samplers", gltfRuntime);
+        }
+        if (parsedData.techniques) {
+            parseObject(parsedData.techniques, "techniques", gltfRuntime);
+        }
+        if (parsedData.materials) {
+            parseObject(parsedData.materials, "materials", gltfRuntime);
+        }
+        if (parsedData.animations) {
+            parseObject(parsedData.animations, "animations", gltfRuntime);
+        }
+        if (parsedData.skins) {
+            parseObject(parsedData.skins, "skins", gltfRuntime);
+        }
+        if (parsedData.scenes) {
+            gltfRuntime.scenes = parsedData.scenes;
+        }
+        if (parsedData.scene && parsedData.scenes) {
+            gltfRuntime.currentScene = parsedData.scenes[parsedData.scene];
+        }
+        return gltfRuntime;
+    };
+    GLTFLoaderBase.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
+        var buffer = gltfRuntime.buffers[id];
+        if (core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.IsBase64(buffer.uri)) {
+            setTimeout(function () { return onSuccess(new Uint8Array(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.DecodeBase64(buffer.uri))); });
+        }
+        else {
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.LoadFile(gltfRuntime.rootUrl + buffer.uri, function (data) { return onSuccess(new Uint8Array(data)); }, onProgress, undefined, true, function (request) {
+                if (request) {
+                    onError(request.status + " " + request.statusText);
+                }
+            });
+        }
+    };
+    GLTFLoaderBase.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var texture = gltfRuntime.textures[id];
+        if (!texture || !texture.source) {
+            onError("");
+            return;
+        }
+        if (texture.babylonTexture) {
+            onSuccess(null);
+            return;
+        }
+        var source = gltfRuntime.images[texture.source];
+        if (core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.IsBase64(source.uri)) {
+            setTimeout(function () { return onSuccess(new Uint8Array(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.DecodeBase64(source.uri))); });
+        }
+        else {
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.LoadFile(gltfRuntime.rootUrl + source.uri, function (data) { return onSuccess(new Uint8Array(data)); }, undefined, undefined, true, function (request) {
+                if (request) {
+                    onError(request.status + " " + request.statusText);
+                }
+            });
+        }
+    };
+    GLTFLoaderBase.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess) {
+        var texture = gltfRuntime.textures[id];
+        if (texture.babylonTexture) {
+            onSuccess(texture.babylonTexture);
+            return;
+        }
+        var sampler = gltfRuntime.samplers[texture.sampler];
+        var createMipMaps = sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.NEAREST_MIPMAP_NEAREST ||
+            sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.NEAREST_MIPMAP_LINEAR ||
+            sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.LINEAR_MIPMAP_NEAREST ||
+            sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.LINEAR_MIPMAP_LINEAR;
+        var samplingMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.BILINEAR_SAMPLINGMODE;
+        var blob = buffer == null ? new Blob() : new Blob([buffer]);
+        var blobURL = URL.createObjectURL(blob);
+        var revokeBlobURL = function () { return URL.revokeObjectURL(blobURL); };
+        var newTexture = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture(blobURL, gltfRuntime.scene, !createMipMaps, true, samplingMode, revokeBlobURL, revokeBlobURL);
+        if (sampler.wrapS !== undefined) {
+            newTexture.wrapU = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetWrapMode(sampler.wrapS);
+        }
+        if (sampler.wrapT !== undefined) {
+            newTexture.wrapV = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetWrapMode(sampler.wrapT);
+        }
+        newTexture.name = id;
+        texture.babylonTexture = newTexture;
+        onSuccess(newTexture);
+    };
+    GLTFLoaderBase.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var shader = gltfRuntime.shaders[id];
+        if (core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.IsBase64(shader.uri)) {
+            var shaderString = atob(shader.uri.split(",")[1]);
+            if (onSuccess) {
+                onSuccess(shaderString);
+            }
+        }
+        else {
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, function (request) {
+                if (request && onError) {
+                    onError(request.status + " " + request.statusText);
+                }
+            });
+        }
+    };
+    GLTFLoaderBase.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var material = gltfRuntime.materials[id];
+        if (!material.technique) {
+            if (onError) {
+                onError("No technique found.");
+            }
+            return;
+        }
+        var technique = gltfRuntime.techniques[material.technique];
+        if (!technique) {
+            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+            var defaultMaterial = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.StandardMaterial(id, gltfRuntime.scene);
+            defaultMaterial._parentContainer = gltfRuntime.assetContainer;
+            gltfRuntime.scene._blockEntityCollection = false;
+            defaultMaterial.diffuseColor = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3(0.5, 0.5, 0.5);
+            defaultMaterial.sideOrientation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.CounterClockWiseSideOrientation;
+            onSuccess(defaultMaterial);
+            return;
+        }
+        var program = gltfRuntime.programs[technique.program];
+        var states = technique.states;
+        var vertexShader = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore[program.vertexShader + "VertexShader"];
+        var pixelShader = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore[program.fragmentShader + "PixelShader"];
+        var newVertexShader = "";
+        var newPixelShader = "";
+        var vertexTokenizer = new Tokenizer(vertexShader);
+        var pixelTokenizer = new Tokenizer(pixelShader);
+        var unTreatedUniforms = {};
+        var uniforms = [];
+        var attributes = [];
+        var samplers = [];
+        // Fill uniform, sampler2D and attributes
+        for (var unif in technique.uniforms) {
+            var uniform = technique.uniforms[unif];
+            var uniformParameter = technique.parameters[uniform];
+            unTreatedUniforms[unif] = uniformParameter;
+            if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
+                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
+                if (transformIndex !== -1) {
+                    uniforms.push(babylonTransforms[transformIndex]);
+                    delete unTreatedUniforms[unif];
+                }
+                else {
+                    uniforms.push(unif);
+                }
+            }
+            else if (uniformParameter.type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.SAMPLER_2D) {
+                samplers.push(unif);
+            }
+            else {
+                uniforms.push(unif);
+            }
+        }
+        for (var attr in technique.attributes) {
+            var attribute = technique.attributes[attr];
+            var attributeParameter = technique.parameters[attribute];
+            if (attributeParameter.semantic) {
+                var name_1 = getAttribute(attributeParameter);
+                if (name_1) {
+                    attributes.push(name_1);
+                }
+            }
+        }
+        // Configure vertex shader
+        while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) {
+            var tokenType = vertexTokenizer.currentToken;
+            if (tokenType !== ETokenType.IDENTIFIER) {
+                newVertexShader += vertexTokenizer.currentString;
+                continue;
+            }
+            var foundAttribute = false;
+            for (var attr in technique.attributes) {
+                var attribute = technique.attributes[attr];
+                var attributeParameter = technique.parameters[attribute];
+                if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
+                    newVertexShader += getAttribute(attributeParameter);
+                    foundAttribute = true;
+                    break;
+                }
+            }
+            if (foundAttribute) {
+                continue;
+            }
+            newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
+        }
+        // Configure pixel shader
+        while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
+            var tokenType = pixelTokenizer.currentToken;
+            if (tokenType !== ETokenType.IDENTIFIER) {
+                newPixelShader += pixelTokenizer.currentString;
+                continue;
+            }
+            newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
+        }
+        // Create shader material
+        var shaderPath = {
+            vertex: program.vertexShader + id,
+            fragment: program.fragmentShader + id,
+        };
+        var options = {
+            attributes: attributes,
+            uniforms: uniforms,
+            samplers: samplers,
+            needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1,
+        };
+        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
+        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
+        var shaderMaterial = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.ShaderMaterial(id, gltfRuntime.scene, shaderPath, options);
+        shaderMaterial.onError = onShaderCompileError(program, shaderMaterial, onError);
+        shaderMaterial.onCompiled = onShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess);
+        shaderMaterial.sideOrientation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.CounterClockWiseSideOrientation;
+        if (states && states.functions) {
+            var functions = states.functions;
+            if (functions.cullFace && functions.cullFace[0] !== _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ECullingType.BACK) {
+                shaderMaterial.backFaceCulling = false;
+            }
+            var blendFunc = functions.blendFuncSeparate;
+            if (blendFunc) {
+                if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.SRC_ALPHA &&
+                    blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE_MINUS_SRC_ALPHA &&
+                    blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE) {
+                    shaderMaterial.alphaMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Constants.ALPHA_COMBINE;
+                }
+                else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ZERO &&
+                    blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE) {
+                    shaderMaterial.alphaMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Constants.ALPHA_ONEONE;
+                }
+                else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.SRC_ALPHA &&
+                    blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ZERO &&
+                    blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE) {
+                    shaderMaterial.alphaMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Constants.ALPHA_ADD;
+                }
+                else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ZERO &&
+                    blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE_MINUS_SRC_COLOR &&
+                    blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE) {
+                    shaderMaterial.alphaMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Constants.ALPHA_SUBTRACT;
+                }
+                else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.DST_COLOR &&
+                    blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ZERO &&
+                    blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE) {
+                    shaderMaterial.alphaMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Constants.ALPHA_MULTIPLY;
+                }
+                else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.SRC_ALPHA &&
+                    blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE_MINUS_SRC_COLOR &&
+                    blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE &&
+                    blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EBlendingFunction.ONE) {
+                    shaderMaterial.alphaMode = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Constants.ALPHA_MAXIMIZED;
+                }
+            }
+        }
+    };
+    return GLTFLoaderBase;
+}());
+
+/**
+ * glTF V1 Loader
+ * @hidden
+ */
+var GLTFLoader = /** @class */ (function () {
+    function GLTFLoader() {
+    }
+    GLTFLoader.RegisterExtension = function (extension) {
+        if (GLTFLoader.Extensions[extension.name]) {
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error('Tool with the same name "' + extension.name + '" already exists');
+            return;
+        }
+        GLTFLoader.Extensions[extension.name] = extension;
+    };
+    GLTFLoader.prototype.dispose = function () {
+        // do nothing
+    };
+    GLTFLoader.prototype._importMeshAsync = function (meshesNames, scene, data, rootUrl, assetContainer, onSuccess, onProgress, onError) {
+        var _this = this;
+        scene.useRightHandedSystem = true;
+        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
+            gltfRuntime.assetContainer = assetContainer;
+            gltfRuntime.importOnlyMeshes = true;
+            if (meshesNames === "") {
+                gltfRuntime.importMeshesNames = [];
+            }
+            else if (typeof meshesNames === "string") {
+                gltfRuntime.importMeshesNames = [meshesNames];
+            }
+            else if (meshesNames && !(meshesNames instanceof Array)) {
+                gltfRuntime.importMeshesNames = [meshesNames];
+            }
+            else {
+                gltfRuntime.importMeshesNames = [];
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Argument meshesNames must be of type string or string[]");
+            }
+            // Create nodes
+            _this._createNodes(gltfRuntime);
+            var meshes = new Array();
+            var skeletons = new Array();
+            // Fill arrays of meshes and skeletons
+            for (var nde in gltfRuntime.nodes) {
+                var node = gltfRuntime.nodes[nde];
+                if (node.babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.AbstractMesh) {
+                    meshes.push(node.babylonNode);
+                }
+            }
+            for (var skl in gltfRuntime.skins) {
+                var skin = gltfRuntime.skins[skl];
+                if (skin.babylonSkeleton instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Skeleton) {
+                    skeletons.push(skin.babylonSkeleton);
+                }
+            }
+            // Load buffers, shaders, materials, etc.
+            _this._loadBuffersAsync(gltfRuntime, function () {
+                _this._loadShadersAsync(gltfRuntime, function () {
+                    importMaterials(gltfRuntime);
+                    postLoad(gltfRuntime);
+                    if (!_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.GLTFFileLoader.IncrementalLoading && onSuccess) {
+                        onSuccess(meshes, skeletons);
+                    }
+                });
+            });
+            if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.GLTFFileLoader.IncrementalLoading && onSuccess) {
+                onSuccess(meshes, skeletons);
+            }
+        }, onError);
+        return true;
+    };
+    /**
+     * Imports one or more meshes from a loaded gltf file and adds them to the scene
+     * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
+     * @param scene the scene the meshes should be added to
+     * @param assetContainer defines the asset container to use (can be null)
+     * @param data gltf data containing information of the meshes in a loaded file
+     * @param rootUrl root url to load from
+     * @param onProgress event that fires when loading progress has occured
+     * @returns a promise containg the loaded meshes, particles, skeletons and animations
+     */
+    GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, assetContainer, data, rootUrl, onProgress) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this._importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, function (meshes, skeletons) {
+                resolve({
+                    meshes: meshes,
+                    particleSystems: [],
+                    skeletons: skeletons,
+                    animationGroups: [],
+                    lights: [],
+                    transformNodes: [],
+                    geometries: [],
+                });
+            }, onProgress, function (message) {
+                reject(new Error(message));
+            });
+        });
+    };
+    GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) {
+        var _this = this;
+        scene.useRightHandedSystem = true;
+        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
+            // Load runtime extensios
+            GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, function () {
+                // Create nodes
+                _this._createNodes(gltfRuntime);
+                // Load buffers, shaders, materials, etc.
+                _this._loadBuffersAsync(gltfRuntime, function () {
+                    _this._loadShadersAsync(gltfRuntime, function () {
+                        importMaterials(gltfRuntime);
+                        postLoad(gltfRuntime);
+                        if (!_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.GLTFFileLoader.IncrementalLoading) {
+                            onSuccess();
+                        }
+                    });
+                });
+                if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.GLTFFileLoader.IncrementalLoading) {
+                    onSuccess();
+                }
+            }, onError);
+        }, onError);
+    };
+    /**
+     * Imports all objects from a loaded gltf file and adds them to the scene
+     * @param scene the scene the objects should be added to
+     * @param data gltf data containing information of the meshes in a loaded file
+     * @param rootUrl root url to load from
+     * @param onProgress event that fires when loading progress has occured
+     * @returns a promise which completes when objects have been loaded to the scene
+     */
+    GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this._loadAsync(scene, data, rootUrl, function () {
+                resolve();
+            }, onProgress, function (message) {
+                reject(new Error(message));
+            });
+        });
+    };
+    GLTFLoader.prototype._loadShadersAsync = function (gltfRuntime, onload) {
+        var hasShaders = false;
+        var processShader = function (sha, shader) {
+            GLTFLoaderExtension.LoadShaderStringAsync(gltfRuntime, sha, function (shaderString) {
+                if (shaderString instanceof ArrayBuffer) {
+                    return;
+                }
+                gltfRuntime.loadedShaderCount++;
+                if (shaderString) {
+                    core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore[sha + (shader.type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EShaderType.VERTEX ? "VertexShader" : "PixelShader")] = shaderString;
+                }
+                if (gltfRuntime.loadedShaderCount === gltfRuntime.shaderscount) {
+                    onload();
+                }
+            }, function () {
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Error when loading shader program named " + sha + " located at " + shader.uri);
+            });
+        };
+        for (var sha in gltfRuntime.shaders) {
+            hasShaders = true;
+            var shader = gltfRuntime.shaders[sha];
+            if (shader) {
+                processShader.bind(this, sha, shader)();
+            }
+            else {
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("No shader named: " + sha);
+            }
+        }
+        if (!hasShaders) {
+            onload();
+        }
+    };
+    GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad) {
+        var hasBuffers = false;
+        var processBuffer = function (buf, buffer) {
+            GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
+                gltfRuntime.loadedBufferCount++;
+                if (bufferView) {
+                    if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) {
+                        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Buffer named " + buf + " is length " + bufferView.byteLength + ". Expected: " + buffer.byteLength); // Improve error message
+                    }
+                    gltfRuntime.loadedBufferViews[buf] = bufferView;
+                }
+                if (gltfRuntime.loadedBufferCount === gltfRuntime.buffersCount) {
+                    onLoad();
+                }
+            }, function () {
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Error when loading buffer named " + buf + " located at " + buffer.uri);
+            });
+        };
+        for (var buf in gltfRuntime.buffers) {
+            hasBuffers = true;
+            var buffer = gltfRuntime.buffers[buf];
+            if (buffer) {
+                processBuffer.bind(this, buf, buffer)();
+            }
+            else {
+                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("No buffer named: " + buf);
+            }
+        }
+        if (!hasBuffers) {
+            onLoad();
+        }
+    };
+    GLTFLoader.prototype._createNodes = function (gltfRuntime) {
+        var currentScene = gltfRuntime.currentScene;
+        if (currentScene) {
+            // Only one scene even if multiple scenes are defined
+            for (var i = 0; i < currentScene.nodes.length; i++) {
+                traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+            }
+        }
+        else {
+            // Load all scenes
+            for (var thing in gltfRuntime.scenes) {
+                currentScene = gltfRuntime.scenes[thing];
+                for (var i = 0; i < currentScene.nodes.length; i++) {
+                    traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+                }
+            }
+        }
+    };
+    GLTFLoader.Extensions = {};
+    return GLTFLoader;
+}());
+
+/** @hidden */
+var GLTFLoaderExtension = /** @class */ (function () {
+    function GLTFLoaderExtension(name) {
+        this._name = name;
+    }
+    Object.defineProperty(GLTFLoaderExtension.prototype, "name", {
+        get: function () {
+            return this._name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Defines an override for loading the runtime
+     * Return true to stop further extensions from loading the runtime
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
+        return false;
+    };
+    /**
+     * Defines an onverride for creating gltf runtime
+     * Return true to stop further extensions from creating the runtime
+     * @param gltfRuntime
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
+        return false;
+    };
+    /**
+     * Defines an override for loading buffers
+     * Return true to stop further extensions from loading this buffer
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     * @param onProgress
+     */
+    GLTFLoaderExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
+        return false;
+    };
+    /**
+     * Defines an override for loading texture buffers
+     * Return true to stop further extensions from loading this texture data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        return false;
+    };
+    /**
+     * Defines an override for creating textures
+     * Return true to stop further extensions from loading this texture
+     * @param gltfRuntime
+     * @param id
+     * @param buffer
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.createTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
+        return false;
+    };
+    /**
+     * Defines an override for loading shader strings
+     * Return true to stop further extensions from loading this shader data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
+        return false;
+    };
+    /**
+     * Defines an override for loading materials
+     * Return true to stop further extensions from loading this material
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        return false;
+    };
+    // ---------
+    // Utilities
+    // ---------
+    GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
+        }, function () {
+            setTimeout(function () {
+                if (!onSuccess) {
+                    return;
+                }
+                onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
+            });
+        });
+    };
+    GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
+        }, function () {
+            setTimeout(function () {
+                onSuccess();
+            });
+        });
+    };
+    GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
+        }, function () {
+            GLTFLoaderBase.LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
+        });
+    };
+    GLTFLoaderExtension.LoadTextureAsync = function (gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
+            if (buffer) {
+                GLTFLoaderExtension._CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
+            }
+        }, onError);
+    };
+    GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
+        }, function () {
+            GLTFLoaderBase.LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
+        });
+    };
+    GLTFLoaderExtension.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadMaterialAsync(gltfRuntime, id, onSuccess, onError);
+        }, function () {
+            GLTFLoaderBase.LoadMaterialAsync(gltfRuntime, id, onSuccess, onError);
+        });
+    };
+    GLTFLoaderExtension._LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
+        }, function () {
+            GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
+        });
+    };
+    GLTFLoaderExtension._CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
+        }, function () {
+            GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess);
+        });
+    };
+    GLTFLoaderExtension._ApplyExtensions = function (func, defaultFunc) {
+        for (var extensionName in GLTFLoader.Extensions) {
+            var loaderExtension = GLTFLoader.Extensions[extensionName];
+            if (func(loaderExtension)) {
+                return;
+            }
+        }
+        defaultFunc();
+    };
+    return GLTFLoaderExtension;
+}());
+
+_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.GLTFFileLoader._CreateGLTF1Loader = function () { return new GLTFLoader(); };
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderInterfaces.js":
+/*!******************************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/1.0/glTFLoaderInterfaces.js ***!
+  \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "EBlendingFunction": () => (/* binding */ EBlendingFunction),
+/* harmony export */   "EComponentType": () => (/* binding */ EComponentType),
+/* harmony export */   "ECullingType": () => (/* binding */ ECullingType),
+/* harmony export */   "EParameterType": () => (/* binding */ EParameterType),
+/* harmony export */   "EShaderType": () => (/* binding */ EShaderType),
+/* harmony export */   "ETextureFilterType": () => (/* binding */ ETextureFilterType),
+/* harmony export */   "ETextureFormat": () => (/* binding */ ETextureFormat),
+/* harmony export */   "ETextureWrapMode": () => (/* binding */ ETextureWrapMode)
+/* harmony export */ });
+/**
+ * Enums
+ * @hidden
+ */
+var EComponentType;
+(function (EComponentType) {
+    EComponentType[EComponentType["BYTE"] = 5120] = "BYTE";
+    EComponentType[EComponentType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+    EComponentType[EComponentType["SHORT"] = 5122] = "SHORT";
+    EComponentType[EComponentType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+    EComponentType[EComponentType["FLOAT"] = 5126] = "FLOAT";
+})(EComponentType || (EComponentType = {}));
+/** @hidden */
+var EShaderType;
+(function (EShaderType) {
+    EShaderType[EShaderType["FRAGMENT"] = 35632] = "FRAGMENT";
+    EShaderType[EShaderType["VERTEX"] = 35633] = "VERTEX";
+})(EShaderType || (EShaderType = {}));
+/** @hidden */
+var EParameterType;
+(function (EParameterType) {
+    EParameterType[EParameterType["BYTE"] = 5120] = "BYTE";
+    EParameterType[EParameterType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+    EParameterType[EParameterType["SHORT"] = 5122] = "SHORT";
+    EParameterType[EParameterType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+    EParameterType[EParameterType["INT"] = 5124] = "INT";
+    EParameterType[EParameterType["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
+    EParameterType[EParameterType["FLOAT"] = 5126] = "FLOAT";
+    EParameterType[EParameterType["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
+    EParameterType[EParameterType["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
+    EParameterType[EParameterType["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
+    EParameterType[EParameterType["INT_VEC2"] = 35667] = "INT_VEC2";
+    EParameterType[EParameterType["INT_VEC3"] = 35668] = "INT_VEC3";
+    EParameterType[EParameterType["INT_VEC4"] = 35669] = "INT_VEC4";
+    EParameterType[EParameterType["BOOL"] = 35670] = "BOOL";
+    EParameterType[EParameterType["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
+    EParameterType[EParameterType["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
+    EParameterType[EParameterType["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
+    EParameterType[EParameterType["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
+    EParameterType[EParameterType["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
+    EParameterType[EParameterType["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
+    EParameterType[EParameterType["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
+})(EParameterType || (EParameterType = {}));
+/** @hidden */
+var ETextureWrapMode;
+(function (ETextureWrapMode) {
+    ETextureWrapMode[ETextureWrapMode["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
+    ETextureWrapMode[ETextureWrapMode["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+    ETextureWrapMode[ETextureWrapMode["REPEAT"] = 10497] = "REPEAT";
+})(ETextureWrapMode || (ETextureWrapMode = {}));
+/** @hidden */
+var ETextureFilterType;
+(function (ETextureFilterType) {
+    ETextureFilterType[ETextureFilterType["NEAREST"] = 9728] = "NEAREST";
+    ETextureFilterType[ETextureFilterType["LINEAR"] = 9728] = "LINEAR";
+    ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
+    ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+    ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
+    ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
+})(ETextureFilterType || (ETextureFilterType = {}));
+/** @hidden */
+var ETextureFormat;
+(function (ETextureFormat) {
+    ETextureFormat[ETextureFormat["ALPHA"] = 6406] = "ALPHA";
+    ETextureFormat[ETextureFormat["RGB"] = 6407] = "RGB";
+    ETextureFormat[ETextureFormat["RGBA"] = 6408] = "RGBA";
+    ETextureFormat[ETextureFormat["LUMINANCE"] = 6409] = "LUMINANCE";
+    ETextureFormat[ETextureFormat["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
+})(ETextureFormat || (ETextureFormat = {}));
+/** @hidden */
+var ECullingType;
+(function (ECullingType) {
+    ECullingType[ECullingType["FRONT"] = 1028] = "FRONT";
+    ECullingType[ECullingType["BACK"] = 1029] = "BACK";
+    ECullingType[ECullingType["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
+})(ECullingType || (ECullingType = {}));
+/** @hidden */
+var EBlendingFunction;
+(function (EBlendingFunction) {
+    EBlendingFunction[EBlendingFunction["ZERO"] = 0] = "ZERO";
+    EBlendingFunction[EBlendingFunction["ONE"] = 1] = "ONE";
+    EBlendingFunction[EBlendingFunction["SRC_COLOR"] = 768] = "SRC_COLOR";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
+    EBlendingFunction[EBlendingFunction["DST_COLOR"] = 774] = "DST_COLOR";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
+    EBlendingFunction[EBlendingFunction["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+    EBlendingFunction[EBlendingFunction["DST_ALPHA"] = 772] = "DST_ALPHA";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
+    EBlendingFunction[EBlendingFunction["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
+    EBlendingFunction[EBlendingFunction["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
+    EBlendingFunction[EBlendingFunction["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
+})(EBlendingFunction || (EBlendingFunction = {}));
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderUtils.js":
+/*!*************************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/1.0/glTFLoaderUtils.js ***!
+  \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFUtils": () => (/* binding */ GLTFUtils)
+/* harmony export */ });
+/* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderInterfaces.js");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/Textures/texture */ "core/Misc/observable");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__);
+
+
+
+
+
+
+/**
+ * Utils functions for GLTF
+ * @hidden
+ */
+var GLTFUtils = /** @class */ (function () {
+    function GLTFUtils() {
+    }
+    /**
+     * Sets the given "parameter" matrix
+     * @param scene the Scene object
+     * @param source the source node where to pick the matrix
+     * @param parameter the GLTF technique parameter
+     * @param uniformName the name of the shader's uniform
+     * @param shaderMaterial the shader material
+     */
+    GLTFUtils.SetMatrix = function (scene, source, parameter, uniformName, shaderMaterial) {
+        var mat = null;
+        if (parameter.semantic === "MODEL") {
+            mat = source.getWorldMatrix();
+        }
+        else if (parameter.semantic === "PROJECTION") {
+            mat = scene.getProjectionMatrix();
+        }
+        else if (parameter.semantic === "VIEW") {
+            mat = scene.getViewMatrix();
+        }
+        else if (parameter.semantic === "MODELVIEWINVERSETRANSPOSE") {
+            mat = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Transpose(source.getWorldMatrix().multiply(scene.getViewMatrix()).invert());
+        }
+        else if (parameter.semantic === "MODELVIEW") {
+            mat = source.getWorldMatrix().multiply(scene.getViewMatrix());
+        }
+        else if (parameter.semantic === "MODELVIEWPROJECTION") {
+            mat = source.getWorldMatrix().multiply(scene.getTransformMatrix());
+        }
+        else if (parameter.semantic === "MODELINVERSE") {
+            mat = source.getWorldMatrix().invert();
+        }
+        else if (parameter.semantic === "VIEWINVERSE") {
+            mat = scene.getViewMatrix().invert();
+        }
+        else if (parameter.semantic === "PROJECTIONINVERSE") {
+            mat = scene.getProjectionMatrix().invert();
+        }
+        else if (parameter.semantic === "MODELVIEWINVERSE") {
+            mat = source.getWorldMatrix().multiply(scene.getViewMatrix()).invert();
+        }
+        else if (parameter.semantic === "MODELVIEWPROJECTIONINVERSE") {
+            mat = source.getWorldMatrix().multiply(scene.getTransformMatrix()).invert();
+        }
+        else if (parameter.semantic === "MODELINVERSETRANSPOSE") {
+            mat = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Transpose(source.getWorldMatrix().invert());
+        }
+        if (mat) {
+            switch (parameter.type) {
+                case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT2:
+                    shaderMaterial.setMatrix2x2(uniformName, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.GetAsMatrix2x2(mat));
+                    break;
+                case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT3:
+                    shaderMaterial.setMatrix3x3(uniformName, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.GetAsMatrix3x3(mat));
+                    break;
+                case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT4:
+                    shaderMaterial.setMatrix(uniformName, mat);
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+    /**
+     * Sets the given "parameter" matrix
+     * @param shaderMaterial the shader material
+     * @param uniform the name of the shader's uniform
+     * @param value the value of the uniform
+     * @param type the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
+     */
+    GLTFUtils.SetUniform = function (shaderMaterial, uniform, value, type) {
+        switch (type) {
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT:
+                shaderMaterial.setFloat(uniform, value);
+                return true;
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_VEC2:
+                shaderMaterial.setVector2(uniform, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector2.FromArray(value));
+                return true;
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_VEC3:
+                shaderMaterial.setVector3(uniform, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(value));
+                return true;
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_VEC4:
+                shaderMaterial.setVector4(uniform, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector4.FromArray(value));
+                return true;
+            default:
+                return false;
+        }
+    };
+    /**
+     * Returns the wrap mode of the texture
+     * @param mode the mode value
+     */
+    GLTFUtils.GetWrapMode = function (mode) {
+        switch (mode) {
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureWrapMode.CLAMP_TO_EDGE:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.CLAMP_ADDRESSMODE;
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureWrapMode.MIRRORED_REPEAT:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.MIRROR_ADDRESSMODE;
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureWrapMode.REPEAT:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.WRAP_ADDRESSMODE;
+            default:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.WRAP_ADDRESSMODE;
+        }
+    };
+    /**
+     * Returns the byte stride giving an accessor
+     * @param accessor the GLTF accessor objet
+     */
+    GLTFUtils.GetByteStrideFromType = function (accessor) {
+        // Needs this function since "byteStride" isn't requiered in glTF format
+        var type = accessor.type;
+        switch (type) {
+            case "VEC2":
+                return 2;
+            case "VEC3":
+                return 3;
+            case "VEC4":
+                return 4;
+            case "MAT2":
+                return 4;
+            case "MAT3":
+                return 9;
+            case "MAT4":
+                return 16;
+            default:
+                return 1;
+        }
+    };
+    /**
+     * Returns the texture filter mode giving a mode value
+     * @param mode the filter mode value
+     */
+    GLTFUtils.GetTextureFilterMode = function (mode) {
+        switch (mode) {
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.LINEAR:
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.LINEAR_MIPMAP_NEAREST:
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.LINEAR_MIPMAP_LINEAR:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.TRILINEAR_SAMPLINGMODE;
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.NEAREST:
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.ETextureFilterType.NEAREST_MIPMAP_NEAREST:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.NEAREST_SAMPLINGMODE;
+            default:
+                return core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Texture.BILINEAR_SAMPLINGMODE;
+        }
+    };
+    GLTFUtils.GetBufferFromBufferView = function (gltfRuntime, bufferView, byteOffset, byteLength, componentType) {
+        byteOffset = bufferView.byteOffset + byteOffset;
+        var loadedBufferView = gltfRuntime.loadedBufferViews[bufferView.buffer];
+        if (byteOffset + byteLength > loadedBufferView.byteLength) {
+            throw new Error("Buffer access is out of range");
+        }
+        var buffer = loadedBufferView.buffer;
+        byteOffset += loadedBufferView.byteOffset;
+        switch (componentType) {
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EComponentType.BYTE:
+                return new Int8Array(buffer, byteOffset, byteLength);
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EComponentType.UNSIGNED_BYTE:
+                return new Uint8Array(buffer, byteOffset, byteLength);
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EComponentType.SHORT:
+                return new Int16Array(buffer, byteOffset, byteLength);
+            case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EComponentType.UNSIGNED_SHORT:
+                return new Uint16Array(buffer, byteOffset, byteLength);
+            default:
+                return new Float32Array(buffer, byteOffset, byteLength);
+        }
+    };
+    /**
+     * Returns a buffer from its accessor
+     * @param gltfRuntime the GLTF runtime
+     * @param accessor the GLTF accessor
+     */
+    GLTFUtils.GetBufferFromAccessor = function (gltfRuntime, accessor) {
+        var bufferView = gltfRuntime.bufferViews[accessor.bufferView];
+        var byteLength = accessor.count * GLTFUtils.GetByteStrideFromType(accessor);
+        return GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, accessor.byteOffset, byteLength, accessor.componentType);
+    };
+    /**
+     * Decodes a buffer view into a string
+     * @param view the buffer view
+     */
+    GLTFUtils.DecodeBufferToText = function (view) {
+        var result = "";
+        var length = view.byteLength;
+        for (var i = 0; i < length; ++i) {
+            result += String.fromCharCode(view[i]);
+        }
+        return result;
+    };
+    /**
+     * Returns the default material of gltf. Related to
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
+     * @param scene the Babylon.js scene
+     */
+    GLTFUtils.GetDefaultMaterial = function (scene) {
+        if (!GLTFUtils._DefaultMaterial) {
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore.GLTFDefaultMaterialVertexShader = [
+                "precision highp float;",
+                "",
+                "uniform mat4 worldView;",
+                "uniform mat4 projection;",
+                "",
+                "attribute vec3 position;",
+                "",
+                "void main(void)",
+                "{",
+                "    gl_Position = projection * worldView * vec4(position, 1.0);",
+                "}",
+            ].join("\n");
+            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Effect.ShadersStore.GLTFDefaultMaterialPixelShader = [
+                "precision highp float;",
+                "",
+                "uniform vec4 u_emission;",
+                "",
+                "void main(void)",
+                "{",
+                "    gl_FragColor = u_emission;",
+                "}",
+            ].join("\n");
+            var shaderPath = {
+                vertex: "GLTFDefaultMaterial",
+                fragment: "GLTFDefaultMaterial",
+            };
+            var options = {
+                attributes: ["position"],
+                uniforms: ["worldView", "projection", "u_emission"],
+                samplers: new Array(),
+                needAlphaBlending: false,
+            };
+            GLTFUtils._DefaultMaterial = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.ShaderMaterial("GLTFDefaultMaterial", scene, shaderPath, options);
+            GLTFUtils._DefaultMaterial.setColor4("u_emission", new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color4(0.5, 0.5, 0.5, 1.0));
+        }
+        return GLTFUtils._DefaultMaterial;
+    };
+    // The GLTF default material
+    GLTFUtils._DefaultMaterial = null;
+    return GLTFUtils;
+}());
+
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/1.0/glTFMaterialsCommonExtension.js":
+/*!**************************************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/1.0/glTFMaterialsCommonExtension.js ***!
+  \**************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFMaterialsCommonExtension": () => (/* binding */ GLTFMaterialsCommonExtension)
+/* harmony export */ });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../../../node_modules/tslib/tslib.es6.js");
+/* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoader */ "../../../lts/loaders/dist/glTF/1.0/glTFLoader.js");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! core/Lights/spotLight */ "core/Misc/observable");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__);
+
+
+
+
+
+
+
+
+
+
+
+/** @hidden */
+var GLTFMaterialsCommonExtension = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(GLTFMaterialsCommonExtension, _super);
+    function GLTFMaterialsCommonExtension() {
+        return _super.call(this, "KHR_materials_common") || this;
+    }
+    GLTFMaterialsCommonExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime) {
+        if (!gltfRuntime.extensions) {
+            return false;
+        }
+        var extension = gltfRuntime.extensions[this.name];
+        if (!extension) {
+            return false;
+        }
+        // Create lights
+        var lights = extension.lights;
+        if (lights) {
+            for (var thing in lights) {
+                var light = lights[thing];
+                switch (light.type) {
+                    case "ambient": {
+                        var ambientLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.HemisphericLight(light.name, new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Vector3(0, 1, 0), gltfRuntime.scene);
+                        var ambient = light.ambient;
+                        if (ambient) {
+                            ambientLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(ambient.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "point": {
+                        var pointLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.PointLight(light.name, new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Vector3(10, 10, 10), gltfRuntime.scene);
+                        var point = light.point;
+                        if (point) {
+                            pointLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(point.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "directional": {
+                        var dirLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.DirectionalLight(light.name, new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Vector3(0, -1, 0), gltfRuntime.scene);
+                        var directional = light.directional;
+                        if (directional) {
+                            dirLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(directional.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "spot": {
+                        var spot = light.spot;
+                        if (spot) {
+                            var spotLight = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.SpotLight(light.name, new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Vector3(0, 10, 0), new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Vector3(0, -1, 0), spot.fallOffAngle || Math.PI, spot.fallOffExponent || 0.0, gltfRuntime.scene);
+                            spotLight.diffuse = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(spot.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    default:
+                        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Tools.Warn('GLTF Material Common extension: light type "' + light.type + "” not supported");
+                        break;
+                }
+            }
+        }
+        return false;
+    };
+    GLTFMaterialsCommonExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var material = gltfRuntime.materials[id];
+        if (!material || !material.extensions) {
+            return false;
+        }
+        var extension = material.extensions[this.name];
+        if (!extension) {
+            return false;
+        }
+        var standardMaterial = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.StandardMaterial(id, gltfRuntime.scene);
+        standardMaterial.sideOrientation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Material.CounterClockWiseSideOrientation;
+        if (extension.technique === "CONSTANT") {
+            standardMaterial.disableLighting = true;
+        }
+        standardMaterial.backFaceCulling = extension.doubleSided === undefined ? false : !extension.doubleSided;
+        standardMaterial.alpha = extension.values.transparency === undefined ? 1.0 : extension.values.transparency;
+        standardMaterial.specularPower = extension.values.shininess === undefined ? 0.0 : extension.values.shininess;
+        // Ambient
+        if (typeof extension.values.ambient === "string") {
+            this._loadTexture(gltfRuntime, extension.values.ambient, standardMaterial, "ambientTexture", onError);
+        }
+        else {
+            standardMaterial.ambientColor = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(extension.values.ambient || [0, 0, 0]);
+        }
+        // Diffuse
+        if (typeof extension.values.diffuse === "string") {
+            this._loadTexture(gltfRuntime, extension.values.diffuse, standardMaterial, "diffuseTexture", onError);
+        }
+        else {
+            standardMaterial.diffuseColor = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(extension.values.diffuse || [0, 0, 0]);
+        }
+        // Emission
+        if (typeof extension.values.emission === "string") {
+            this._loadTexture(gltfRuntime, extension.values.emission, standardMaterial, "emissiveTexture", onError);
+        }
+        else {
+            standardMaterial.emissiveColor = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(extension.values.emission || [0, 0, 0]);
+        }
+        // Specular
+        if (typeof extension.values.specular === "string") {
+            this._loadTexture(gltfRuntime, extension.values.specular, standardMaterial, "specularTexture", onError);
+        }
+        else {
+            standardMaterial.specularColor = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_2__.Color3.FromArray(extension.values.specular || [0, 0, 0]);
+        }
+        return true;
+    };
+    GLTFMaterialsCommonExtension.prototype._loadTexture = function (gltfRuntime, id, material, propertyPath, onError) {
+        // Create buffer from texture url
+        _glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
+            // Create texture from buffer
+            _glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, function (texture) { return (material[propertyPath] = texture); });
+        }, onError);
+    };
+    return GLTFMaterialsCommonExtension;
+}(_glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderExtension));
+
+_glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoader.RegisterExtension(new GLTFMaterialsCommonExtension());
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/1.0/index.js":
+/*!***************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/1.0/index.js ***!
+  \***************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "EBlendingFunction": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.EBlendingFunction),
+/* harmony export */   "EComponentType": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.EComponentType),
+/* harmony export */   "ECullingType": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.ECullingType),
+/* harmony export */   "EParameterType": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.EParameterType),
+/* harmony export */   "EShaderType": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.EShaderType),
+/* harmony export */   "ETextureFilterType": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.ETextureFilterType),
+/* harmony export */   "ETextureFormat": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.ETextureFormat),
+/* harmony export */   "ETextureWrapMode": () => (/* reexport safe */ _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.ETextureWrapMode),
+/* harmony export */   "GLTFBinaryExtension": () => (/* reexport safe */ _glTFBinaryExtension__WEBPACK_IMPORTED_MODULE_0__.GLTFBinaryExtension),
+/* harmony export */   "GLTFLoader": () => (/* reexport safe */ _glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoader),
+/* harmony export */   "GLTFLoaderBase": () => (/* reexport safe */ _glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderBase),
+/* harmony export */   "GLTFLoaderExtension": () => (/* reexport safe */ _glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoaderExtension),
+/* harmony export */   "GLTFMaterialsCommonExtension": () => (/* reexport safe */ _glTFMaterialsCommonExtension__WEBPACK_IMPORTED_MODULE_4__.GLTFMaterialsCommonExtension),
+/* harmony export */   "GLTFUtils": () => (/* reexport safe */ _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_3__.GLTFUtils)
+/* harmony export */ });
+/* harmony import */ var _glTFBinaryExtension__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFBinaryExtension */ "../../../lts/loaders/dist/glTF/1.0/glTFBinaryExtension.js");
+/* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoader */ "../../../lts/loaders/dist/glTF/1.0/glTFLoader.js");
+/* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderInterfaces.js");
+/* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./glTFLoaderUtils */ "../../../lts/loaders/dist/glTF/1.0/glTFLoaderUtils.js");
+/* harmony import */ var _glTFMaterialsCommonExtension__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./glTFMaterialsCommonExtension */ "../../../lts/loaders/dist/glTF/1.0/glTFMaterialsCommonExtension.js");
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/glTFFileLoader.js":
+/*!********************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/glTFFileLoader.js ***!
+  \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFFileLoader": () => (/* binding */ GLTFFileLoader),
+/* harmony export */   "GLTFLoaderAnimationStartMode": () => (/* binding */ GLTFLoaderAnimationStartMode),
+/* harmony export */   "GLTFLoaderCoordinateSystemMode": () => (/* binding */ GLTFLoaderCoordinateSystemMode),
+/* harmony export */   "GLTFLoaderState": () => (/* binding */ GLTFLoaderState)
+/* harmony export */ });
+/* harmony import */ var core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/error */ "core/Misc/observable");
+/* harmony import */ var core_Misc_observable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _glTFValidation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFValidation */ "../../../lts/loaders/dist/glTF/glTFValidation.js");
+
+
+
+
+
+
+
+
+
+
+function readAsync(arrayBuffer, byteOffset, byteLength) {
+    try {
+        return Promise.resolve(new Uint8Array(arrayBuffer, byteOffset, byteLength));
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+}
+/**
+ * Mode that determines the coordinate system to use.
+ */
+var GLTFLoaderCoordinateSystemMode;
+(function (GLTFLoaderCoordinateSystemMode) {
+    /**
+     * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.
+     */
+    GLTFLoaderCoordinateSystemMode[GLTFLoaderCoordinateSystemMode["AUTO"] = 0] = "AUTO";
+    /**
+     * Sets the useRightHandedSystem flag on the scene.
+     */
+    GLTFLoaderCoordinateSystemMode[GLTFLoaderCoordinateSystemMode["FORCE_RIGHT_HANDED"] = 1] = "FORCE_RIGHT_HANDED";
+})(GLTFLoaderCoordinateSystemMode || (GLTFLoaderCoordinateSystemMode = {}));
+/**
+ * Mode that determines what animations will start.
+ */
+var GLTFLoaderAnimationStartMode;
+(function (GLTFLoaderAnimationStartMode) {
+    /**
+     * No animation will start.
+     */
+    GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["NONE"] = 0] = "NONE";
+    /**
+     * The first animation will start.
+     */
+    GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["FIRST"] = 1] = "FIRST";
+    /**
+     * All animations will start.
+     */
+    GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["ALL"] = 2] = "ALL";
+})(GLTFLoaderAnimationStartMode || (GLTFLoaderAnimationStartMode = {}));
+/**
+ * Loader state.
+ */
+var GLTFLoaderState;
+(function (GLTFLoaderState) {
+    /**
+     * The asset is loading.
+     */
+    GLTFLoaderState[GLTFLoaderState["LOADING"] = 0] = "LOADING";
+    /**
+     * The asset is ready for rendering.
+     */
+    GLTFLoaderState[GLTFLoaderState["READY"] = 1] = "READY";
+    /**
+     * The asset is completely loaded.
+     */
+    GLTFLoaderState[GLTFLoaderState["COMPLETE"] = 2] = "COMPLETE";
+})(GLTFLoaderState || (GLTFLoaderState = {}));
+/**
+ * File loader for loading glTF files into a scene.
+ */
+var GLTFFileLoader = /** @class */ (function () {
+    function GLTFFileLoader() {
+        // --------------
+        // Common options
+        // --------------
+        /**
+         * Raised when the asset has been parsed
+         */
+        this.onParsedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        // ----------
+        // V2 options
+        // ----------
+        /**
+         * The coordinate system mode. Defaults to AUTO.
+         */
+        this.coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;
+        /**
+         * The animation start mode. Defaults to FIRST.
+         */
+        this.animationStartMode = GLTFLoaderAnimationStartMode.FIRST;
+        /**
+         * Defines if the loader should compile materials before raising the success callback. Defaults to false.
+         */
+        this.compileMaterials = false;
+        /**
+         * Defines if the loader should also compile materials with clip planes. Defaults to false.
+         */
+        this.useClipPlane = false;
+        /**
+         * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
+         */
+        this.compileShadowGenerators = false;
+        /**
+         * Defines if the Alpha blended materials are only applied as coverage.
+         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
+         * If true, no extra effects are applied to transparent pixels.
+         */
+        this.transparencyAsCoverage = false;
+        /**
+         * Defines if the loader should use range requests when load binary glTF files from HTTP.
+         * Enabling will disable offline support and glTF validator.
+         * Defaults to false.
+         */
+        this.useRangeRequests = false;
+        /**
+         * Defines if the loader should create instances when multiple glTF nodes point to the same glTF mesh. Defaults to true.
+         */
+        this.createInstances = true;
+        /**
+         * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.
+         */
+        this.alwaysComputeBoundingBox = false;
+        /**
+         * If true, load all materials defined in the file, even if not used by any mesh. Defaults to false.
+         */
+        this.loadAllMaterials = false;
+        /**
+         * If true, load only the materials defined in the file. Defaults to false.
+         */
+        this.loadOnlyMaterials = false;
+        /**
+         * If true, do not load any materials defined in the file. Defaults to false.
+         */
+        this.skipMaterials = false;
+        /**
+         * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.
+         */
+        this.useSRGBBuffers = true;
+        /**
+         * When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.
+         */
+        this.targetFps = 60;
+        /**
+         * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.
+         * Set this to true if loading assets with invalid `skin.skeleton` values.
+         */
+        this.alwaysComputeSkeletonRootNode = false;
+        /**
+         * Function called before loading a url referenced by the asset.
+         * @param url
+         */
+        this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
+        /**
+         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
+         * Note that the observable is raised as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
+         */
+        this.onMeshLoadedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
+         */
+        this.onTextureLoadedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised when the loader creates a material after parsing the glTF properties of the material.
+         */
+        this.onMaterialLoadedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
+         */
+        this.onCameraLoadedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
+         * For assets with LODs, raised when all of the LODs are complete.
+         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
+         */
+        this.onCompleteObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised when an error occurs.
+         */
+        this.onErrorObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised after the loader is disposed.
+         */
+        this.onDisposeObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Observable raised after a loader extension is created.
+         * Set additional options for a loader extension in this event.
+         */
+        this.onExtensionLoadedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        /**
+         * Defines if the loader should validate the asset.
+         */
+        this.validate = false;
+        /**
+         * Observable raised after validation when validate is set to true. The event data is the result of the validation.
+         */
+        this.onValidatedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        this._loader = null;
+        this._state = null;
+        this._requests = new Array();
+        /**
+         * Name of the loader ("gltf")
+         */
+        this.name = "gltf";
+        /** @hidden */
+        this.extensions = {
+            ".gltf": { isBinary: false },
+            ".glb": { isBinary: true },
+        };
+        /**
+         * Observable raised when the loader state changes.
+         */
+        this.onLoaderStateChangedObservable = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable();
+        this._logIndentLevel = 0;
+        this._loggingEnabled = false;
+        /** @hidden */
+        this._log = this._logDisabled;
+        this._capturePerformanceCounters = false;
+        /** @hidden */
+        this._startPerformanceCounter = this._startPerformanceCounterDisabled;
+        /** @hidden */
+        this._endPerformanceCounter = this._endPerformanceCounterDisabled;
+    }
+    Object.defineProperty(GLTFFileLoader.prototype, "onParsed", {
+        /**
+         * Raised when the asset has been parsed
+         */
+        set: function (callback) {
+            if (this._onParsedObserver) {
+                this.onParsedObservable.remove(this._onParsedObserver);
+            }
+            this._onParsedObserver = this.onParsedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onMeshLoaded", {
+        /**
+         * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
+         * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
+         */
+        set: function (callback) {
+            if (this._onMeshLoadedObserver) {
+                this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);
+            }
+            this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onTextureLoaded", {
+        /**
+         * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
+         */
+        set: function (callback) {
+            if (this._onTextureLoadedObserver) {
+                this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);
+            }
+            this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onMaterialLoaded", {
+        /**
+         * Callback raised when the loader creates a material after parsing the glTF properties of the material.
+         */
+        set: function (callback) {
+            if (this._onMaterialLoadedObserver) {
+                this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);
+            }
+            this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onCameraLoaded", {
+        /**
+         * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
+         */
+        set: function (callback) {
+            if (this._onCameraLoadedObserver) {
+                this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);
+            }
+            this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onComplete", {
+        /**
+         * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
+         * For assets with LODs, raised when all of the LODs are complete.
+         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
+         */
+        set: function (callback) {
+            if (this._onCompleteObserver) {
+                this.onCompleteObservable.remove(this._onCompleteObserver);
+            }
+            this._onCompleteObserver = this.onCompleteObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onError", {
+        /**
+         * Callback raised when an error occurs.
+         */
+        set: function (callback) {
+            if (this._onErrorObserver) {
+                this.onErrorObservable.remove(this._onErrorObserver);
+            }
+            this._onErrorObserver = this.onErrorObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onDispose", {
+        /**
+         * Callback raised after the loader is disposed.
+         */
+        set: function (callback) {
+            if (this._onDisposeObserver) {
+                this.onDisposeObservable.remove(this._onDisposeObserver);
+            }
+            this._onDisposeObserver = this.onDisposeObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onExtensionLoaded", {
+        /**
+         * Callback raised after a loader extension is created.
+         */
+        set: function (callback) {
+            if (this._onExtensionLoadedObserver) {
+                this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);
+            }
+            this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "loggingEnabled", {
+        /**
+         * Defines if the loader logging is enabled.
+         */
+        get: function () {
+            return this._loggingEnabled;
+        },
+        set: function (value) {
+            if (this._loggingEnabled === value) {
+                return;
+            }
+            this._loggingEnabled = value;
+            if (this._loggingEnabled) {
+                this._log = this._logEnabled;
+            }
+            else {
+                this._log = this._logDisabled;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "capturePerformanceCounters", {
+        /**
+         * Defines if the loader should capture performance counters.
+         */
+        get: function () {
+            return this._capturePerformanceCounters;
+        },
+        set: function (value) {
+            if (this._capturePerformanceCounters === value) {
+                return;
+            }
+            this._capturePerformanceCounters = value;
+            if (this._capturePerformanceCounters) {
+                this._startPerformanceCounter = this._startPerformanceCounterEnabled;
+                this._endPerformanceCounter = this._endPerformanceCounterEnabled;
+            }
+            else {
+                this._startPerformanceCounter = this._startPerformanceCounterDisabled;
+                this._endPerformanceCounter = this._endPerformanceCounterDisabled;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFFileLoader.prototype, "onValidated", {
+        /**
+         * Callback raised after a loader extension is created.
+         */
+        set: function (callback) {
+            if (this._onValidatedObserver) {
+                this.onValidatedObservable.remove(this._onValidatedObserver);
+            }
+            this._onValidatedObserver = this.onValidatedObservable.add(callback);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Disposes the loader, releases resources during load, and cancels any outstanding requests.
+     */
+    GLTFFileLoader.prototype.dispose = function () {
+        if (this._loader) {
+            this._loader.dispose();
+            this._loader = null;
+        }
+        for (var _i = 0, _a = this._requests; _i < _a.length; _i++) {
+            var request = _a[_i];
+            request.abort();
+        }
+        this._requests.length = 0;
+        delete this._progressCallback;
+        this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
+        this.onMeshLoadedObservable.clear();
+        this.onTextureLoadedObservable.clear();
+        this.onMaterialLoadedObservable.clear();
+        this.onCameraLoadedObservable.clear();
+        this.onCompleteObservable.clear();
+        this.onExtensionLoadedObservable.clear();
+        this.onDisposeObservable.notifyObservers(undefined);
+        this.onDisposeObservable.clear();
+    };
+    /**
+     * @param scene
+     * @param fileOrUrl
+     * @param onSuccess
+     * @param onProgress
+     * @param useArrayBuffer
+     * @param onError
+     * @hidden
+     */
+    GLTFFileLoader.prototype.loadFile = function (scene, fileOrUrl, onSuccess, onProgress, useArrayBuffer, onError) {
+        var _this = this;
+        this._progressCallback = onProgress;
+        var rootUrl = fileOrUrl.name ? "file:" : core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Tools.GetFolderPath(fileOrUrl);
+        var fileName = fileOrUrl.name || core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Tools.GetFilename(fileOrUrl);
+        if (useArrayBuffer) {
+            if (this.useRangeRequests) {
+                if (this.validate) {
+                    core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Logger.Warn("glTF validation is not supported when range requests are enabled");
+                }
+                var fileRequest_1 = {
+                    abort: function () { },
+                    onCompleteObservable: new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Observable(),
+                };
+                var dataBuffer = {
+                    readAsync: function (byteOffset, byteLength) {
+                        return new Promise(function (resolve, reject) {
+                            _this._loadFile(scene, fileOrUrl, function (data) {
+                                resolve(new Uint8Array(data));
+                            }, true, function (error) {
+                                reject(error);
+                            }, function (webRequest) {
+                                webRequest.setRequestHeader("Range", "bytes=".concat(byteOffset, "-").concat(byteOffset + byteLength - 1));
+                            });
+                        });
+                    },
+                    byteLength: 0,
+                };
+                this._unpackBinaryAsync(new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.DataReader(dataBuffer)).then(function (loaderData) {
+                    fileRequest_1.onCompleteObservable.notifyObservers(fileRequest_1);
+                    onSuccess(loaderData);
+                }, onError ? function (error) { return onError(undefined, error); } : undefined);
+                return fileRequest_1;
+            }
+            return this._loadFile(scene, fileOrUrl, function (data) {
+                _this._validate(scene, data, rootUrl, fileName);
+                _this._unpackBinaryAsync(new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.DataReader({
+                    readAsync: function (byteOffset, byteLength) { return readAsync(data, byteOffset, byteLength); },
+                    byteLength: data.byteLength,
+                })).then(function (loaderData) {
+                    onSuccess(loaderData);
+                }, onError ? function (error) { return onError(undefined, error); } : undefined);
+            }, true, onError);
+        }
+        return this._loadFile(scene, fileOrUrl, function (data) {
+            _this._validate(scene, data, rootUrl, fileName);
+            onSuccess({ json: _this._parseJson(data) });
+        }, useArrayBuffer, onError);
+    };
+    /**
+     * @param meshesNames
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onProgress
+     * @param fileName
+     * @hidden
+     */
+    GLTFFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress, fileName) {
+        var _this = this;
+        return Promise.resolve().then(function () {
+            _this.onParsedObservable.notifyObservers(data);
+            _this.onParsedObservable.clear();
+            _this._log("Loading ".concat(fileName || ""));
+            _this._loader = _this._getLoader(data);
+            return _this._loader.importMeshAsync(meshesNames, scene, null, data, rootUrl, onProgress, fileName);
+        });
+    };
+    /**
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onProgress
+     * @param fileName
+     * @hidden
+     */
+    GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
+        var _this = this;
+        return Promise.resolve().then(function () {
+            _this.onParsedObservable.notifyObservers(data);
+            _this.onParsedObservable.clear();
+            _this._log("Loading ".concat(fileName || ""));
+            _this._loader = _this._getLoader(data);
+            return _this._loader.loadAsync(scene, data, rootUrl, onProgress, fileName);
+        });
+    };
+    /**
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onProgress
+     * @param fileName
+     * @hidden
+     */
+    GLTFFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl, onProgress, fileName) {
+        var _this = this;
+        return Promise.resolve().then(function () {
+            _this.onParsedObservable.notifyObservers(data);
+            _this.onParsedObservable.clear();
+            _this._log("Loading ".concat(fileName || ""));
+            _this._loader = _this._getLoader(data);
+            // Prepare the asset container.
+            var container = new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.AssetContainer(scene);
+            // Get materials/textures when loading to add to container
+            var materials = [];
+            _this.onMaterialLoadedObservable.add(function (material) {
+                materials.push(material);
+            });
+            var textures = [];
+            _this.onTextureLoadedObservable.add(function (texture) {
+                textures.push(texture);
+            });
+            var cameras = [];
+            _this.onCameraLoadedObservable.add(function (camera) {
+                cameras.push(camera);
+            });
+            return _this._loader.importMeshAsync(null, scene, container, data, rootUrl, onProgress, fileName).then(function (result) {
+                Array.prototype.push.apply(container.geometries, result.geometries);
+                Array.prototype.push.apply(container.meshes, result.meshes);
+                Array.prototype.push.apply(container.particleSystems, result.particleSystems);
+                Array.prototype.push.apply(container.skeletons, result.skeletons);
+                Array.prototype.push.apply(container.animationGroups, result.animationGroups);
+                Array.prototype.push.apply(container.materials, materials);
+                Array.prototype.push.apply(container.textures, textures);
+                Array.prototype.push.apply(container.lights, result.lights);
+                Array.prototype.push.apply(container.transformNodes, result.transformNodes);
+                Array.prototype.push.apply(container.cameras, cameras);
+                return container;
+            });
+        });
+    };
+    /**
+     * @param data
+     * @hidden
+     */
+    GLTFFileLoader.prototype.canDirectLoad = function (data) {
+        return ((data.indexOf("asset") !== -1 && data.indexOf("version") !== -1) ||
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "data:base64," + GLTFFileLoader._MagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "data:;base64," + GLTFFileLoader._MagicBase64Encoded) ||
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "data:application/octet-stream;base64," + GLTFFileLoader._MagicBase64Encoded) ||
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "data:model/gltf-binary;base64," + GLTFFileLoader._MagicBase64Encoded));
+    };
+    /**
+     * @param scene
+     * @param data
+     * @hidden
+     */
+    GLTFFileLoader.prototype.directLoad = function (scene, data) {
+        if (core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "base64," + GLTFFileLoader._MagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, ";base64," + GLTFFileLoader._MagicBase64Encoded) ||
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "application/octet-stream;base64," + GLTFFileLoader._MagicBase64Encoded) ||
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.StringTools.StartsWith(data, "model/gltf-binary;base64," + GLTFFileLoader._MagicBase64Encoded)) {
+            var arrayBuffer_1 = (0,core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.DecodeBase64UrlToBinary)(data);
+            this._validate(scene, arrayBuffer_1);
+            return this._unpackBinaryAsync(new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.DataReader({
+                readAsync: function (byteOffset, byteLength) { return readAsync(arrayBuffer_1, byteOffset, byteLength); },
+                byteLength: arrayBuffer_1.byteLength,
+            }));
+        }
+        this._validate(scene, data);
+        return Promise.resolve({ json: this._parseJson(data) });
+    };
+    /** @hidden */
+    GLTFFileLoader.prototype.createPlugin = function () {
+        return new GLTFFileLoader();
+    };
+    Object.defineProperty(GLTFFileLoader.prototype, "loaderState", {
+        /**
+         * The loader state or null if the loader is not active.
+         */
+        get: function () {
+            return this._state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Returns a promise that resolves when the asset is completely loaded.
+     * @returns a promise that resolves when the asset is completely loaded.
+     */
+    GLTFFileLoader.prototype.whenCompleteAsync = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.onCompleteObservable.addOnce(function () {
+                resolve();
+            });
+            _this.onErrorObservable.addOnce(function (reason) {
+                reject(reason);
+            });
+        });
+    };
+    /**
+     * @param state
+     * @hidden
+     */
+    GLTFFileLoader.prototype._setState = function (state) {
+        if (this._state === state) {
+            return;
+        }
+        this._state = state;
+        this.onLoaderStateChangedObservable.notifyObservers(this._state);
+        this._log(GLTFLoaderState[this._state]);
+    };
+    /**
+     * @param scene
+     * @param fileOrUrl
+     * @param onSuccess
+     * @param useArrayBuffer
+     * @param onError
+     * @param onOpened
+     * @hidden
+     */
+    GLTFFileLoader.prototype._loadFile = function (scene, fileOrUrl, onSuccess, useArrayBuffer, onError, onOpened) {
+        var _this = this;
+        var request = scene._loadFile(fileOrUrl, onSuccess, function (event) {
+            _this._onProgress(event, request);
+        }, true, useArrayBuffer, onError, onOpened);
+        request.onCompleteObservable.add(function (request) {
+            _this._requests.splice(_this._requests.indexOf(request), 1);
+        });
+        this._requests.push(request);
+        return request;
+    };
+    GLTFFileLoader.prototype._onProgress = function (event, request) {
+        if (!this._progressCallback) {
+            return;
+        }
+        request._lengthComputable = event.lengthComputable;
+        request._loaded = event.loaded;
+        request._total = event.total;
+        var lengthComputable = true;
+        var loaded = 0;
+        var total = 0;
+        for (var _i = 0, _a = this._requests; _i < _a.length; _i++) {
+            var request_1 = _a[_i];
+            if (request_1._lengthComputable === undefined || request_1._loaded === undefined || request_1._total === undefined) {
+                return;
+            }
+            lengthComputable = lengthComputable && request_1._lengthComputable;
+            loaded += request_1._loaded;
+            total += request_1._total;
+        }
+        this._progressCallback({
+            lengthComputable: lengthComputable,
+            loaded: loaded,
+            total: lengthComputable ? total : 0,
+        });
+    };
+    GLTFFileLoader.prototype._validate = function (scene, data, rootUrl, fileName) {
+        var _this = this;
+        if (rootUrl === void 0) { rootUrl = ""; }
+        if (fileName === void 0) { fileName = ""; }
+        if (!this.validate) {
+            return;
+        }
+        this._startPerformanceCounter("Validate JSON");
+        _glTFValidation__WEBPACK_IMPORTED_MODULE_1__.GLTFValidation.ValidateAsync(data, rootUrl, fileName, function (uri) {
+            return _this.preprocessUrlAsync(rootUrl + uri).then(function (url) { return scene._loadFileAsync(url, undefined, true, true); });
+        }).then(function (result) {
+            _this._endPerformanceCounter("Validate JSON");
+            _this.onValidatedObservable.notifyObservers(result);
+            _this.onValidatedObservable.clear();
+        }, function (reason) {
+            _this._endPerformanceCounter("Validate JSON");
+            core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Tools.Warn("Failed to validate: ".concat(reason.message));
+            _this.onValidatedObservable.clear();
+        });
+    };
+    GLTFFileLoader.prototype._getLoader = function (loaderData) {
+        var asset = loaderData.json.asset || {};
+        this._log("Asset version: ".concat(asset.version));
+        asset.minVersion && this._log("Asset minimum version: ".concat(asset.minVersion));
+        asset.generator && this._log("Asset generator: ".concat(asset.generator));
+        var version = GLTFFileLoader._parseVersion(asset.version);
+        if (!version) {
+            throw new Error("Invalid version: " + asset.version);
+        }
+        if (asset.minVersion !== undefined) {
+            var minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
+            if (!minVersion) {
+                throw new Error("Invalid minimum version: " + asset.minVersion);
+            }
+            if (GLTFFileLoader._compareVersion(minVersion, { major: 2, minor: 0 }) > 0) {
+                throw new Error("Incompatible minimum version: " + asset.minVersion);
+            }
+        }
+        var createLoaders = {
+            1: GLTFFileLoader._CreateGLTF1Loader,
+            2: GLTFFileLoader._CreateGLTF2Loader,
+        };
+        var createLoader = createLoaders[version.major];
+        if (!createLoader) {
+            throw new Error("Unsupported version: " + asset.version);
+        }
+        return createLoader(this);
+    };
+    GLTFFileLoader.prototype._parseJson = function (json) {
+        this._startPerformanceCounter("Parse JSON");
+        this._log("JSON length: ".concat(json.length));
+        var parsed = JSON.parse(json);
+        this._endPerformanceCounter("Parse JSON");
+        return parsed;
+    };
+    GLTFFileLoader.prototype._unpackBinaryAsync = function (dataReader) {
+        var _this = this;
+        this._startPerformanceCounter("Unpack Binary");
+        // Read magic + version + length + json length + json format
+        return dataReader.loadAsync(20).then(function () {
+            var Binary = {
+                Magic: 0x46546c67,
+            };
+            var magic = dataReader.readUint32();
+            if (magic !== Binary.Magic) {
+                throw new core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.RuntimeError("Unexpected magic: " + magic, core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes.GLTFLoaderUnexpectedMagicError);
+            }
+            var version = dataReader.readUint32();
+            if (_this.loggingEnabled) {
+                _this._log("Binary version: ".concat(version));
+            }
+            var length = dataReader.readUint32();
+            if (dataReader.buffer.byteLength !== 0 && length !== dataReader.buffer.byteLength) {
+                throw new Error("Length in header does not match actual data length: ".concat(length, " != ").concat(dataReader.buffer.byteLength));
+            }
+            var unpacked;
+            switch (version) {
+                case 1: {
+                    unpacked = _this._unpackBinaryV1Async(dataReader, length);
+                    break;
+                }
+                case 2: {
+                    unpacked = _this._unpackBinaryV2Async(dataReader, length);
+                    break;
+                }
+                default: {
+                    throw new Error("Unsupported version: " + version);
+                }
+            }
+            _this._endPerformanceCounter("Unpack Binary");
+            return unpacked;
+        });
+    };
+    GLTFFileLoader.prototype._unpackBinaryV1Async = function (dataReader, length) {
+        var ContentFormat = {
+            JSON: 0,
+        };
+        var contentLength = dataReader.readUint32();
+        var contentFormat = dataReader.readUint32();
+        if (contentFormat !== ContentFormat.JSON) {
+            throw new Error("Unexpected content format: ".concat(contentFormat));
+        }
+        var bodyLength = length - dataReader.byteOffset;
+        var data = { json: this._parseJson(dataReader.readString(contentLength)), bin: null };
+        if (bodyLength !== 0) {
+            var startByteOffset_1 = dataReader.byteOffset;
+            data.bin = {
+                readAsync: function (byteOffset, byteLength) { return dataReader.buffer.readAsync(startByteOffset_1 + byteOffset, byteLength); },
+                byteLength: bodyLength,
+            };
+        }
+        return Promise.resolve(data);
+    };
+    GLTFFileLoader.prototype._unpackBinaryV2Async = function (dataReader, length) {
+        var _this = this;
+        var ChunkFormat = {
+            JSON: 0x4e4f534a,
+            BIN: 0x004e4942,
+        };
+        // Read the JSON chunk header.
+        var chunkLength = dataReader.readUint32();
+        var chunkFormat = dataReader.readUint32();
+        if (chunkFormat !== ChunkFormat.JSON) {
+            throw new Error("First chunk format is not JSON");
+        }
+        // Bail if there are no other chunks.
+        if (dataReader.byteOffset + chunkLength === length) {
+            return dataReader.loadAsync(chunkLength).then(function () {
+                return { json: _this._parseJson(dataReader.readString(chunkLength)), bin: null };
+            });
+        }
+        // Read the JSON chunk and the length and type of the next chunk.
+        return dataReader.loadAsync(chunkLength + 8).then(function () {
+            var data = { json: _this._parseJson(dataReader.readString(chunkLength)), bin: null };
+            var readAsync = function () {
+                var chunkLength = dataReader.readUint32();
+                var chunkFormat = dataReader.readUint32();
+                switch (chunkFormat) {
+                    case ChunkFormat.JSON: {
+                        throw new Error("Unexpected JSON chunk");
+                    }
+                    case ChunkFormat.BIN: {
+                        var startByteOffset_2 = dataReader.byteOffset;
+                        data.bin = {
+                            readAsync: function (byteOffset, byteLength) { return dataReader.buffer.readAsync(startByteOffset_2 + byteOffset, byteLength); },
+                            byteLength: chunkLength,
+                        };
+                        dataReader.skipBytes(chunkLength);
+                        break;
+                    }
+                    default: {
+                        // ignore unrecognized chunkFormat
+                        dataReader.skipBytes(chunkLength);
+                        break;
+                    }
+                }
+                if (dataReader.byteOffset !== length) {
+                    return dataReader.loadAsync(8).then(readAsync);
+                }
+                return Promise.resolve(data);
+            };
+            return readAsync();
+        });
+    };
+    GLTFFileLoader._parseVersion = function (version) {
+        if (version === "1.0" || version === "1.0.1") {
+            return {
+                major: 1,
+                minor: 0,
+            };
+        }
+        var match = (version + "").match(/^(\d+)\.(\d+)/);
+        if (!match) {
+            return null;
+        }
+        return {
+            major: parseInt(match[1]),
+            minor: parseInt(match[2]),
+        };
+    };
+    GLTFFileLoader._compareVersion = function (a, b) {
+        if (a.major > b.major) {
+            return 1;
+        }
+        if (a.major < b.major) {
+            return -1;
+        }
+        if (a.minor > b.minor) {
+            return 1;
+        }
+        if (a.minor < b.minor) {
+            return -1;
+        }
+        return 0;
+    };
+    /**
+     * @param message
+     * @hidden
+     */
+    GLTFFileLoader.prototype._logOpen = function (message) {
+        this._log(message);
+        this._logIndentLevel++;
+    };
+    /** @hidden */
+    GLTFFileLoader.prototype._logClose = function () {
+        --this._logIndentLevel;
+    };
+    GLTFFileLoader.prototype._logEnabled = function (message) {
+        var spaces = GLTFFileLoader._logSpaces.substr(0, this._logIndentLevel * 2);
+        core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Logger.Log("".concat(spaces).concat(message));
+    };
+    GLTFFileLoader.prototype._logDisabled = function (message) { };
+    GLTFFileLoader.prototype._startPerformanceCounterEnabled = function (counterName) {
+        core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Tools.StartPerformanceCounter(counterName);
+    };
+    GLTFFileLoader.prototype._startPerformanceCounterDisabled = function (counterName) { };
+    GLTFFileLoader.prototype._endPerformanceCounterEnabled = function (counterName) {
+        core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.Tools.EndPerformanceCounter(counterName);
+    };
+    GLTFFileLoader.prototype._endPerformanceCounterDisabled = function (counterName) { };
+    // ----------
+    // V1 options
+    // ----------
+    /**
+     * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
+     * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
+     * Defaults to true.
+     * @hidden
+     */
+    GLTFFileLoader.IncrementalLoading = true;
+    /**
+     * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
+     * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
+     * @hidden
+     */
+    GLTFFileLoader.HomogeneousCoordinates = false;
+    GLTFFileLoader._MagicBase64Encoded = "Z2xURg"; // "glTF" base64 encoded (without the quotes!)
+    GLTFFileLoader._logSpaces = "                                ";
+    return GLTFFileLoader;
+}());
+
+if (core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.SceneLoader) {
+    core_Misc_observable__WEBPACK_IMPORTED_MODULE_0__.SceneLoader.RegisterPlugin(new GLTFFileLoader());
+}
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/glTFValidation.js":
+/*!********************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/glTFValidation.js ***!
+  \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFValidation": () => (/* binding */ GLTFValidation)
+/* harmony export */ });
+/* harmony import */ var core_Misc_tools__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/tools */ "core/Misc/observable");
+/* harmony import */ var core_Misc_tools__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Misc_tools__WEBPACK_IMPORTED_MODULE_0__);
+
+function validateAsync(data, rootUrl, fileName, getExternalResource) {
+    var options = {
+        externalResourceFunction: function (uri) { return getExternalResource(uri).then(function (value) { return new Uint8Array(value); }); },
+    };
+    if (fileName) {
+        options.uri = rootUrl === "file:" ? fileName : rootUrl + fileName;
+    }
+    return data instanceof ArrayBuffer ? GLTFValidator.validateBytes(new Uint8Array(data), options) : GLTFValidator.validateString(data, options);
+}
+/**
+ * The worker function that gets converted to a blob url to pass into a worker.
+ */
+function workerFunc() {
+    var pendingExternalResources = [];
+    onmessage = function (message) {
+        var data = message.data;
+        switch (data.id) {
+            case "init": {
+                importScripts(data.url);
+                break;
+            }
+            case "validate": {
+                validateAsync(data.data, data.rootUrl, data.fileName, function (uri) {
+                    return new Promise(function (resolve, reject) {
+                        var index = pendingExternalResources.length;
+                        pendingExternalResources.push({ resolve: resolve, reject: reject });
+                        postMessage({ id: "getExternalResource", index: index, uri: uri });
+                    });
+                }).then(function (value) {
+                    postMessage({ id: "validate.resolve", value: value });
+                }, function (reason) {
+                    postMessage({ id: "validate.reject", reason: reason });
+                });
+                break;
+            }
+            case "getExternalResource.resolve": {
+                pendingExternalResources[data.index].resolve(data.value);
+                break;
+            }
+            case "getExternalResource.reject": {
+                pendingExternalResources[data.index].reject(data.reason);
+                break;
+            }
+        }
+    };
+}
+/**
+ * glTF validation
+ */
+var GLTFValidation = /** @class */ (function () {
+    function GLTFValidation() {
+    }
+    /**
+     * Validate a glTF asset using the glTF-Validator.
+     * @param data The JSON of a glTF or the array buffer of a binary glTF
+     * @param rootUrl The root url for the glTF
+     * @param fileName The file name for the glTF
+     * @param getExternalResource The callback to get external resources for the glTF validator
+     * @returns A promise that resolves with the glTF validation results once complete
+     */
+    GLTFValidation.ValidateAsync = function (data, rootUrl, fileName, getExternalResource) {
+        var _this = this;
+        if (typeof Worker === "function") {
+            return new Promise(function (resolve, reject) {
+                var workerContent = "".concat(validateAsync, "(").concat(workerFunc, ")()");
+                var workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: "application/javascript" }));
+                var worker = new Worker(workerBlobUrl);
+                var onError = function (error) {
+                    worker.removeEventListener("error", onError);
+                    worker.removeEventListener("message", onMessage);
+                    reject(error);
+                };
+                var onMessage = function (message) {
+                    var data = message.data;
+                    switch (data.id) {
+                        case "getExternalResource": {
+                            getExternalResource(data.uri).then(function (value) {
+                                worker.postMessage({ id: "getExternalResource.resolve", index: data.index, value: value }, [value]);
+                            }, function (reason) {
+                                worker.postMessage({ id: "getExternalResource.reject", index: data.index, reason: reason });
+                            });
+                            break;
+                        }
+                        case "validate.resolve": {
+                            worker.removeEventListener("error", onError);
+                            worker.removeEventListener("message", onMessage);
+                            resolve(data.value);
+                            worker.terminate();
+                            break;
+                        }
+                        case "validate.reject": {
+                            worker.removeEventListener("error", onError);
+                            worker.removeEventListener("message", onMessage);
+                            reject(data.reason);
+                            worker.terminate();
+                        }
+                    }
+                };
+                worker.addEventListener("error", onError);
+                worker.addEventListener("message", onMessage);
+                worker.postMessage({ id: "init", url: _this.Configuration.url });
+                worker.postMessage({ id: "validate", data: data, rootUrl: rootUrl, fileName: fileName });
+            });
+        }
+        else {
+            if (!this._LoadScriptPromise) {
+                this._LoadScriptPromise = core_Misc_tools__WEBPACK_IMPORTED_MODULE_0__.Tools.LoadScriptAsync(this.Configuration.url);
+            }
+            return this._LoadScriptPromise.then(function () {
+                return validateAsync(data, rootUrl, fileName, getExternalResource);
+            });
+        }
+    };
+    /**
+     * The configuration. Defaults to `{ url: "https://preview.babylonjs.com/gltf_validator.js" }`.
+     */
+    GLTFValidation.Configuration = {
+        url: "https://preview.babylonjs.com/gltf_validator.js",
+    };
+    return GLTFValidation;
+}());
+
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/legacy/legacy-glTF.js":
+/*!*******************************************************!*\
+  !*** ../../../lts/loaders/dist/legacy/legacy-glTF.js ***!
+  \*******************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTFFileLoader": () => (/* reexport safe */ _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFFileLoader),
+/* harmony export */   "GLTFLoaderAnimationStartMode": () => (/* reexport safe */ _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderAnimationStartMode),
+/* harmony export */   "GLTFLoaderCoordinateSystemMode": () => (/* reexport safe */ _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderCoordinateSystemMode),
+/* harmony export */   "GLTFLoaderState": () => (/* reexport safe */ _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderState),
+/* harmony export */   "GLTFValidation": () => (/* reexport safe */ _glTF_glTFValidation__WEBPACK_IMPORTED_MODULE_1__.GLTFValidation)
+/* harmony export */ });
+/* harmony import */ var _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTF/glTFFileLoader */ "../../../lts/loaders/dist/glTF/glTFFileLoader.js");
+/* harmony import */ var _glTF_glTFValidation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../glTF/glTFValidation */ "../../../lts/loaders/dist/glTF/glTFValidation.js");
+
+
+/**
+ * This is the entry point for the UMD module.
+ * The entry point for a future ESM package should be index.ts
+ */
+var globalObject = typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof window !== "undefined" ? window : undefined;
+if (typeof globalObject !== "undefined") {
+    globalObject.BABYLON = globalObject.BABYLON || {};
+    for (var key in _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__) {
+        globalObject.BABYLON[key] = _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__[key];
+    }
+    for (var key in _glTF_glTFValidation__WEBPACK_IMPORTED_MODULE_1__) {
+        globalObject.BABYLON[key] = _glTF_glTFValidation__WEBPACK_IMPORTED_MODULE_1__[key];
+    }
+}
+
+
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/legacy/legacy-glTF1.js":
+/*!********************************************************!*\
+  !*** ../../../lts/loaders/dist/legacy/legacy-glTF1.js ***!
+  \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTF1": () => (/* reexport module object */ _glTF_1_0_index__WEBPACK_IMPORTED_MODULE_0__)
+/* harmony export */ });
+/* harmony import */ var _glTF_1_0_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTF/1.0/index */ "../../../lts/loaders/dist/glTF/1.0/index.js");
+/* eslint-disable import/no-internal-modules */
+
+/**
+ * This is the entry point for the UMD module.
+ * The entry point for a future ESM package should be index.ts
+ */
+var globalObject = typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof window !== "undefined" ? window : undefined;
+if (typeof globalObject !== "undefined") {
+    globalObject.BABYLON = globalObject.BABYLON || {};
+    globalObject.BABYLON.GLTF1 = globalObject.BABYLON.GLTF1 || {};
+    for (var key in _glTF_1_0_index__WEBPACK_IMPORTED_MODULE_0__) {
+        globalObject.BABYLON.GLTF1[key] = _glTF_1_0_index__WEBPACK_IMPORTED_MODULE_0__[key];
+    }
+}
+
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/legacy/legacy-glTF1FileLoader.js":
+/*!******************************************************************!*\
+  !*** ../../../lts/loaders/dist/legacy/legacy-glTF1FileLoader.js ***!
+  \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLTF1": () => (/* reexport safe */ _legacy_glTF1__WEBPACK_IMPORTED_MODULE_1__.GLTF1),
+/* harmony export */   "GLTFFileLoader": () => (/* reexport safe */ _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__.GLTFFileLoader),
+/* harmony export */   "GLTFLoaderAnimationStartMode": () => (/* reexport safe */ _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderAnimationStartMode),
+/* harmony export */   "GLTFLoaderCoordinateSystemMode": () => (/* reexport safe */ _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderCoordinateSystemMode),
+/* harmony export */   "GLTFLoaderState": () => (/* reexport safe */ _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderState),
+/* harmony export */   "GLTFValidation": () => (/* reexport safe */ _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__.GLTFValidation)
+/* harmony export */ });
+/* harmony import */ var _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./legacy-glTF */ "../../../lts/loaders/dist/legacy/legacy-glTF.js");
+/* harmony import */ var _legacy_glTF1__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./legacy-glTF1 */ "../../../lts/loaders/dist/legacy/legacy-glTF1.js");
+// eslint-disable-next-line import/export
+
+
+
+
+/***/ }),
+
+/***/ "core/Misc/observable":
+/*!****************************************************************************************************!*\
+  !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!
+  \****************************************************************************************************/
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE_core_Misc_observable__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+/*!********************************!*\
+  !*** ./src/glTF1FileLoader.ts ***!
+  \********************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   "loaders": () => (/* reexport module object */ loaders_legacy_legacy_glTF1FileLoader__WEBPACK_IMPORTED_MODULE_0__)
+/* harmony export */ });
+/* harmony import */ var loaders_legacy_legacy_glTF1FileLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! loaders/legacy/legacy-glTF1FileLoader */ "../../../lts/loaders/dist/legacy/legacy-glTF1FileLoader.js");
+// eslint-disable-next-line import/export
+
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (loaders_legacy_legacy_glTF1FileLoader__WEBPACK_IMPORTED_MODULE_0__);
+
+})();
+
+__webpack_exports__ = __webpack_exports__["default"];
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=babylon.glTF1FileLoader.js.map