text: /// <reference path="../../../dist/preview release/babylon.d.ts"/>
  /// <reference path="../../../dist/preview release/glTF2Interface/babylon.glTF2Interface.d.ts"/>
  var BABYLON;
  (function (BABYLON) {
      /**
       * 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 = BABYLON.GLTFLoaderCoordinateSystemMode || (BABYLON.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 = BABYLON.GLTFLoaderAnimationStartMode || (BABYLON.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 = BABYLON.GLTFLoaderState || (BABYLON.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 BABYLON.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;
              /**
               * Function called before loading a url referenced by the asset.
               */
              this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
              /**
               * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
               */
              this.onMeshLoadedObservable = new BABYLON.Observable();
              /**
               * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
               */
              this.onTextureLoadedObservable = new BABYLON.Observable();
              /**
               * Observable raised when the loader creates a material after parsing the glTF properties of the material.
               */
              this.onMaterialLoadedObservable = new BABYLON.Observable();
              /**
               * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
               */
              this.onCameraLoadedObservable = new BABYLON.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 BABYLON.Observable();
              /**
               * Observable raised when an error occurs.
               */
              this.onErrorObservable = new BABYLON.Observable();
              /**
               * Observable raised after the loader is disposed.
               */
              this.onDisposeObservable = new BABYLON.Observable();
              /**
               * Observable raised after a loader extension is created.
               * Set additional options for a loader extension in this event.
               */
              this.onExtensionLoadedObservable = new BABYLON.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 BABYLON.Observable();
              this._loader = null;
              /**
               * Name of the loader ("gltf")
               */
              this.name = "gltf";
              /**
               * Supported file extensions of the loader (.gltf, .glb)
               */
              this.extensions = {
                  ".gltf": { isBinary: false },
                  ".glb": { isBinary: true }
              };
              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: true,
              configurable: true
          });
          Object.defineProperty(GLTFFileLoader.prototype, "onMeshLoaded", {
              /**
               * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
               */
              set: function (callback) {
                  if (this._onMeshLoadedObserver) {
                      this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);
                  }
                  this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);
              },
              enumerable: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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: true,
              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;
              }
              this._clear();
              this.onDisposeObservable.notifyObservers(undefined);
              this.onDisposeObservable.clear();
          };
          /** @hidden */
          GLTFFileLoader.prototype._clear = function () {
              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();
          };
          /**
           * Imports one or more meshes from the loaded glTF data 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 data the glTF data to load
           * @param rootUrl root url to load from
           * @param onProgress event that fires when loading progress has occured
           * @param fileName Defines the name of the file to load
           * @returns a promise containg the loaded meshes, particles, skeletons and animations
           */
          GLTFFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress, fileName) {
              var _this = this;
              return this._parseAsync(scene, data, rootUrl, fileName).then(function (loaderData) {
                  _this._log("Loading " + (fileName || ""));
                  _this._loader = _this._getLoader(loaderData);
                  return _this._loader.importMeshAsync(meshesNames, scene, loaderData, rootUrl, onProgress, fileName);
              });
          };
          /**
           * Imports all objects from the loaded glTF data and adds them to the scene
           * @param scene the scene the objects should be added to
           * @param data the glTF data to load
           * @param rootUrl root url to load from
           * @param onProgress event that fires when loading progress has occured
           * @param fileName Defines the name of the file to load
           * @returns a promise which completes when objects have been loaded to the scene
           */
          GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
              var _this = this;
              return this._parseAsync(scene, data, rootUrl, fileName).then(function (loaderData) {
                  _this._log("Loading " + (fileName || ""));
                  _this._loader = _this._getLoader(loaderData);
                  return _this._loader.loadAsync(scene, loaderData, rootUrl, onProgress, fileName);
              });
          };
          /**
           * Load into an asset container.
           * @param scene The scene to load into
           * @param data The data to import
           * @param rootUrl The root url for scene and resources
           * @param onProgress The callback when the load progresses
           * @param fileName Defines the name of the file to load
           * @returns The loaded asset container
           */
          GLTFFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl, onProgress, fileName) {
              var _this = this;
              return this._parseAsync(scene, data, rootUrl, fileName).then(function (loaderData) {
                  _this._log("Loading " + (fileName || ""));
                  _this._loader = _this._getLoader(loaderData);
                  return _this._loader.importMeshAsync(null, scene, loaderData, rootUrl, onProgress, fileName).then(function (result) {
                      var container = new BABYLON.AssetContainer(scene);
                      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);
                      container.removeAllFromScene();
                      return container;
                  });
              });
          };
          /**
           * If the data string can be loaded directly.
           * @param data string contianing the file data
           * @returns if the data can be loaded directly
           */
          GLTFFileLoader.prototype.canDirectLoad = function (data) {
              return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1));
          };
          /**
           * Instantiates a glTF file loader plugin.
           * @returns the created plugin
           */
          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._loader ? this._loader.state : null;
              },
              enumerable: true,
              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);
                  });
              });
          };
          GLTFFileLoader.prototype._parseAsync = function (scene, data, rootUrl, fileName) {
              var _this = this;
              return Promise.resolve().then(function () {
                  var unpacked = (data instanceof ArrayBuffer) ? _this._unpackBinary(data) : { json: data, bin: null };
                  return _this._validateAsync(scene, unpacked.json, rootUrl, fileName).then(function () {
                      _this._startPerformanceCounter("Parse JSON");
                      _this._log("JSON length: " + unpacked.json.length);
                      var loaderData = {
                          json: JSON.parse(unpacked.json),
                          bin: unpacked.bin
                      };
                      _this._endPerformanceCounter("Parse JSON");
                      _this.onParsedObservable.notifyObservers(loaderData);
                      _this.onParsedObservable.clear();
                      return loaderData;
                  });
              });
          };
          GLTFFileLoader.prototype._validateAsync = function (scene, json, rootUrl, fileName) {
              var _this = this;
              if (!this.validate || typeof GLTFValidator === "undefined") {
                  return Promise.resolve();
              }
              this._startPerformanceCounter("Validate JSON");
              var options = {
                  externalResourceFunction: function (uri) {
                      return _this.preprocessUrlAsync(rootUrl + uri)
                          .then(function (url) { return scene._loadFileAsync(url, true, true); })
                          .then(function (data) { return new Uint8Array(data); });
                  }
              };
              if (fileName && fileName.substr(0, 5) !== "data:") {
                  options.uri = (rootUrl === "file:" ? fileName : "" + rootUrl + fileName);
              }
              return GLTFValidator.validateString(json, options).then(function (result) {
                  _this._endPerformanceCounter("Validate JSON");
                  _this.onValidatedObservable.notifyObservers(result);
                  _this.onValidatedObservable.clear();
              }, function (reason) {
                  _this._endPerformanceCounter("Validate JSON");
                  BABYLON.Tools.Warn("Failed to validate: " + reason);
                  _this.onValidatedObservable.clear();
              });
          };
          GLTFFileLoader.prototype._getLoader = function (loaderData) {
              var asset = loaderData.json.asset || {};
              this._log("Asset version: " + asset.version);
              asset.minVersion && this._log("Asset minimum version: " + asset.minVersion);
              asset.generator && this._log("Asset generator: " + 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._CreateGLTFLoaderV1,
                  2: GLTFFileLoader._CreateGLTFLoaderV2
              };
              var createLoader = createLoaders[version.major];
              if (!createLoader) {
                  throw new Error("Unsupported version: " + asset.version);
              }
              return createLoader(this);
          };
          GLTFFileLoader.prototype._unpackBinary = function (data) {
              this._startPerformanceCounter("Unpack binary");
              this._log("Binary length: " + data.byteLength);
              var Binary = {
                  Magic: 0x46546C67
              };
              var binaryReader = new BinaryReader(data);
              var magic = binaryReader.readUint32();
              if (magic !== Binary.Magic) {
                  throw new Error("Unexpected magic: " + magic);
              }
              var version = binaryReader.readUint32();
              if (this.loggingEnabled) {
                  this._log("Binary version: " + version);
              }
              var unpacked;
              switch (version) {
                  case 1: {
                      unpacked = this._unpackBinaryV1(binaryReader);
                      break;
                  }
                  case 2: {
                      unpacked = this._unpackBinaryV2(binaryReader);
                      break;
                  }
                  default: {
                      throw new Error("Unsupported version: " + version);
                  }
              }
              this._endPerformanceCounter("Unpack binary");
              return unpacked;
          };
          GLTFFileLoader.prototype._unpackBinaryV1 = function (binaryReader) {
              var ContentFormat = {
                  JSON: 0
              };
              var length = binaryReader.readUint32();
              if (length != binaryReader.getLength()) {
                  throw new Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
              }
              var contentLength = binaryReader.readUint32();
              var contentFormat = binaryReader.readUint32();
              var content;
              switch (contentFormat) {
                  case ContentFormat.JSON: {
                      content = GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(contentLength));
                      break;
                  }
                  default: {
                      throw new Error("Unexpected content format: " + contentFormat);
                  }
              }
              var bytesRemaining = binaryReader.getLength() - binaryReader.getPosition();
              var body = binaryReader.readUint8Array(bytesRemaining);
              return {
                  json: content,
                  bin: body
              };
          };
          GLTFFileLoader.prototype._unpackBinaryV2 = function (binaryReader) {
              var ChunkFormat = {
                  JSON: 0x4E4F534A,
                  BIN: 0x004E4942
              };
              var length = binaryReader.readUint32();
              if (length !== binaryReader.getLength()) {
                  throw new Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
              }
              // JSON chunk
              var chunkLength = binaryReader.readUint32();
              var chunkFormat = binaryReader.readUint32();
              if (chunkFormat !== ChunkFormat.JSON) {
                  throw new Error("First chunk format is not JSON");
              }
              var json = GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(chunkLength));
              // Look for BIN chunk
              var bin = null;
              while (binaryReader.getPosition() < binaryReader.getLength()) {
                  var chunkLength_1 = binaryReader.readUint32();
                  var chunkFormat_1 = binaryReader.readUint32();
                  switch (chunkFormat_1) {
                      case ChunkFormat.JSON: {
                          throw new Error("Unexpected JSON chunk");
                      }
                      case ChunkFormat.BIN: {
                          bin = binaryReader.readUint8Array(chunkLength_1);
                          break;
                      }
                      default: {
                          // ignore unrecognized chunkFormat
                          binaryReader.skipBytes(chunkLength_1);
                          break;
                      }
                  }
              }
              return {
                  json: json,
                  bin: bin
              };
          };
          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;
          };
          GLTFFileLoader._decodeBufferToText = function (buffer) {
              var result = "";
              var length = buffer.byteLength;
              for (var i = 0; i < length; i++) {
                  result += String.fromCharCode(buffer[i]);
              }
              return result;
          };
          /** @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);
              BABYLON.Tools.Log("" + spaces + message);
          };
          GLTFFileLoader.prototype._logDisabled = function (message) {
          };
          GLTFFileLoader.prototype._startPerformanceCounterEnabled = function (counterName) {
              BABYLON.Tools.StartPerformanceCounter(counterName);
          };
          GLTFFileLoader.prototype._startPerformanceCounterDisabled = function (counterName) {
          };
          GLTFFileLoader.prototype._endPerformanceCounterEnabled = function (counterName) {
              BABYLON.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._logSpaces = "                                ";
          return GLTFFileLoader;
      }());
      BABYLON.GLTFFileLoader = GLTFFileLoader;
      var BinaryReader = /** @class */ (function () {
          function BinaryReader(arrayBuffer) {
              this._arrayBuffer = arrayBuffer;
              this._dataView = new DataView(arrayBuffer);
              this._byteOffset = 0;
          }
          BinaryReader.prototype.getPosition = function () {
              return this._byteOffset;
          };
          BinaryReader.prototype.getLength = function () {
              return this._arrayBuffer.byteLength;
          };
          BinaryReader.prototype.readUint32 = function () {
              var value = this._dataView.getUint32(this._byteOffset, true);
              this._byteOffset += 4;
              return value;
          };
          BinaryReader.prototype.readUint8Array = function (length) {
              var value = new Uint8Array(this._arrayBuffer, this._byteOffset, length);
              this._byteOffset += length;
              return value;
          };
          BinaryReader.prototype.skipBytes = function (length) {
              this._byteOffset += length;
          };
          return BinaryReader;
      }());
      if (BABYLON.SceneLoader) {
          BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader());
      }
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFFileLoader.js.map
  
  /// <reference path="../../../../dist/preview release/babylon.d.ts"/>
  var BABYLON;
  (function (BABYLON) {
      var GLTF1;
      (function (GLTF1) {
          /**
          * Enums
          */
          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 = GLTF1.EComponentType || (GLTF1.EComponentType = {}));
          var EShaderType;
          (function (EShaderType) {
              EShaderType[EShaderType["FRAGMENT"] = 35632] = "FRAGMENT";
              EShaderType[EShaderType["VERTEX"] = 35633] = "VERTEX";
          })(EShaderType = GLTF1.EShaderType || (GLTF1.EShaderType = {}));
          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 = GLTF1.EParameterType || (GLTF1.EParameterType = {}));
          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 = GLTF1.ETextureWrapMode || (GLTF1.ETextureWrapMode = {}));
          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 = GLTF1.ETextureFilterType || (GLTF1.ETextureFilterType = {}));
          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 = GLTF1.ETextureFormat || (GLTF1.ETextureFormat = {}));
          var ECullingType;
          (function (ECullingType) {
              ECullingType[ECullingType["FRONT"] = 1028] = "FRONT";
              ECullingType[ECullingType["BACK"] = 1029] = "BACK";
              ECullingType[ECullingType["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
          })(ECullingType = GLTF1.ECullingType || (GLTF1.ECullingType = {}));
          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 = GLTF1.EBlendingFunction || (GLTF1.EBlendingFunction = {}));
      })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFLoaderInterfaces.js.map
  
  /// <reference path="../../../../dist/preview release/babylon.d.ts"/>
  var BABYLON;
  (function (BABYLON) {
      var GLTF1;
      (function (GLTF1) {
          /**
          * 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
          */
          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
          */
          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
          */
          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 = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
                      var bufferOutput = GLTF1.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) {
                          BABYLON.Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetID + " to attach to");
                          continue;
                      }
                      var isBone = targetNode instanceof BABYLON.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 = BABYLON.Animation.ANIMATIONTYPE_MATRIX;
                      if (!isBone) {
                          if (targetPath === "rotationQuaternion") {
                              animationType = BABYLON.Animation.ANIMATIONTYPE_QUATERNION;
                              targetNode.rotationQuaternion = new BABYLON.Quaternion();
                          }
                          else {
                              animationType = BABYLON.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) {
                          babylonAnimation = new BABYLON.Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, BABYLON.Animation.ANIMATIONLOOPMODE_CYCLE);
                      }
                      // For each frame
                      for (var j = 0; j < bufferInput.length; j++) {
                          var value = null;
                          if (targetPath === "rotationQuaternion") { // VEC4
                              value = BABYLON.Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
                              arrayOffset += 4;
                          }
                          else { // Position and scaling are VEC3
                              value = BABYLON.Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
                              arrayOffset += 3;
                          }
                          if (isBone) {
                              var bone = targetNode;
                              var translation = BABYLON.Vector3.Zero();
                              var rotationQuaternion = new BABYLON.Quaternion();
                              var scaling = BABYLON.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 = BABYLON.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
          */
          var configureBoneTransformation = function (node) {
              var mat = null;
              if (node.translation || node.rotation || node.scale) {
                  var scale = BABYLON.Vector3.FromArray(node.scale || [1, 1, 1]);
                  var rotation = BABYLON.Quaternion.FromArray(node.rotation || [0, 0, 0, 1]);
                  var position = BABYLON.Vector3.FromArray(node.translation || [0, 0, 0]);
                  mat = BABYLON.Matrix.Compose(scale, rotation, position);
              }
              else {
                  mat = BABYLON.Matrix.FromArray(node.matrix);
              }
              return mat;
          };
          /**
          * Returns the parent bone
          */
          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 BABYLON.Bone(node.name || "", newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
                          bone.id = nde;
                          return bone;
                      }
                  }
              }
              return null;
          };
          /**
          * Returns the appropriate root node
          */
          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
          */
          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
          */
          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
          */
          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 BABYLON.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
          */
          var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton, id) {
              if (!newSkeleton) {
                  newSkeleton = new BABYLON.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) {
                      BABYLON.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) {
                          BABYLON.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 BABYLON.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
          */
          var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
              if (!newMesh) {
                  newMesh = new BABYLON.Mesh(node.name || "", gltfRuntime.scene);
                  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 BABYLON.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 = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
                          if (semantic === "NORMAL") {
                              tempVertexData.normals = new Float32Array(buffer.length);
                              tempVertexData.normals.set(buffer);
                          }
                          else if (semantic === "POSITION") {
                              if (BABYLON.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 = BABYLON.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 = GLTF1.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 ? GLTF1.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;
              if (subMaterials.length > 1) {
                  material = new BABYLON.MultiMaterial("multimat" + id, gltfRuntime.scene);
                  material.subMaterials = subMaterials;
              }
              else {
                  material = new BABYLON.StandardMaterial("multimat" + id, gltfRuntime.scene);
              }
              if (subMaterials.length === 1) {
                  material = subMaterials[0];
              }
              if (!newMesh.material) {
                  newMesh.material = material;
              }
              // Apply geometry
              new BABYLON.Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
              newMesh.computeWorldMatrix(true);
              // 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;
                      }
                      BABYLON.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
          */
          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
          */
          var configureNodeFromMatrix = function (newNode, node, parent) {
              if (node.matrix) {
                  var position = new BABYLON.Vector3(0, 0, 0);
                  var rotation = new BABYLON.Quaternion();
                  var scaling = new BABYLON.Vector3(0, 0, 0);
                  var mat = BABYLON.Matrix.FromArray(node.matrix);
                  mat.decompose(scaling, rotation, position);
                  configureNode(newNode, position, rotation, scaling);
              }
              else if (node.translation && node.rotation && node.scale) {
                  configureNode(newNode, BABYLON.Vector3.FromArray(node.translation), BABYLON.Quaternion.FromArray(node.rotation), BABYLON.Vector3.FromArray(node.scale));
              }
              newNode.computeWorldMatrix(true);
          };
          /**
          * Imports a node
          */
          var importNode = function (gltfRuntime, node, id, parent) {
              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, node.skin);
                          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 BABYLON.HemisphericLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
                          hemiLight.name = node.name || "";
                          if (ambienLight.color) {
                              hemiLight.diffuse = BABYLON.Color3.FromArray(ambienLight.color);
                          }
                          lastNode = hemiLight;
                      }
                      else if (light.type === "directional") {
                          var directionalLight = light[light.type];
                          var dirLight = new BABYLON.DirectionalLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
                          dirLight.name = node.name || "";
                          if (directionalLight.color) {
                              dirLight.diffuse = BABYLON.Color3.FromArray(directionalLight.color);
                          }
                          lastNode = dirLight;
                      }
                      else if (light.type === "point") {
                          var pointLight = light[light.type];
                          var ptLight = new BABYLON.PointLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
                          ptLight.name = node.name || "";
                          if (pointLight.color) {
                              ptLight.diffuse = BABYLON.Color3.FromArray(pointLight.color);
                          }
                          lastNode = ptLight;
                      }
                      else if (light.type === "spot") {
                          var spotLight = light[light.type];
                          var spLight = new BABYLON.SpotLight(node.light, BABYLON.Vector3.Zero(), BABYLON.Vector3.Zero(), 0, 0, gltfRuntime.scene);
                          spLight.name = node.name || "";
                          if (spotLight.color) {
                              spLight.diffuse = BABYLON.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) {
                      if (camera.type === "orthographic") {
                          var orthoCamera = new BABYLON.FreeCamera(node.camera, BABYLON.Vector3.Zero(), gltfRuntime.scene, false);
                          orthoCamera.name = node.name || "";
                          orthoCamera.mode = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
                          orthoCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
                          lastNode = orthoCamera;
                      }
                      else if (camera.type === "perspective") {
                          var perspectiveCamera = camera[camera.type];
                          var persCamera = new BABYLON.FreeCamera(node.camera, BABYLON.Vector3.Zero(), gltfRuntime.scene, false);
                          persCamera.name = node.name || "";
                          persCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
                          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;
                      }
                  }
              }
              // Empty node
              if (!node.jointName) {
                  if (node.babylonNode) {
                      return node.babylonNode;
                  }
                  else if (lastNode === null) {
                      var dummy = new BABYLON.Mesh(node.name || "", gltfRuntime.scene);
                      node.babylonNode = dummy;
                      lastNode = dummy;
                  }
              }
              if (lastNode !== null) {
                  if (node.matrix && lastNode instanceof BABYLON.Mesh) {
                      configureNodeFromMatrix(lastNode, node, parent);
                  }
                  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, BABYLON.Vector3.FromArray(translation), BABYLON.Quaternion.FromArray(rotation), BABYLON.Vector3.FromArray(scale));
                  }
                  lastNode.updateCache(true);
                  node.babylonNode = lastNode;
              }
              return lastNode;
          };
          /**
          * Traverses nodes and creates them
          */
          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, parent);
                  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.)
          */
          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
          */
          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 === GLTF1.EParameterType.FLOAT_MAT2 || type === GLTF1.EParameterType.FLOAT_MAT3 || type === GLTF1.EParameterType.FLOAT_MAT4) {
                      if (uniform.semantic && !uniform.source && !uniform.node) {
                          GLTF1.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;
                          }
                          GLTF1.GLTFUtils.SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
                      }
                  }
                  else {
                      var value = materialValues[technique.uniforms[unif]];
                      if (!value) {
                          continue;
                      }
                      if (type === GLTF1.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 {
                          GLTF1.GLTFUtils.SetUniform((shaderMaterial.getEffect()), unif, value, type);
                      }
                  }
              }
              onSuccess(shaderMaterial);
          };
          /**
          * Prepare uniforms to send the only one time
          * Loads the appropriate textures
          */
          var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
              var materialValues = material.values || technique.parameters;
              var techniqueUniforms = technique.uniforms;
              /**
              * Prepare values here (not matrices)
              */
              for (var unif in unTreatedUniforms) {
                  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) {
                      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 === GLTF1.EParameterType.SAMPLER_2D) {
                      GLTF1.GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
                  }
                  // Others
                  else {
                      if (uniform.value && GLTF1.GLTFUtils.SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) {
                          // Static uniform
                          delete unTreatedUniforms[unif];
                      }
                  }
              }
          };
          /**
          * Shader compilation failed
          */
          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
          */
          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
          */
          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
          */
          var importMaterials = function (gltfRuntime) {
              // Create materials
              for (var mat in gltfRuntime.materials) {
                  GLTF1.GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function (material) { }, function () { });
              }
          };
          /**
          * Implementation of the base glTF spec
          */
          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: []
                  };
                  // 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 (BABYLON.Tools.IsBase64(buffer.uri)) {
                      setTimeout(function () { return onSuccess(new Uint8Array(BABYLON.Tools.DecodeBase64(buffer.uri))); });
                  }
                  else {
                      BABYLON.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 (BABYLON.Tools.IsBase64(source.uri)) {
                      setTimeout(function () { return onSuccess(new Uint8Array(BABYLON.Tools.DecodeBase64(source.uri))); });
                  }
                  else {
                      BABYLON.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, onError) {
                  var texture = gltfRuntime.textures[id];
                  if (texture.babylonTexture) {
                      onSuccess(texture.babylonTexture);
                      return;
                  }
                  var sampler = gltfRuntime.samplers[texture.sampler];
                  var createMipMaps = (sampler.minFilter === GLTF1.ETextureFilterType.NEAREST_MIPMAP_NEAREST) ||
                      (sampler.minFilter === GLTF1.ETextureFilterType.NEAREST_MIPMAP_LINEAR) ||
                      (sampler.minFilter === GLTF1.ETextureFilterType.LINEAR_MIPMAP_NEAREST) ||
                      (sampler.minFilter === GLTF1.ETextureFilterType.LINEAR_MIPMAP_LINEAR);
                  var samplingMode = BABYLON.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 BABYLON.Texture(blobURL, gltfRuntime.scene, !createMipMaps, true, samplingMode, revokeBlobURL, revokeBlobURL);
                  if (sampler.wrapS !== undefined) {
                      newTexture.wrapU = GLTF1.GLTFUtils.GetWrapMode(sampler.wrapS);
                  }
                  if (sampler.wrapT !== undefined) {
                      newTexture.wrapV = GLTF1.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 (BABYLON.Tools.IsBase64(shader.uri)) {
                      var shaderString = atob(shader.uri.split(",")[1]);
                      if (onSuccess) {
                          onSuccess(shaderString);
                      }
                  }
                  else {
                      BABYLON.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) {
                      var defaultMaterial = new BABYLON.StandardMaterial(id, gltfRuntime.scene);
                      defaultMaterial.diffuseColor = new BABYLON.Color3(0.5, 0.5, 0.5);
                      defaultMaterial.sideOrientation = BABYLON.Material.CounterClockWiseSideOrientation;
                      onSuccess(defaultMaterial);
                      return;
                  }
                  var program = gltfRuntime.programs[technique.program];
                  var states = technique.states;
                  var vertexShader = BABYLON.Effect.ShadersStore[program.vertexShader + "VertexShader"];
                  var pixelShader = BABYLON.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 === GLTF1.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
                  };
                  BABYLON.Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
                  BABYLON.Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
                  var shaderMaterial = new BABYLON.ShaderMaterial(id, gltfRuntime.scene, shaderPath, options);
                  shaderMaterial.onError = onShaderCompileError(program, shaderMaterial, onError);
                  shaderMaterial.onCompiled = onShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess);
                  shaderMaterial.sideOrientation = BABYLON.Material.CounterClockWiseSideOrientation;
                  if (states && states.functions) {
                      var functions = states.functions;
                      if (functions.cullFace && functions.cullFace[0] !== GLTF1.ECullingType.BACK) {
                          shaderMaterial.backFaceCulling = false;
                      }
                      var blendFunc = functions.blendFuncSeparate;
                      if (blendFunc) {
                          if (blendFunc[0] === GLTF1.EBlendingFunction.SRC_ALPHA && blendFunc[1] === GLTF1.EBlendingFunction.ONE_MINUS_SRC_ALPHA && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) {
                              shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_COMBINE;
                          }
                          else if (blendFunc[0] === GLTF1.EBlendingFunction.ONE && blendFunc[1] === GLTF1.EBlendingFunction.ONE && blendFunc[2] === GLTF1.EBlendingFunction.ZERO && blendFunc[3] === GLTF1.EBlendingFunction.ONE) {
                              shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_ONEONE;
                          }
                          else if (blendFunc[0] === GLTF1.EBlendingFunction.SRC_ALPHA && blendFunc[1] === GLTF1.EBlendingFunction.ONE && blendFunc[2] === GLTF1.EBlendingFunction.ZERO && blendFunc[3] === GLTF1.EBlendingFunction.ONE) {
                              shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_ADD;
                          }
                          else if (blendFunc[0] === GLTF1.EBlendingFunction.ZERO && blendFunc[1] === GLTF1.EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) {
                              shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_SUBTRACT;
                          }
                          else if (blendFunc[0] === GLTF1.EBlendingFunction.DST_COLOR && blendFunc[1] === GLTF1.EBlendingFunction.ZERO && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) {
                              shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_MULTIPLY;
                          }
                          else if (blendFunc[0] === GLTF1.EBlendingFunction.SRC_ALPHA && blendFunc[1] === GLTF1.EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) {
                              shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_MAXIMIZED;
                          }
                      }
                  }
              };
              return GLTFLoaderBase;
          }());
          GLTF1.GLTFLoaderBase = GLTFLoaderBase;
          /**
          * glTF V1 Loader
          */
          var GLTFLoader = /** @class */ (function () {
              function GLTFLoader() {
                  this.state = null;
              }
              GLTFLoader.RegisterExtension = function (extension) {
                  if (GLTFLoader.Extensions[extension.name]) {
                      BABYLON.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, onSuccess, onProgress, onError) {
                  var _this = this;
                  scene.useRightHandedSystem = true;
                  GLTF1.GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
                      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 = [];
                          BABYLON.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 BABYLON.AbstractMesh) {
                              meshes.push(node.babylonNode);
                          }
                      }
                      for (var skl in gltfRuntime.skins) {
                          var skin = gltfRuntime.skins[skl];
                          if (skin.babylonSkeleton instanceof BABYLON.Skeleton) {
                              skeletons.push(skin.babylonSkeleton);
                          }
                      }
                      // Load buffers, shaders, materials, etc.
                      _this._loadBuffersAsync(gltfRuntime, function () {
                          _this._loadShadersAsync(gltfRuntime, function () {
                              importMaterials(gltfRuntime);
                              postLoad(gltfRuntime);
                              if (!BABYLON.GLTFFileLoader.IncrementalLoading && onSuccess) {
                                  onSuccess(meshes, skeletons);
                              }
                          });
                      }, onProgress);
                      if (BABYLON.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 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, data, rootUrl, onProgress) {
                  var _this = this;
                  return new Promise(function (resolve, reject) {
                      _this._importMeshAsync(meshesNames, scene, data, rootUrl, function (meshes, skeletons) {
                          resolve({
                              meshes: meshes,
                              particleSystems: [],
                              skeletons: skeletons,
                              animationGroups: []
                          });
                      }, onProgress, function (message) {
                          reject(new Error(message));
                      });
                  });
              };
              GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) {
                  var _this = this;
                  scene.useRightHandedSystem = true;
                  GLTF1.GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
                      // Load runtime extensios
                      GLTF1.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 (!BABYLON.GLTFFileLoader.IncrementalLoading) {
                                      onSuccess();
                                  }
                              });
                          });
                          if (BABYLON.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) {
                      GLTF1.GLTFLoaderExtension.LoadShaderStringAsync(gltfRuntime, sha, function (shaderString) {
                          if (shaderString instanceof ArrayBuffer) {
                              return;
                          }
                          gltfRuntime.loadedShaderCount++;
                          if (shaderString) {
                              BABYLON.Effect.ShadersStore[sha + (shader.type === GLTF1.EShaderType.VERTEX ? "VertexShader" : "PixelShader")] = shaderString;
                          }
                          if (gltfRuntime.loadedShaderCount === gltfRuntime.shaderscount) {
                              onload();
                          }
                      }, function () {
                          BABYLON.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 {
                          BABYLON.Tools.Error("No shader named: " + sha);
                      }
                  }
                  if (!hasShaders) {
                      onload();
                  }
              };
              GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad, onProgress) {
                  var hasBuffers = false;
                  var processBuffer = function (buf, buffer) {
                      GLTF1.GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
                          gltfRuntime.loadedBufferCount++;
                          if (bufferView) {
                              if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) {
                                  BABYLON.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 () {
                          BABYLON.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 {
                          BABYLON.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;
          }());
          GLTF1.GLTFLoader = GLTFLoader;
          BABYLON.GLTFFileLoader._CreateGLTFLoaderV1 = function () { return new GLTFLoader(); };
      })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFLoader.js.map
  
  /// <reference path="../../../../dist/preview release/babylon.d.ts"/>
  var BABYLON;
  (function (BABYLON) {
      var GLTF1;
      (function (GLTF1) {
          /**
          * Utils functions for GLTF
          */
          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 = BABYLON.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 = BABYLON.Matrix.Transpose(source.getWorldMatrix().invert());
                  }
                  else {
                      debugger;
                  }
                  if (mat) {
                      switch (parameter.type) {
                          case GLTF1.EParameterType.FLOAT_MAT2:
                              shaderMaterial.setMatrix2x2(uniformName, BABYLON.Matrix.GetAsMatrix2x2(mat));
                              break;
                          case GLTF1.EParameterType.FLOAT_MAT3:
                              shaderMaterial.setMatrix3x3(uniformName, BABYLON.Matrix.GetAsMatrix3x3(mat));
                              break;
                          case GLTF1.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 GLTF1.EParameterType.FLOAT:
                          shaderMaterial.setFloat(uniform, value);
                          return true;
                      case GLTF1.EParameterType.FLOAT_VEC2:
                          shaderMaterial.setVector2(uniform, BABYLON.Vector2.FromArray(value));
                          return true;
                      case GLTF1.EParameterType.FLOAT_VEC3:
                          shaderMaterial.setVector3(uniform, BABYLON.Vector3.FromArray(value));
                          return true;
                      case GLTF1.EParameterType.FLOAT_VEC4:
                          shaderMaterial.setVector4(uniform, BABYLON.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 GLTF1.ETextureWrapMode.CLAMP_TO_EDGE: return BABYLON.Texture.CLAMP_ADDRESSMODE;
                      case GLTF1.ETextureWrapMode.MIRRORED_REPEAT: return BABYLON.Texture.MIRROR_ADDRESSMODE;
                      case GLTF1.ETextureWrapMode.REPEAT: return BABYLON.Texture.WRAP_ADDRESSMODE;
                      default: return BABYLON.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 GLTF1.ETextureFilterType.LINEAR:
                      case GLTF1.ETextureFilterType.LINEAR_MIPMAP_NEAREST:
                      case GLTF1.ETextureFilterType.LINEAR_MIPMAP_LINEAR: return BABYLON.Texture.TRILINEAR_SAMPLINGMODE;
                      case GLTF1.ETextureFilterType.NEAREST:
                      case GLTF1.ETextureFilterType.NEAREST_MIPMAP_NEAREST: return BABYLON.Texture.NEAREST_SAMPLINGMODE;
                      default: return BABYLON.Texture.BILINEAR_SAMPLINGMODE;
                  }
              };
              GLTFUtils.GetBufferFromBufferView = function (gltfRuntime, bufferView, byteOffset, byteLength, componentType) {
                  var 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 GLTF1.EComponentType.BYTE: return new Int8Array(buffer, byteOffset, byteLength);
                      case GLTF1.EComponentType.UNSIGNED_BYTE: return new Uint8Array(buffer, byteOffset, byteLength);
                      case GLTF1.EComponentType.SHORT: return new Int16Array(buffer, byteOffset, byteLength);
                      case GLTF1.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) {
                      BABYLON.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");
                      BABYLON.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 BABYLON.ShaderMaterial("GLTFDefaultMaterial", scene, shaderPath, options);
                      GLTFUtils._DefaultMaterial.setColor4("u_emission", new BABYLON.Color4(0.5, 0.5, 0.5, 1.0));
                  }
                  return GLTFUtils._DefaultMaterial;
              };
              // The GLTF default material
              GLTFUtils._DefaultMaterial = null;
              return GLTFUtils;
          }());
          GLTF1.GLTFUtils = GLTFUtils;
      })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFLoaderUtils.js.map
  
  /// <reference path="../../../../dist/preview release/babylon.d.ts"/>
  var BABYLON;
  (function (BABYLON) {
      var GLTF1;
      (function (GLTF1) {
          var GLTFLoaderExtension = /** @class */ (function () {
              function GLTFLoaderExtension(name) {
                  this._name = name;
              }
              Object.defineProperty(GLTFLoaderExtension.prototype, "name", {
                  get: function () {
                      return this._name;
                  },
                  enumerable: true,
                  configurable: true
              });
              /**
              * Defines an override for loading the runtime
              * Return true to stop further extensions from loading the runtime
              */
              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
               */
              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
              */
              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
              */
              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
              */
              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
              */
              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
              */
              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(GLTF1.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 () {
                      GLTF1.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 () {
                      GLTF1.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 () {
                      GLTF1.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 () {
                      GLTF1.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 () {
                      GLTF1.GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
                  });
              };
              GLTFLoaderExtension.ApplyExtensions = function (func, defaultFunc) {
                  for (var extensionName in GLTF1.GLTFLoader.Extensions) {
                      var loaderExtension = GLTF1.GLTFLoader.Extensions[extensionName];
                      if (func(loaderExtension)) {
                          return;
                      }
                  }
                  defaultFunc();
              };
              return GLTFLoaderExtension;
          }());
          GLTF1.GLTFLoaderExtension = GLTFLoaderExtension;
      })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFLoaderExtension.js.map
  
  /// <reference path="../../../../dist/preview release/babylon.d.ts"/>
  var __extends = (this && this.__extends) || (function () {
      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 (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      }
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var BABYLON;
  (function (BABYLON) {
      var GLTF1;
      (function (GLTF1) {
          var BinaryExtensionBufferName = "binary_glTF";
          var GLTFBinaryExtension = /** @class */ (function (_super) {
              __extends(GLTFBinaryExtension, _super);
              function GLTFBinaryExtension() {
                  return _super.call(this, "KHR_binary_glTF") || this;
              }
              GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
                  var extensionsUsed = data.json.extensionsUsed;
                  if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) {
                      return false;
                  }
                  this._bin = data.bin;
                  onSuccess(GLTF1.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;
                  }
                  onSuccess(this._bin);
                  return true;
              };
              GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
                  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 = GLTF1.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, GLTF1.EComponentType.UNSIGNED_BYTE);
                  onSuccess(buffer);
                  return true;
              };
              GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
                  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 = GLTF1.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, GLTF1.EComponentType.UNSIGNED_BYTE);
                  setTimeout(function () {
                      var shaderString = GLTF1.GLTFUtils.DecodeBufferToText(shaderBytes);
                      onSuccess(shaderString);
                  });
                  return true;
              };
              return GLTFBinaryExtension;
          }(GLTF1.GLTFLoaderExtension));
          GLTF1.GLTFBinaryExtension = GLTFBinaryExtension;
          GLTF1.GLTFLoader.RegisterExtension(new GLTFBinaryExtension());
      })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFBinaryExtension.js.map
  
  /// <reference path="../../../../dist/preview release/babylon.d.ts"/>
  var __extends = (this && this.__extends) || (function () {
      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 (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      }
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var BABYLON;
  (function (BABYLON) {
      var GLTF1;
      (function (GLTF1) {
          var GLTFMaterialsCommonExtension = /** @class */ (function (_super) {
              __extends(GLTFMaterialsCommonExtension, _super);
              function GLTFMaterialsCommonExtension() {
                  return _super.call(this, "KHR_materials_common") || this;
              }
              GLTFMaterialsCommonExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
                  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 BABYLON.HemisphericLight(light.name, new BABYLON.Vector3(0, 1, 0), gltfRuntime.scene);
                                  var ambient = light.ambient;
                                  if (ambient) {
                                      ambientLight.diffuse = BABYLON.Color3.FromArray(ambient.color || [1, 1, 1]);
                                  }
                                  break;
                              case "point":
                                  var pointLight = new BABYLON.PointLight(light.name, new BABYLON.Vector3(10, 10, 10), gltfRuntime.scene);
                                  var point = light.point;
                                  if (point) {
                                      pointLight.diffuse = BABYLON.Color3.FromArray(point.color || [1, 1, 1]);
                                  }
                                  break;
                              case "directional":
                                  var dirLight = new BABYLON.DirectionalLight(light.name, new BABYLON.Vector3(0, -1, 0), gltfRuntime.scene);
                                  var directional = light.directional;
                                  if (directional) {
                                      dirLight.diffuse = BABYLON.Color3.FromArray(directional.color || [1, 1, 1]);
                                  }
                                  break;
                              case "spot":
                                  var spot = light.spot;
                                  if (spot) {
                                      var spotLight = new BABYLON.SpotLight(light.name, new BABYLON.Vector3(0, 10, 0), new BABYLON.Vector3(0, -1, 0), spot.fallOffAngle || Math.PI, spot.fallOffExponent || 0.0, gltfRuntime.scene);
                                      spotLight.diffuse = BABYLON.Color3.FromArray(spot.color || [1, 1, 1]);
                                  }
                                  break;
                              default:
                                  BABYLON.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 BABYLON.StandardMaterial(id, gltfRuntime.scene);
                  standardMaterial.sideOrientation = BABYLON.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 = BABYLON.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 = BABYLON.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 = BABYLON.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 = BABYLON.Color3.FromArray(extension.values.specular || [0, 0, 0]);
                  }
                  return true;
              };
              GLTFMaterialsCommonExtension.prototype._loadTexture = function (gltfRuntime, id, material, propertyPath, onError) {
                  // Create buffer from texture url
                  GLTF1.GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
                      // Create texture from buffer
                      GLTF1.GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, function (texture) { return material[propertyPath] = texture; }, onError);
                  }, onError);
              };
              return GLTFMaterialsCommonExtension;
          }(GLTF1.GLTFLoaderExtension));
          GLTF1.GLTFMaterialsCommonExtension = GLTFMaterialsCommonExtension;
          GLTF1.GLTFLoader.RegisterExtension(new GLTFMaterialsCommonExtension());
      })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
  })(BABYLON || (BABYLON = {}));
  
  //# sourceMappingURL=babylon.glTFMaterialsCommonExtension.js.map
  