@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoader.esm.js

@@ -0,0 +1,1562 @@
+import { Deferred as U } from "../../../core/Misc/deferred.esm.js";
+import { Vector3 as T, Quaternion as I, Matrix as P, TmpVectors as O } from "../../../core/Maths/math.vector.esm.js";
+import { Color3 as R } from "../../../core/Maths/math.color.esm.js";
+import { Tools as L } from "../../../core/Misc/tools.esm.js";
+import { Camera as W } from "../../../core/Cameras/camera.esm.js";
+import { FreeCamera as K } from "../../../core/Cameras/freeCamera.esm.js";
+import { AnimationKeyInterpolation as z } from "../../../core/Animations/animationKey.esm.js";
+import { AnimationGroup as H } from "../../../core/Animations/animationGroup.esm.js";
+import { Bone as X } from "../../../core/Bones/bone.esm.js";
+import { Skeleton as Z } from "../../../core/Bones/skeleton.esm.js";
+import { Material as C } from "../../../core/Materials/material.esm.js";
+import { PBRMaterial as M } from "../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { Texture as A } from "../../../core/Materials/Textures/texture.esm.js";
+import { TransformNode as k } from "../../../core/Meshes/transformNode.esm.js";
+import { VertexBuffer as p, Buffer as Q } from "../../../core/Buffers/buffer.esm.js";
+import { Geometry as J } from "../../../core/Meshes/geometry.esm.js";
+import { Mesh as V } from "../../../core/Meshes/mesh.esm.js";
+import { MorphTarget as Y } from "../../../core/Morph/morphTarget.esm.js";
+import { MorphTargetManager as j } from "../../../core/Morph/morphTargetManager.esm.js";
+import { GLTFFileLoader as q, GLTFLoaderState as x, GLTFLoaderCoordinateSystemMode as D, GLTFLoaderAnimationStartMode as B } from "../glTFFileLoader.esm.js";
+import { IsBase64DataUrl as ee, DecodeBase64UrlToBinary as te, LoadFileError as ne } from "../../../core/Misc/fileTools.esm.js";
+import { Logger as $ } from "../../../core/Misc/logger.esm.js";
+import { BoundingInfo as se } from "../../../core/Culling/boundingInfo.esm.js";
+import { nodeAnimationData as N } from "./glTFLoaderAnimation.esm.js";
+function F(...v) {
+  const t = (e) => e && typeof e == "object";
+  return v.reduce((e, n) => (Object.keys(n).forEach((s) => {
+    const r = e[s], o = n[s];
+    Array.isArray(r) && Array.isArray(o) ? e[s] = r.concat(...o) : t(r) && t(o) ? e[s] = F(r, o) : e[s] = o;
+  }), e), {});
+}
+class c {
+  /**
+   * Gets an item from the given array.
+   * @param context The context when loading the asset
+   * @param array The array to get the item from
+   * @param index The index to the array
+   * @returns The array item
+   */
+  static Get(t, e, n) {
+    if (!e || n == null || !e[n])
+      throw new Error(`${t}: Failed to find index (${n})`);
+    return e[n];
+  }
+  /**
+   * Assign an `index` field to each item of the given array.
+   * @param array The array of items
+   */
+  static Assign(t) {
+    if (t)
+      for (let e = 0; e < t.length; e++)
+        t[e].index = e;
+  }
+}
+class u {
+  /**
+   * Registers a loader extension.
+   * @param name The name of the loader extension.
+   * @param factory The factory function that creates the loader extension.
+   */
+  static RegisterExtension(t, e) {
+    u.UnregisterExtension(t) && $.Warn(`Extension with the name '${t}' already exists`), u._RegisteredExtensions[t] = {
+      factory: e
+    };
+  }
+  /**
+   * Unregisters a loader extension.
+   * @param name The name of the loader extension.
+   * @returns A boolean indicating whether the extension has been unregistered
+   */
+  static UnregisterExtension(t) {
+    return u._RegisteredExtensions[t] ? (delete u._RegisteredExtensions[t], !0) : !1;
+  }
+  /**
+   * The object that represents the glTF JSON.
+   */
+  get gltf() {
+    if (!this._gltf)
+      throw new Error("glTF JSON is not available");
+    return this._gltf;
+  }
+  /**
+   * The BIN chunk of a binary glTF.
+   */
+  get bin() {
+    return this._bin;
+  }
+  /**
+   * The parent file loader.
+   */
+  get parent() {
+    return this._parent;
+  }
+  /**
+   * The Babylon scene when loading the asset.
+   */
+  get babylonScene() {
+    if (!this._babylonScene)
+      throw new Error("Scene is not available");
+    return this._babylonScene;
+  }
+  /**
+   * The root Babylon mesh when loading the asset.
+   */
+  get rootBabylonMesh() {
+    return this._rootBabylonMesh;
+  }
+  /**
+   * @internal
+   */
+  constructor(t) {
+    this._completePromises = new Array(), this._assetContainer = null, this._babylonLights = [], this._disableInstancedMesh = 0, this._extensions = new Array(), this._disposed = !1, this._rootUrl = null, this._fileName = null, this._uniqueRootUrl = null, this._bin = null, this._rootBabylonMesh = null, this._defaultBabylonMaterialData = {}, this._postSceneLoadActions = new Array(), this._parent = t;
+  }
+  /** @internal */
+  dispose() {
+    this._disposed || (this._disposed = !0, this._completePromises.length = 0, this._extensions.forEach((t) => t.dispose && t.dispose()), this._extensions.length = 0, this._gltf = null, this._bin = null, this._babylonScene = null, this._rootBabylonMesh = null, this._defaultBabylonMaterialData = {}, this._postSceneLoadActions.length = 0, this._parent.dispose());
+  }
+  /**
+   * @internal
+   */
+  importMeshAsync(t, e, n, s, r, o, i = "") {
+    return Promise.resolve().then(() => {
+      this._babylonScene = e, this._assetContainer = n, this._loadData(s);
+      let a = null;
+      if (t) {
+        const l = {};
+        if (this._gltf.nodes)
+          for (const f of this._gltf.nodes)
+            f.name && (l[f.name] = f.index);
+        a = (t instanceof Array ? t : [t]).map((f) => {
+          const d = l[f];
+          if (d === void 0)
+            throw new Error(`Failed to find node '${f}'`);
+          return d;
+        });
+      }
+      return this._loadAsync(r, i, a, () => ({
+        meshes: this._getMeshes(),
+        particleSystems: [],
+        skeletons: this._getSkeletons(),
+        animationGroups: this._getAnimationGroups(),
+        lights: this._babylonLights,
+        transformNodes: this._getTransformNodes(),
+        geometries: this._getGeometries()
+      }));
+    });
+  }
+  /**
+   * @internal
+   */
+  loadAsync(t, e, n, s, r = "") {
+    return Promise.resolve().then(() => (this._babylonScene = t, this._loadData(e), this._loadAsync(n, r, null, () => {
+    })));
+  }
+  _loadAsync(t, e, n, s) {
+    return Promise.resolve().then(() => {
+      this._rootUrl = t, this._uniqueRootUrl = !t.startsWith("file:") && e ? t : `${t}${Date.now()}/`, this._fileName = e, this._loadExtensions(), this._checkExtensions();
+      const r = `${x[x.LOADING]} => ${x[x.READY]}`, o = `${x[x.LOADING]} => ${x[x.COMPLETE]}`;
+      this._parent._startPerformanceCounter(r), this._parent._startPerformanceCounter(o), this._parent._setState(x.LOADING), this._extensionsOnLoading();
+      const i = new Array(), a = this._babylonScene.blockMaterialDirtyMechanism;
+      if (this._babylonScene.blockMaterialDirtyMechanism = !0, !this.parent.loadOnlyMaterials) {
+        if (n)
+          i.push(this.loadSceneAsync("/nodes", { nodes: n, index: -1 }));
+        else if (this._gltf.scene != null || this._gltf.scenes && this._gltf.scenes[0]) {
+          const h = c.Get("/scene", this._gltf.scenes, this._gltf.scene || 0);
+          i.push(this.loadSceneAsync(`/scenes/${h.index}`, h));
+        }
+      }
+      if (!this.parent.skipMaterials && this.parent.loadAllMaterials && this._gltf.materials)
+        for (let h = 0; h < this._gltf.materials.length; ++h) {
+          const f = this._gltf.materials[h], d = "/materials/" + h, m = C.TriangleFillMode;
+          i.push(this._loadMaterialAsync(d, f, null, m, () => {
+          }));
+        }
+      return this._babylonScene.blockMaterialDirtyMechanism = a, this._parent.compileMaterials && i.push(this._compileMaterialsAsync()), this._parent.compileShadowGenerators && i.push(this._compileShadowGeneratorsAsync()), Promise.all(i).then(() => (this._rootBabylonMesh && this._rootBabylonMesh.setEnabled(!0), this._extensionsOnReady(), this._parent._setState(x.READY), this._startAnimations(), s())).then((h) => (this._parent._endPerformanceCounter(r), L.SetImmediate(() => {
+        this._disposed || Promise.all(this._completePromises).then(() => {
+          this._parent._endPerformanceCounter(o), this._parent._setState(x.COMPLETE), this._parent.onCompleteObservable.notifyObservers(void 0), this._parent.onCompleteObservable.clear(), this.dispose();
+        }, (f) => {
+          this._parent.onErrorObservable.notifyObservers(f), this._parent.onErrorObservable.clear(), this.dispose();
+        });
+      }), h));
+    }).catch((r) => {
+      throw this._disposed || (this._parent.onErrorObservable.notifyObservers(r), this._parent.onErrorObservable.clear(), this.dispose()), r;
+    });
+  }
+  _loadData(t) {
+    if (this._gltf = t.json, this._setupData(), t.bin) {
+      const e = this._gltf.buffers;
+      if (e && e[0] && !e[0].uri) {
+        const n = e[0];
+        (n.byteLength < t.bin.byteLength - 3 || n.byteLength > t.bin.byteLength) && $.Warn(`Binary buffer length (${n.byteLength}) from JSON does not match chunk length (${t.bin.byteLength})`), this._bin = t.bin;
+      } else
+        $.Warn("Unexpected BIN chunk");
+    }
+  }
+  _setupData() {
+    if (c.Assign(this._gltf.accessors), c.Assign(this._gltf.animations), c.Assign(this._gltf.buffers), c.Assign(this._gltf.bufferViews), c.Assign(this._gltf.cameras), c.Assign(this._gltf.images), c.Assign(this._gltf.materials), c.Assign(this._gltf.meshes), c.Assign(this._gltf.nodes), c.Assign(this._gltf.samplers), c.Assign(this._gltf.scenes), c.Assign(this._gltf.skins), c.Assign(this._gltf.textures), this._gltf.nodes) {
+      const t = {};
+      for (const n of this._gltf.nodes)
+        if (n.children)
+          for (const s of n.children)
+            t[s] = n.index;
+      const e = this._createRootNode();
+      for (const n of this._gltf.nodes) {
+        const s = t[n.index];
+        n.parent = s === void 0 ? e : this._gltf.nodes[s];
+      }
+    }
+  }
+  _loadExtensions() {
+    for (const t in u._RegisteredExtensions) {
+      const e = u._RegisteredExtensions[t].factory(this);
+      e.name !== t && $.Warn(`The name of the glTF loader extension instance does not match the registered name: ${e.name} !== ${t}`), this._extensions.push(e), this._parent.onExtensionLoadedObservable.notifyObservers(e);
+    }
+    this._extensions.sort((t, e) => (t.order || Number.MAX_VALUE) - (e.order || Number.MAX_VALUE)), this._parent.onExtensionLoadedObservable.clear();
+  }
+  _checkExtensions() {
+    if (this._gltf.extensionsRequired) {
+      for (const t of this._gltf.extensionsRequired)
+        if (!this._extensions.some((n) => n.name === t && n.enabled))
+          throw new Error(`Require extension ${t} is not available`);
+    }
+  }
+  _createRootNode() {
+    this._babylonScene._blockEntityCollection = !!this._assetContainer, this._rootBabylonMesh = new V("__root__", this._babylonScene), this._rootBabylonMesh._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, this._rootBabylonMesh.setEnabled(!1);
+    const t = {
+      _babylonTransformNode: this._rootBabylonMesh,
+      index: -1
+    };
+    switch (this._parent.coordinateSystemMode) {
+      case D.AUTO: {
+        this._babylonScene.useRightHandedSystem || (t.rotation = [0, 1, 0, 0], t.scale = [1, 1, -1], u._LoadTransform(t, this._rootBabylonMesh));
+        break;
+      }
+      case D.FORCE_RIGHT_HANDED: {
+        this._babylonScene.useRightHandedSystem = !0;
+        break;
+      }
+      default:
+        throw new Error(`Invalid coordinate system mode (${this._parent.coordinateSystemMode})`);
+    }
+    return this._parent.onMeshLoadedObservable.notifyObservers(this._rootBabylonMesh), t;
+  }
+  /**
+   * Loads a glTF scene.
+   * @param context The context when loading the asset
+   * @param scene The glTF scene property
+   * @returns A promise that resolves when the load is complete
+   */
+  loadSceneAsync(t, e) {
+    const n = this._extensionsLoadSceneAsync(t, e);
+    if (n)
+      return n;
+    const s = new Array();
+    if (this.logOpen(`${t} ${e.name || ""}`), e.nodes)
+      for (const r of e.nodes) {
+        const o = c.Get(`${t}/nodes/${r}`, this._gltf.nodes, r);
+        s.push(this.loadNodeAsync(`/nodes/${o.index}`, o, (i) => {
+          i.parent = this._rootBabylonMesh;
+        }));
+      }
+    for (const r of this._postSceneLoadActions)
+      r();
+    return s.push(this._loadAnimationsAsync()), this.logClose(), Promise.all(s).then(() => {
+    });
+  }
+  _forEachPrimitive(t, e) {
+    if (t._primitiveBabylonMeshes)
+      for (const n of t._primitiveBabylonMeshes)
+        e(n);
+  }
+  _getGeometries() {
+    const t = new Array(), e = this._gltf.nodes;
+    if (e)
+      for (const n of e)
+        this._forEachPrimitive(n, (s) => {
+          const r = s.geometry;
+          r && t.indexOf(r) === -1 && t.push(r);
+        });
+    return t;
+  }
+  _getMeshes() {
+    const t = new Array();
+    this._rootBabylonMesh && t.push(this._rootBabylonMesh);
+    const e = this._gltf.nodes;
+    if (e)
+      for (const n of e)
+        this._forEachPrimitive(n, (s) => {
+          t.push(s);
+        });
+    return t;
+  }
+  _getTransformNodes() {
+    const t = new Array(), e = this._gltf.nodes;
+    if (e)
+      for (const n of e)
+        n._babylonTransformNode && n._babylonTransformNode.getClassName() === "TransformNode" && t.push(n._babylonTransformNode), n._babylonTransformNodeForSkin && t.push(n._babylonTransformNodeForSkin);
+    return t;
+  }
+  _getSkeletons() {
+    const t = new Array(), e = this._gltf.skins;
+    if (e)
+      for (const n of e)
+        n._data && t.push(n._data.babylonSkeleton);
+    return t;
+  }
+  _getAnimationGroups() {
+    const t = new Array(), e = this._gltf.animations;
+    if (e)
+      for (const n of e)
+        n._babylonAnimationGroup && t.push(n._babylonAnimationGroup);
+    return t;
+  }
+  _startAnimations() {
+    switch (this._parent.animationStartMode) {
+      case B.NONE:
+        break;
+      case B.FIRST: {
+        const t = this._getAnimationGroups();
+        t.length !== 0 && t[0].start(!0);
+        break;
+      }
+      case B.ALL: {
+        const t = this._getAnimationGroups();
+        for (const e of t)
+          e.start(!0);
+        break;
+      }
+      default: {
+        $.Error(`Invalid animation start mode (${this._parent.animationStartMode})`);
+        return;
+      }
+    }
+  }
+  /**
+   * Loads a glTF node.
+   * @param context The context when loading the asset
+   * @param node The glTF node property
+   * @param assign A function called synchronously after parsing the glTF properties
+   * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
+   */
+  loadNodeAsync(t, e, n = () => {
+  }) {
+    const s = this._extensionsLoadNodeAsync(t, e, n);
+    if (s)
+      return s;
+    if (e._babylonTransformNode)
+      throw new Error(`${t}: Invalid recursive node hierarchy`);
+    const r = new Array();
+    this.logOpen(`${t} ${e.name || ""}`);
+    const o = (i) => {
+      if (u.AddPointerMetadata(i, t), u._LoadTransform(e, i), e.camera != null) {
+        const a = c.Get(`${t}/camera`, this._gltf.cameras, e.camera);
+        r.push(this.loadCameraAsync(`/cameras/${a.index}`, a, (l) => {
+          l.parent = i;
+        }));
+      }
+      if (e.children)
+        for (const a of e.children) {
+          const l = c.Get(`${t}/children/${a}`, this._gltf.nodes, a);
+          r.push(this.loadNodeAsync(`/nodes/${l.index}`, l, (h) => {
+            h.parent = i;
+          }));
+        }
+      n(i);
+    };
+    if (e.mesh == null || e.skin != null) {
+      const i = e.name || `node${e.index}`;
+      this._babylonScene._blockEntityCollection = !!this._assetContainer;
+      const a = new k(i, this._babylonScene);
+      a._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, e.mesh == null ? e._babylonTransformNode = a : e._babylonTransformNodeForSkin = a, o(a);
+    }
+    if (e.mesh != null)
+      if (e.skin == null) {
+        const i = c.Get(`${t}/mesh`, this._gltf.meshes, e.mesh);
+        r.push(this._loadMeshAsync(`/meshes/${i.index}`, e, i, o));
+      } else {
+        const i = c.Get(`${t}/mesh`, this._gltf.meshes, e.mesh);
+        r.push(this._loadMeshAsync(`/meshes/${i.index}`, e, i, (a) => {
+          const l = e._babylonTransformNodeForSkin;
+          a.metadata = F(l.metadata, a.metadata || {});
+          const h = c.Get(`${t}/skin`, this._gltf.skins, e.skin);
+          r.push(this._loadSkinAsync(`/skins/${h.index}`, e, h, (f) => {
+            this._forEachPrimitive(e, (d) => {
+              d.skeleton = f;
+            }), this._postSceneLoadActions.push(() => {
+              if (h.skeleton != null) {
+                const d = c.Get(`/skins/${h.index}/skeleton`, this._gltf.nodes, h.skeleton).parent;
+                e.index === d.index ? a.parent = l.parent : a.parent = d._babylonTransformNode;
+              } else
+                a.parent = this._rootBabylonMesh;
+              this._parent.onSkinLoadedObservable.notifyObservers({ node: l, skinnedNode: a });
+            });
+          }));
+        }));
+      }
+    return this.logClose(), Promise.all(r).then(() => (this._forEachPrimitive(e, (i) => {
+      i.geometry && i.geometry.useBoundingInfoFromGeometry ? i._updateBoundingInfo() : i.refreshBoundingInfo(!0);
+    }), e._babylonTransformNode));
+  }
+  _loadMeshAsync(t, e, n, s) {
+    const r = n.primitives;
+    if (!r || !r.length)
+      throw new Error(`${t}: Primitives are missing`);
+    r[0].index == null && c.Assign(r);
+    const o = new Array();
+    this.logOpen(`${t} ${n.name || ""}`);
+    const i = e.name || `node${e.index}`;
+    if (r.length === 1) {
+      const a = n.primitives[0];
+      o.push(this._loadMeshPrimitiveAsync(`${t}/primitives/${a.index}`, i, e, n, a, (l) => {
+        e._babylonTransformNode = l, e._primitiveBabylonMeshes = [l];
+      }));
+    } else {
+      this._babylonScene._blockEntityCollection = !!this._assetContainer, e._babylonTransformNode = new k(i, this._babylonScene), e._babylonTransformNode._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, e._primitiveBabylonMeshes = [];
+      for (const a of r)
+        o.push(this._loadMeshPrimitiveAsync(`${t}/primitives/${a.index}`, `${i}_primitive${a.index}`, e, n, a, (l) => {
+          l.parent = e._babylonTransformNode, e._primitiveBabylonMeshes.push(l);
+        }));
+    }
+    return s(e._babylonTransformNode), this.logClose(), Promise.all(o).then(() => e._babylonTransformNode);
+  }
+  /**
+   * @internal Define this method to modify the default behavior when loading data for mesh primitives.
+   * @param context The context when loading the asset
+   * @param name The mesh name when loading the asset
+   * @param node The glTF node when loading the asset
+   * @param mesh The glTF mesh when loading the asset
+   * @param primitive The glTF mesh primitive property
+   * @param assign A function called synchronously after parsing the glTF properties
+   * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
+   */
+  _loadMeshPrimitiveAsync(t, e, n, s, r, o) {
+    const i = this._extensionsLoadMeshPrimitiveAsync(t, e, n, s, r, o);
+    if (i)
+      return i;
+    this.logOpen(`${t}`);
+    const a = this._disableInstancedMesh === 0 && this._parent.createInstances && n.skin == null && !s.primitives[0].targets;
+    let l, h;
+    if (a && r._instanceData)
+      this._babylonScene._blockEntityCollection = !!this._assetContainer, l = r._instanceData.babylonSourceMesh.createInstance(e), l._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, h = r._instanceData.promise;
+    else {
+      const f = new Array();
+      this._babylonScene._blockEntityCollection = !!this._assetContainer;
+      const d = new V(e, this._babylonScene);
+      d._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, d.overrideMaterialSideOrientation = this._babylonScene.useRightHandedSystem ? C.CounterClockWiseSideOrientation : C.ClockWiseSideOrientation, this._createMorphTargets(t, n, s, r, d), f.push(this._loadVertexDataAsync(t, r, d).then((_) => this._loadMorphTargetsAsync(t, r, d, _).then(() => {
+        this._disposed || (this._babylonScene._blockEntityCollection = !!this._assetContainer, _.applyToMesh(d), _._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1);
+      })));
+      const m = u._GetDrawMode(t, r.mode);
+      if (r.material == null) {
+        let _ = this._defaultBabylonMaterialData[m];
+        _ || (_ = this._createDefaultMaterial("__GLTFLoader._default", m), this._parent.onMaterialLoadedObservable.notifyObservers(_), this._defaultBabylonMaterialData[m] = _), d.material = _;
+      } else if (!this.parent.skipMaterials) {
+        const _ = c.Get(`${t}/material`, this._gltf.materials, r.material);
+        f.push(this._loadMaterialAsync(`/materials/${_.index}`, _, d, m, (E) => {
+          d.material = E;
+        }));
+      }
+      h = Promise.all(f), a && (r._instanceData = {
+        babylonSourceMesh: d,
+        promise: h
+      }), l = d;
+    }
+    return u.AddPointerMetadata(l, t), this._parent.onMeshLoadedObservable.notifyObservers(l), o(l), this.logClose(), h.then(() => l);
+  }
+  _loadVertexDataAsync(t, e, n) {
+    const s = this._extensionsLoadVertexDataAsync(t, e, n);
+    if (s)
+      return s;
+    const r = e.attributes;
+    if (!r)
+      throw new Error(`${t}: Attributes are missing`);
+    const o = new Array(), i = new J(n.name, this._babylonScene);
+    if (e.indices == null)
+      n.isUnIndexed = !0;
+    else {
+      const l = c.Get(`${t}/indices`, this._gltf.accessors, e.indices);
+      o.push(this._loadIndicesAccessorAsync(`/accessors/${l.index}`, l).then((h) => {
+        i.setIndices(h);
+      }));
+    }
+    const a = (l, h, f) => {
+      if (r[l] == null)
+        return;
+      n._delayInfo = n._delayInfo || [], n._delayInfo.indexOf(h) === -1 && n._delayInfo.push(h);
+      const d = c.Get(`${t}/attributes/${l}`, this._gltf.accessors, r[l]);
+      o.push(this._loadVertexAccessorAsync(`/accessors/${d.index}`, d, h).then((m) => {
+        if (m.getKind() === p.PositionKind && !this.parent.alwaysComputeBoundingBox && !n.skeleton && d.min && d.max) {
+          const _ = O.Vector3[0].copyFromFloats(...d.min), E = O.Vector3[1].copyFromFloats(...d.max);
+          if (d.normalized && d.componentType !== 5126) {
+            let g = 1;
+            switch (d.componentType) {
+              case 5120:
+                g = 127;
+                break;
+              case 5121:
+                g = 255;
+                break;
+              case 5122:
+                g = 32767;
+                break;
+              case 5123:
+                g = 65535;
+                break;
+            }
+            const b = 1 / g;
+            _.scaleInPlace(b), E.scaleInPlace(b);
+          }
+          i._boundingInfo = new se(_, E), i.useBoundingInfoFromGeometry = !0;
+        }
+        i.setVerticesBuffer(m, d.count);
+      })), h == p.MatricesIndicesExtraKind && (n.numBoneInfluencers = 8), f && f(d);
+    };
+    return a("POSITION", p.PositionKind), a("NORMAL", p.NormalKind), a("TANGENT", p.TangentKind), a("TEXCOORD_0", p.UVKind), a("TEXCOORD_1", p.UV2Kind), a("TEXCOORD_2", p.UV3Kind), a("TEXCOORD_3", p.UV4Kind), a("TEXCOORD_4", p.UV5Kind), a("TEXCOORD_5", p.UV6Kind), a("JOINTS_0", p.MatricesIndicesKind), a("WEIGHTS_0", p.MatricesWeightsKind), a("JOINTS_1", p.MatricesIndicesExtraKind), a("WEIGHTS_1", p.MatricesWeightsExtraKind), a("COLOR_0", p.ColorKind, (l) => {
+      l.type === "VEC4" && (n.hasVertexAlpha = !0);
+    }), Promise.all(o).then(() => i);
+  }
+  _createMorphTargets(t, e, n, s, r) {
+    if (!s.targets)
+      return;
+    if (e._numMorphTargets == null)
+      e._numMorphTargets = s.targets.length;
+    else if (s.targets.length !== e._numMorphTargets)
+      throw new Error(`${t}: Primitives do not have the same number of targets`);
+    const o = n.extras ? n.extras.targetNames : null;
+    this._babylonScene._blockEntityCollection = !!this._assetContainer, r.morphTargetManager = new j(this._babylonScene), r.morphTargetManager._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, r.morphTargetManager.areUpdatesFrozen = !0;
+    for (let i = 0; i < s.targets.length; i++) {
+      const a = e.weights ? e.weights[i] : n.weights ? n.weights[i] : 0, l = o ? o[i] : `morphTarget${i}`;
+      r.morphTargetManager.addTarget(new Y(l, a, r.getScene()));
+    }
+  }
+  _loadMorphTargetsAsync(t, e, n, s) {
+    if (!e.targets)
+      return Promise.resolve();
+    const r = new Array(), o = n.morphTargetManager;
+    for (let i = 0; i < o.numTargets; i++) {
+      const a = o.getTarget(i);
+      r.push(this._loadMorphTargetVertexDataAsync(`${t}/targets/${i}`, s, e.targets[i], a));
+    }
+    return Promise.all(r).then(() => {
+      o.areUpdatesFrozen = !1;
+    });
+  }
+  _loadMorphTargetVertexDataAsync(t, e, n, s) {
+    const r = new Array(), o = (i, a, l) => {
+      if (n[i] == null)
+        return;
+      const h = e.getVertexBuffer(a);
+      if (!h)
+        return;
+      const f = c.Get(`${t}/${i}`, this._gltf.accessors, n[i]);
+      r.push(this._loadFloatAccessorAsync(`/accessors/${f.index}`, f).then((d) => {
+        l(h, d);
+      }));
+    };
+    return o("POSITION", p.PositionKind, (i, a) => {
+      const l = new Float32Array(a.length);
+      i.forEach(a.length, (h, f) => {
+        l[f] = a[f] + h;
+      }), s.setPositions(l);
+    }), o("NORMAL", p.NormalKind, (i, a) => {
+      const l = new Float32Array(a.length);
+      i.forEach(l.length, (h, f) => {
+        l[f] = a[f] + h;
+      }), s.setNormals(l);
+    }), o("TANGENT", p.TangentKind, (i, a) => {
+      const l = new Float32Array(a.length / 3 * 4);
+      let h = 0;
+      i.forEach(a.length / 3 * 4, (f, d) => {
+        (d + 1) % 4 !== 0 && (l[h] = a[h] + f, h++);
+      }), s.setTangents(l);
+    }), Promise.all(r).then(() => {
+    });
+  }
+  static _LoadTransform(t, e) {
+    if (t.skin != null)
+      return;
+    let n = T.Zero(), s = I.Identity(), r = T.One();
+    t.matrix ? P.FromArray(t.matrix).decompose(r, s, n) : (t.translation && (n = T.FromArray(t.translation)), t.rotation && (s = I.FromArray(t.rotation)), t.scale && (r = T.FromArray(t.scale))), e.position = n, e.rotationQuaternion = s, e.scaling = r;
+  }
+  _loadSkinAsync(t, e, n, s) {
+    const r = this._extensionsLoadSkinAsync(t, e, n);
+    if (r)
+      return r;
+    if (n._data)
+      return s(n._data.babylonSkeleton), n._data.promise;
+    const o = `skeleton${n.index}`;
+    this._babylonScene._blockEntityCollection = !!this._assetContainer;
+    const i = new Z(n.name || o, o, this._babylonScene);
+    i._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, this._loadBones(t, n, i);
+    const a = this._loadSkinInverseBindMatricesDataAsync(t, n).then((l) => {
+      this._updateBoneMatrices(i, l);
+    });
+    return n._data = {
+      babylonSkeleton: i,
+      promise: a
+    }, s(i), a;
+  }
+  _loadBones(t, e, n) {
+    if (e.skeleton == null || this._parent.alwaysComputeSkeletonRootNode) {
+      const r = this._findSkeletonRootNode(`${t}/joints`, e.joints);
+      if (r)
+        if (e.skeleton === void 0)
+          e.skeleton = r.index;
+        else {
+          const o = (a, l) => {
+            for (; l.parent; l = l.parent)
+              if (l.parent === a)
+                return !0;
+            return !1;
+          }, i = c.Get(`${t}/skeleton`, this._gltf.nodes, e.skeleton);
+          i !== r && !o(i, r) && ($.Warn(`${t}/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root`), e.skeleton = r.index);
+        }
+      else
+        $.Warn(`${t}: Failed to find common root`);
+    }
+    const s = {};
+    for (const r of e.joints) {
+      const o = c.Get(`${t}/joints/${r}`, this._gltf.nodes, r);
+      this._loadBone(o, e, n, s);
+    }
+  }
+  _findSkeletonRootNode(t, e) {
+    if (e.length === 0)
+      return null;
+    const n = {};
+    for (const r of e) {
+      const o = new Array();
+      let i = c.Get(`${t}/${r}`, this._gltf.nodes, r);
+      for (; i.index !== -1; )
+        o.unshift(i), i = i.parent;
+      n[r] = o;
+    }
+    let s = null;
+    for (let r = 0; ; ++r) {
+      let o = n[e[0]];
+      if (r >= o.length)
+        return s;
+      const i = o[r];
+      for (let a = 1; a < e.length; ++a)
+        if (o = n[e[a]], r >= o.length || i !== o[r])
+          return s;
+      s = i;
+    }
+  }
+  _loadBone(t, e, n, s) {
+    let r = s[t.index];
+    if (r)
+      return r;
+    let o = null;
+    t.index !== e.skeleton && (t.parent && t.parent.index !== -1 ? o = this._loadBone(t.parent, e, n, s) : e.skeleton !== void 0 && $.Warn(`/skins/${e.index}/skeleton: Skeleton node is not a common root`));
+    const i = e.joints.indexOf(t.index);
+    return r = new X(t.name || `joint${t.index}`, n, o, this._getNodeMatrix(t), null, null, i), s[t.index] = r, this._postSceneLoadActions.push(() => {
+      r.linkTransformNode(t._babylonTransformNode);
+    }), r;
+  }
+  _loadSkinInverseBindMatricesDataAsync(t, e) {
+    if (e.inverseBindMatrices == null)
+      return Promise.resolve(null);
+    const n = c.Get(`${t}/inverseBindMatrices`, this._gltf.accessors, e.inverseBindMatrices);
+    return this._loadFloatAccessorAsync(`/accessors/${n.index}`, n);
+  }
+  _updateBoneMatrices(t, e) {
+    for (const n of t.bones) {
+      const s = P.Identity(), r = n._index;
+      e && r !== -1 && (P.FromArrayToRef(e, r * 16, s), s.invertToRef(s));
+      const o = n.getParent();
+      o && s.multiplyToRef(o.getAbsoluteInverseBindMatrix(), s), n.updateMatrix(s, !1, !1), n._updateAbsoluteBindMatrices(void 0, !1);
+    }
+  }
+  _getNodeMatrix(t) {
+    return t.matrix ? P.FromArray(t.matrix) : P.Compose(t.scale ? T.FromArray(t.scale) : T.One(), t.rotation ? I.FromArray(t.rotation) : I.Identity(), t.translation ? T.FromArray(t.translation) : T.Zero());
+  }
+  /**
+   * Loads a glTF camera.
+   * @param context The context when loading the asset
+   * @param camera The glTF camera property
+   * @param assign A function called synchronously after parsing the glTF properties
+   * @returns A promise that resolves with the loaded Babylon camera when the load is complete
+   */
+  loadCameraAsync(t, e, n = () => {
+  }) {
+    const s = this._extensionsLoadCameraAsync(t, e, n);
+    if (s)
+      return s;
+    const r = new Array();
+    this.logOpen(`${t} ${e.name || ""}`), this._babylonScene._blockEntityCollection = !!this._assetContainer;
+    const o = new K(e.name || `camera${e.index}`, T.Zero(), this._babylonScene, !1);
+    switch (o._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, o.ignoreParentScaling = !0, e._babylonCamera = o, o.rotation = new T(0, Math.PI, 0), e.type) {
+      case "perspective": {
+        const i = e.perspective;
+        if (!i)
+          throw new Error(`${t}: Camera perspective properties are missing`);
+        o.fov = i.yfov, o.minZ = i.znear, o.maxZ = i.zfar || 0;
+        break;
+      }
+      case "orthographic": {
+        if (!e.orthographic)
+          throw new Error(`${t}: Camera orthographic properties are missing`);
+        o.mode = W.ORTHOGRAPHIC_CAMERA, o.orthoLeft = -e.orthographic.xmag, o.orthoRight = e.orthographic.xmag, o.orthoBottom = -e.orthographic.ymag, o.orthoTop = e.orthographic.ymag, o.minZ = e.orthographic.znear, o.maxZ = e.orthographic.zfar;
+        break;
+      }
+      default:
+        throw new Error(`${t}: Invalid camera type (${e.type})`);
+    }
+    return u.AddPointerMetadata(o, t), this._parent.onCameraLoadedObservable.notifyObservers(o), n(o), this.logClose(), Promise.all(r).then(() => o);
+  }
+  _loadAnimationsAsync() {
+    const t = this._gltf.animations;
+    if (!t)
+      return Promise.resolve();
+    const e = new Array();
+    for (let n = 0; n < t.length; n++) {
+      const s = t[n];
+      e.push(this.loadAnimationAsync(`/animations/${s.index}`, s).then((r) => {
+        r.targetedAnimations.length === 0 && r.dispose();
+      }));
+    }
+    return Promise.all(e).then(() => {
+    });
+  }
+  /**
+   * Loads a glTF animation.
+   * @param context The context when loading the asset
+   * @param animation The glTF animation property
+   * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
+   */
+  loadAnimationAsync(t, e) {
+    const n = this._extensionsLoadAnimationAsync(t, e);
+    if (n)
+      return n;
+    this._babylonScene._blockEntityCollection = !!this._assetContainer;
+    const s = new H(e.name || `animation${e.index}`, this._babylonScene);
+    s._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, e._babylonAnimationGroup = s;
+    const r = new Array();
+    c.Assign(e.channels), c.Assign(e.samplers);
+    for (const o of e.channels)
+      r.push(this._loadAnimationChannelAsync(`${t}/channels/${o.index}`, t, e, o, (i, a) => {
+        i.animations = i.animations || [], i.animations.push(a), s.addTargetedAnimation(a, i);
+      }));
+    return Promise.all(r).then(() => (s.normalize(0), s));
+  }
+  /**
+   * @hidden
+   * Loads a glTF animation channel.
+   * @param context The context when loading the asset
+   * @param animationContext The context of the animation when loading the asset
+   * @param animation The glTF animation property
+   * @param channel The glTF animation channel property
+   * @param onLoad Called for each animation loaded
+   * @returns A void promise that resolves when the load is complete
+   */
+  _loadAnimationChannelAsync(t, e, n, s, r) {
+    const o = this._extensionsLoadAnimationChannelAsync(t, e, n, s, r);
+    if (o)
+      return o;
+    if (s.target.node == null)
+      return Promise.resolve();
+    const i = c.Get(`${t}/target/node`, this._gltf.nodes, s.target.node);
+    if (s.target.path === "weights" && !i._numMorphTargets || s.target.path !== "weights" && !i._babylonTransformNode)
+      return Promise.resolve();
+    let a;
+    switch (s.target.path) {
+      case "translation": {
+        a = N.translation;
+        break;
+      }
+      case "rotation": {
+        a = N.rotation;
+        break;
+      }
+      case "scale": {
+        a = N.scale;
+        break;
+      }
+      case "weights": {
+        a = N.weights;
+        break;
+      }
+      default:
+        throw new Error(`${t}/target/path: Invalid value (${s.target.path})`);
+    }
+    const l = {
+      target: i,
+      properties: a
+    };
+    return this._loadAnimationChannelFromTargetInfoAsync(t, e, n, s, l, r);
+  }
+  /**
+   * @hidden
+   * Loads a glTF animation channel.
+   * @param context The context when loading the asset
+   * @param animationContext The context of the animation when loading the asset
+   * @param animation The glTF animation property
+   * @param channel The glTF animation channel property
+   * @param targetInfo The glTF target and properties
+   * @param onLoad Called for each animation loaded
+   * @returns A void promise that resolves when the load is complete
+   */
+  _loadAnimationChannelFromTargetInfoAsync(t, e, n, s, r, o) {
+    const i = this.parent.targetFps, a = 1 / i, l = c.Get(`${t}/sampler`, n.samplers, s.sampler);
+    return this._loadAnimationSamplerAsync(`${e}/samplers/${s.sampler}`, l).then((h) => {
+      let f = 0;
+      for (const d of r.properties) {
+        const m = d.getStride(r.target), _ = h.input, E = h.output, g = new Array(_.length);
+        let b = 0;
+        switch (h.interpolation) {
+          case "STEP": {
+            for (let y = 0; y < _.length; y++) {
+              const w = d.getValue(r.target, E, b, 1);
+              b += m, g[y] = {
+                frame: _[y] * i,
+                value: w,
+                interpolation: z.STEP
+              };
+            }
+            break;
+          }
+          case "CUBICSPLINE": {
+            for (let y = 0; y < _.length; y++) {
+              const w = d.getValue(r.target, E, b, a);
+              b += m;
+              const S = d.getValue(r.target, E, b, 1);
+              b += m;
+              const G = d.getValue(r.target, E, b, a);
+              b += m, g[y] = {
+                frame: _[y] * i,
+                inTangent: w,
+                value: S,
+                outTangent: G
+              };
+            }
+            break;
+          }
+          case "LINEAR": {
+            for (let y = 0; y < _.length; y++) {
+              const w = d.getValue(r.target, E, b, 1);
+              b += m, g[y] = {
+                frame: _[y] * i,
+                value: w
+              };
+            }
+            break;
+          }
+        }
+        if (b > 0) {
+          const y = `${n.name || `animation${n.index}`}_channel${s.index}_${f}`;
+          d.buildAnimations(r.target, y, i, g, (w, S) => {
+            ++f, o(w, S);
+          });
+        }
+      }
+    });
+  }
+  _loadAnimationSamplerAsync(t, e) {
+    if (e._data)
+      return e._data;
+    const n = e.interpolation || "LINEAR";
+    switch (n) {
+      case "STEP":
+      case "LINEAR":
+      case "CUBICSPLINE":
+        break;
+      default:
+        throw new Error(`${t}/interpolation: Invalid value (${e.interpolation})`);
+    }
+    const s = c.Get(`${t}/input`, this._gltf.accessors, e.input), r = c.Get(`${t}/output`, this._gltf.accessors, e.output);
+    return e._data = Promise.all([
+      this._loadFloatAccessorAsync(`/accessors/${s.index}`, s),
+      this._loadFloatAccessorAsync(`/accessors/${r.index}`, r)
+    ]).then(([o, i]) => ({
+      input: o,
+      interpolation: n,
+      output: i
+    })), e._data;
+  }
+  /**
+   * Loads a glTF buffer.
+   * @param context The context when loading the asset
+   * @param buffer The glTF buffer property
+   * @param byteOffset The byte offset to use
+   * @param byteLength The byte length to use
+   * @returns A promise that resolves with the loaded data when the load is complete
+   */
+  loadBufferAsync(t, e, n, s) {
+    const r = this._extensionsLoadBufferAsync(t, e, n, s);
+    if (r)
+      return r;
+    if (!e._data)
+      if (e.uri)
+        e._data = this.loadUriAsync(`${t}/uri`, e, e.uri);
+      else {
+        if (!this._bin)
+          throw new Error(`${t}: Uri is missing or the binary glTF is missing its binary chunk`);
+        e._data = this._bin.readAsync(0, e.byteLength);
+      }
+    return e._data.then((o) => {
+      try {
+        return new Uint8Array(o.buffer, o.byteOffset + n, s);
+      } catch (i) {
+        throw new Error(`${t}: ${i.message}`);
+      }
+    });
+  }
+  /**
+   * Loads a glTF buffer view.
+   * @param context The context when loading the asset
+   * @param bufferView The glTF buffer view property
+   * @returns A promise that resolves with the loaded data when the load is complete
+   */
+  loadBufferViewAsync(t, e) {
+    const n = this._extensionsLoadBufferViewAsync(t, e);
+    if (n)
+      return n;
+    if (e._data)
+      return e._data;
+    const s = c.Get(`${t}/buffer`, this._gltf.buffers, e.buffer);
+    return e._data = this.loadBufferAsync(`/buffers/${s.index}`, s, e.byteOffset || 0, e.byteLength), e._data;
+  }
+  _loadAccessorAsync(t, e, n) {
+    if (e._data)
+      return e._data;
+    const s = u._GetNumComponents(t, e.type), r = s * p.GetTypeByteLength(e.componentType), o = s * e.count;
+    if (e.bufferView == null)
+      e._data = Promise.resolve(new n(o));
+    else {
+      const i = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
+      e._data = this.loadBufferViewAsync(`/bufferViews/${i.index}`, i).then((a) => {
+        if (e.componentType === 5126 && !e.normalized && (!i.byteStride || i.byteStride === r))
+          return u._GetTypedArray(t, e.componentType, a, e.byteOffset, o);
+        {
+          const l = new n(o);
+          return p.ForEach(a, e.byteOffset || 0, i.byteStride || r, s, e.componentType, l.length, e.normalized || !1, (h, f) => {
+            l[f] = h;
+          }), l;
+        }
+      });
+    }
+    if (e.sparse) {
+      const i = e.sparse;
+      e._data = e._data.then((a) => {
+        const l = a, h = c.Get(`${t}/sparse/indices/bufferView`, this._gltf.bufferViews, i.indices.bufferView), f = c.Get(`${t}/sparse/values/bufferView`, this._gltf.bufferViews, i.values.bufferView);
+        return Promise.all([
+          this.loadBufferViewAsync(`/bufferViews/${h.index}`, h),
+          this.loadBufferViewAsync(`/bufferViews/${f.index}`, f)
+        ]).then(([d, m]) => {
+          const _ = u._GetTypedArray(`${t}/sparse/indices`, i.indices.componentType, d, i.indices.byteOffset, i.count), E = s * i.count;
+          let g;
+          if (e.componentType === 5126 && !e.normalized)
+            g = u._GetTypedArray(`${t}/sparse/values`, e.componentType, m, i.values.byteOffset, E);
+          else {
+            const y = u._GetTypedArray(`${t}/sparse/values`, e.componentType, m, i.values.byteOffset, E);
+            g = new n(E), p.ForEach(y, 0, r, s, e.componentType, g.length, e.normalized || !1, (w, S) => {
+              g[S] = w;
+            });
+          }
+          let b = 0;
+          for (let y = 0; y < _.length; y++) {
+            let w = _[y] * s;
+            for (let S = 0; S < s; S++)
+              l[w++] = g[b++];
+          }
+          return l;
+        });
+      });
+    }
+    return e._data;
+  }
+  /**
+   * @internal
+   */
+  _loadFloatAccessorAsync(t, e) {
+    return this._loadAccessorAsync(t, e, Float32Array);
+  }
+  /**
+   * @internal
+   */
+  _loadIndicesAccessorAsync(t, e) {
+    if (e.type !== "SCALAR")
+      throw new Error(`${t}/type: Invalid value ${e.type}`);
+    if (e.componentType !== 5121 && e.componentType !== 5123 && e.componentType !== 5125)
+      throw new Error(`${t}/componentType: Invalid value ${e.componentType}`);
+    if (e._data)
+      return e._data;
+    if (e.sparse) {
+      const n = u._GetTypedArrayConstructor(`${t}/componentType`, e.componentType);
+      e._data = this._loadAccessorAsync(t, e, n);
+    } else {
+      const n = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
+      e._data = this.loadBufferViewAsync(`/bufferViews/${n.index}`, n).then((s) => u._GetTypedArray(t, e.componentType, s, e.byteOffset, e.count));
+    }
+    return e._data;
+  }
+  /**
+   * @internal
+   */
+  _loadVertexBufferViewAsync(t) {
+    if (t._babylonBuffer)
+      return t._babylonBuffer;
+    const e = this._babylonScene.getEngine();
+    return t._babylonBuffer = this.loadBufferViewAsync(`/bufferViews/${t.index}`, t).then((n) => new Q(e, n, !1)), t._babylonBuffer;
+  }
+  /**
+   * @internal
+   */
+  _loadVertexAccessorAsync(t, e, n) {
+    var s;
+    if (!((s = e._babylonVertexBuffer) === null || s === void 0) && s[n])
+      return e._babylonVertexBuffer[n];
+    e._babylonVertexBuffer || (e._babylonVertexBuffer = {});
+    const r = this._babylonScene.getEngine();
+    if (e.sparse)
+      e._babylonVertexBuffer[n] = this._loadFloatAccessorAsync(t, e).then((o) => new p(r, o, n, !1));
+    else if (n === p.MatricesIndicesKind || n === p.MatricesIndicesExtraKind)
+      e._babylonVertexBuffer[n] = this._loadFloatAccessorAsync(t, e).then((o) => new p(r, o, n, !1));
+    else {
+      const o = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
+      e._babylonVertexBuffer[n] = this._loadVertexBufferViewAsync(o).then((i) => {
+        const a = u._GetNumComponents(t, e.type);
+        return new p(r, i, n, !1, !1, o.byteStride, !1, e.byteOffset, a, e.componentType, e.normalized, !0, 1, !0);
+      });
+    }
+    return e._babylonVertexBuffer[n];
+  }
+  _loadMaterialMetallicRoughnessPropertiesAsync(t, e, n) {
+    if (!(n instanceof M))
+      throw new Error(`${t}: Material type not supported`);
+    const s = new Array();
+    return e && (e.baseColorFactor ? (n.albedoColor = R.FromArray(e.baseColorFactor), n.alpha = e.baseColorFactor[3]) : n.albedoColor = R.White(), n.metallic = e.metallicFactor == null ? 1 : e.metallicFactor, n.roughness = e.roughnessFactor == null ? 1 : e.roughnessFactor, e.baseColorTexture && s.push(this.loadTextureInfoAsync(`${t}/baseColorTexture`, e.baseColorTexture, (r) => {
+      r.name = `${n.name} (Base Color)`, n.albedoTexture = r;
+    })), e.metallicRoughnessTexture && (e.metallicRoughnessTexture.nonColorData = !0, s.push(this.loadTextureInfoAsync(`${t}/metallicRoughnessTexture`, e.metallicRoughnessTexture, (r) => {
+      r.name = `${n.name} (Metallic Roughness)`, n.metallicTexture = r;
+    })), n.useMetallnessFromMetallicTextureBlue = !0, n.useRoughnessFromMetallicTextureGreen = !0, n.useRoughnessFromMetallicTextureAlpha = !1)), Promise.all(s).then(() => {
+    });
+  }
+  /**
+   * @internal
+   */
+  _loadMaterialAsync(t, e, n, s, r = () => {
+  }) {
+    const o = this._extensionsLoadMaterialAsync(t, e, n, s, r);
+    if (o)
+      return o;
+    e._data = e._data || {};
+    let i = e._data[s];
+    if (!i) {
+      this.logOpen(`${t} ${e.name || ""}`);
+      const a = this.createMaterial(t, e, s);
+      i = {
+        babylonMaterial: a,
+        babylonMeshes: [],
+        promise: this.loadMaterialPropertiesAsync(t, e, a)
+      }, e._data[s] = i, u.AddPointerMetadata(a, t), this._parent.onMaterialLoadedObservable.notifyObservers(a), this.logClose();
+    }
+    return n && (i.babylonMeshes.push(n), n.onDisposeObservable.addOnce(() => {
+      const a = i.babylonMeshes.indexOf(n);
+      a !== -1 && i.babylonMeshes.splice(a, 1);
+    })), r(i.babylonMaterial), i.promise.then(() => i.babylonMaterial);
+  }
+  _createDefaultMaterial(t, e) {
+    this._babylonScene._blockEntityCollection = !!this._assetContainer;
+    const n = new M(t, this._babylonScene);
+    return n._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, n.fillMode = e, n.enableSpecularAntiAliasing = !0, n.useRadianceOverAlpha = !this._parent.transparencyAsCoverage, n.useSpecularOverAlpha = !this._parent.transparencyAsCoverage, n.transparencyMode = M.PBRMATERIAL_OPAQUE, n.metallic = 1, n.roughness = 1, n;
+  }
+  /**
+   * Creates a Babylon material from a glTF material.
+   * @param context The context when loading the asset
+   * @param material The glTF material property
+   * @param babylonDrawMode The draw mode for the Babylon material
+   * @returns The Babylon material
+   */
+  createMaterial(t, e, n) {
+    const s = this._extensionsCreateMaterial(t, e, n);
+    if (s)
+      return s;
+    const r = e.name || `material${e.index}`;
+    return this._createDefaultMaterial(r, n);
+  }
+  /**
+   * Loads properties from a glTF material into a Babylon material.
+   * @param context The context when loading the asset
+   * @param material The glTF material property
+   * @param babylonMaterial The Babylon material
+   * @returns A promise that resolves when the load is complete
+   */
+  loadMaterialPropertiesAsync(t, e, n) {
+    const s = this._extensionsLoadMaterialPropertiesAsync(t, e, n);
+    if (s)
+      return s;
+    const r = new Array();
+    return r.push(this.loadMaterialBasePropertiesAsync(t, e, n)), e.pbrMetallicRoughness && r.push(this._loadMaterialMetallicRoughnessPropertiesAsync(`${t}/pbrMetallicRoughness`, e.pbrMetallicRoughness, n)), this.loadMaterialAlphaProperties(t, e, n), Promise.all(r).then(() => {
+    });
+  }
+  /**
+   * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
+   * @param context The context when loading the asset
+   * @param material The glTF material property
+   * @param babylonMaterial The Babylon material
+   * @returns A promise that resolves when the load is complete
+   */
+  loadMaterialBasePropertiesAsync(t, e, n) {
+    if (!(n instanceof M))
+      throw new Error(`${t}: Material type not supported`);
+    const s = new Array();
+    return n.emissiveColor = e.emissiveFactor ? R.FromArray(e.emissiveFactor) : new R(0, 0, 0), e.doubleSided && (n.backFaceCulling = !1, n.twoSidedLighting = !0), e.normalTexture && (e.normalTexture.nonColorData = !0, s.push(this.loadTextureInfoAsync(`${t}/normalTexture`, e.normalTexture, (r) => {
+      r.name = `${n.name} (Normal)`, n.bumpTexture = r;
+    })), n.invertNormalMapX = !this._babylonScene.useRightHandedSystem, n.invertNormalMapY = this._babylonScene.useRightHandedSystem, e.normalTexture.scale != null && n.bumpTexture && (n.bumpTexture.level = e.normalTexture.scale), n.forceIrradianceInFragment = !0), e.occlusionTexture && (e.occlusionTexture.nonColorData = !0, s.push(this.loadTextureInfoAsync(`${t}/occlusionTexture`, e.occlusionTexture, (r) => {
+      r.name = `${n.name} (Occlusion)`, n.ambientTexture = r;
+    })), n.useAmbientInGrayScale = !0, e.occlusionTexture.strength != null && (n.ambientTextureStrength = e.occlusionTexture.strength)), e.emissiveTexture && s.push(this.loadTextureInfoAsync(`${t}/emissiveTexture`, e.emissiveTexture, (r) => {
+      r.name = `${n.name} (Emissive)`, n.emissiveTexture = r;
+    })), Promise.all(s).then(() => {
+    });
+  }
+  /**
+   * Loads the alpha properties from a glTF material into a Babylon material.
+   * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
+   * @param context The context when loading the asset
+   * @param material The glTF material property
+   * @param babylonMaterial The Babylon material
+   */
+  loadMaterialAlphaProperties(t, e, n) {
+    if (!(n instanceof M))
+      throw new Error(`${t}: Material type not supported`);
+    switch (e.alphaMode || "OPAQUE") {
+      case "OPAQUE": {
+        n.transparencyMode = M.PBRMATERIAL_OPAQUE;
+        break;
+      }
+      case "MASK": {
+        n.transparencyMode = M.PBRMATERIAL_ALPHATEST, n.alphaCutOff = e.alphaCutoff == null ? 0.5 : e.alphaCutoff, n.albedoTexture && (n.albedoTexture.hasAlpha = !0);
+        break;
+      }
+      case "BLEND": {
+        n.transparencyMode = M.PBRMATERIAL_ALPHABLEND, n.albedoTexture && (n.albedoTexture.hasAlpha = !0, n.useAlphaFromAlbedoTexture = !0);
+        break;
+      }
+      default:
+        throw new Error(`${t}/alphaMode: Invalid value (${e.alphaMode})`);
+    }
+  }
+  /**
+   * Loads a glTF texture info.
+   * @param context The context when loading the asset
+   * @param textureInfo The glTF texture info property
+   * @param assign A function called synchronously after parsing the glTF properties
+   * @returns A promise that resolves with the loaded Babylon texture when the load is complete
+   */
+  loadTextureInfoAsync(t, e, n = () => {
+  }) {
+    const s = this._extensionsLoadTextureInfoAsync(t, e, n);
+    if (s)
+      return s;
+    if (this.logOpen(`${t}`), e.texCoord >= 6)
+      throw new Error(`${t}/texCoord: Invalid value (${e.texCoord})`);
+    const r = c.Get(`${t}/index`, this._gltf.textures, e.index);
+    r._textureInfo = e;
+    const o = this._loadTextureAsync(`/textures/${e.index}`, r, (i) => {
+      i.coordinatesIndex = e.texCoord || 0, u.AddPointerMetadata(i, t), this._parent.onTextureLoadedObservable.notifyObservers(i), n(i);
+    });
+    return this.logClose(), o;
+  }
+  /**
+   * @internal
+   */
+  _loadTextureAsync(t, e, n = () => {
+  }) {
+    const s = this._extensionsLoadTextureAsync(t, e, n);
+    if (s)
+      return s;
+    this.logOpen(`${t} ${e.name || ""}`);
+    const r = e.sampler == null ? u.DefaultSampler : c.Get(`${t}/sampler`, this._gltf.samplers, e.sampler), o = c.Get(`${t}/source`, this._gltf.images, e.source), i = this._createTextureAsync(t, r, o, n, void 0, !e._textureInfo.nonColorData);
+    return this.logClose(), i;
+  }
+  /**
+   * @internal
+   */
+  _createTextureAsync(t, e, n, s = () => {
+  }, r, o) {
+    const i = this._loadSampler(`/samplers/${e.index}`, e), a = new Array(), l = new U();
+    this._babylonScene._blockEntityCollection = !!this._assetContainer;
+    const h = {
+      noMipmap: i.noMipMaps,
+      invertY: !1,
+      samplingMode: i.samplingMode,
+      onLoad: () => {
+        this._disposed || l.resolve();
+      },
+      onError: (d, m) => {
+        this._disposed || l.reject(new Error(`${t}: ${m && m.message ? m.message : d || "Failed to load texture"}`));
+      },
+      mimeType: n.mimeType,
+      loaderOptions: r,
+      useSRGBBuffer: !!o && this._parent.useSRGBBuffers
+    }, f = new A(null, this._babylonScene, h);
+    return f._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, a.push(l.promise), a.push(this.loadImageAsync(`/images/${n.index}`, n).then((d) => {
+      const m = n.uri || `${this._fileName}#image${n.index}`, _ = `data:${this._uniqueRootUrl}${m}`;
+      f.updateURL(_, d);
+    })), f.wrapU = i.wrapU, f.wrapV = i.wrapV, s(f), Promise.all(a).then(() => f);
+  }
+  _loadSampler(t, e) {
+    return e._data || (e._data = {
+      noMipMaps: e.minFilter === 9728 || e.minFilter === 9729,
+      samplingMode: u._GetTextureSamplingMode(t, e),
+      wrapU: u._GetTextureWrapMode(`${t}/wrapS`, e.wrapS),
+      wrapV: u._GetTextureWrapMode(`${t}/wrapT`, e.wrapT)
+    }), e._data;
+  }
+  /**
+   * Loads a glTF image.
+   * @param context The context when loading the asset
+   * @param image The glTF image property
+   * @returns A promise that resolves with the loaded data when the load is complete
+   */
+  loadImageAsync(t, e) {
+    if (!e._data) {
+      if (this.logOpen(`${t} ${e.name || ""}`), e.uri)
+        e._data = this.loadUriAsync(`${t}/uri`, e, e.uri);
+      else {
+        const n = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
+        e._data = this.loadBufferViewAsync(`/bufferViews/${n.index}`, n);
+      }
+      this.logClose();
+    }
+    return e._data;
+  }
+  /**
+   * Loads a glTF uri.
+   * @param context The context when loading the asset
+   * @param property The glTF property associated with the uri
+   * @param uri The base64 or relative uri
+   * @returns A promise that resolves with the loaded data when the load is complete
+   */
+  loadUriAsync(t, e, n) {
+    const s = this._extensionsLoadUriAsync(t, e, n);
+    if (s)
+      return s;
+    if (!u._ValidateUri(n))
+      throw new Error(`${t}: '${n}' is invalid`);
+    if (ee(n)) {
+      const r = new Uint8Array(te(n));
+      return this.log(`${t}: Decoded ${n.substr(0, 64)}... (${r.length} bytes)`), Promise.resolve(r);
+    }
+    return this.log(`${t}: Loading ${n}`), this._parent.preprocessUrlAsync(this._rootUrl + n).then((r) => new Promise((o, i) => {
+      this._parent._loadFile(this._babylonScene, r, (a) => {
+        this._disposed || (this.log(`${t}: Loaded ${n} (${a.byteLength} bytes)`), o(new Uint8Array(a)));
+      }, !0, (a) => {
+        i(new ne(`${t}: Failed to load '${n}'${a ? ": " + a.status + " " + a.statusText : ""}`, a));
+      });
+    }));
+  }
+  /**
+   * Adds a JSON pointer to the _internalMetadata of the Babylon object at `<object>._internalMetadata.gltf.pointers`.
+   * @param babylonObject the Babylon object with _internalMetadata
+   * @param pointer the JSON pointer
+   */
+  static AddPointerMetadata(t, e) {
+    t.metadata = t.metadata || {};
+    const n = t._internalMetadata = t._internalMetadata || {}, s = n.gltf = n.gltf || {};
+    (s.pointers = s.pointers || []).push(e);
+  }
+  static _GetTextureWrapMode(t, e) {
+    switch (e = e ?? 10497, e) {
+      case 33071:
+        return A.CLAMP_ADDRESSMODE;
+      case 33648:
+        return A.MIRROR_ADDRESSMODE;
+      case 10497:
+        return A.WRAP_ADDRESSMODE;
+      default:
+        return $.Warn(`${t}: Invalid value (${e})`), A.WRAP_ADDRESSMODE;
+    }
+  }
+  static _GetTextureSamplingMode(t, e) {
+    const n = e.magFilter == null ? 9729 : e.magFilter, s = e.minFilter == null ? 9987 : e.minFilter;
+    if (n === 9729)
+      switch (s) {
+        case 9728:
+          return A.LINEAR_NEAREST;
+        case 9729:
+          return A.LINEAR_LINEAR;
+        case 9984:
+          return A.LINEAR_NEAREST_MIPNEAREST;
+        case 9985:
+          return A.LINEAR_LINEAR_MIPNEAREST;
+        case 9986:
+          return A.LINEAR_NEAREST_MIPLINEAR;
+        case 9987:
+          return A.LINEAR_LINEAR_MIPLINEAR;
+        default:
+          return $.Warn(`${t}/minFilter: Invalid value (${s})`), A.LINEAR_LINEAR_MIPLINEAR;
+      }
+    else
+      switch (n !== 9728 && $.Warn(`${t}/magFilter: Invalid value (${n})`), s) {
+        case 9728:
+          return A.NEAREST_NEAREST;
+        case 9729:
+          return A.NEAREST_LINEAR;
+        case 9984:
+          return A.NEAREST_NEAREST_MIPNEAREST;
+        case 9985:
+          return A.NEAREST_LINEAR_MIPNEAREST;
+        case 9986:
+          return A.NEAREST_NEAREST_MIPLINEAR;
+        case 9987:
+          return A.NEAREST_LINEAR_MIPLINEAR;
+        default:
+          return $.Warn(`${t}/minFilter: Invalid value (${s})`), A.NEAREST_NEAREST_MIPNEAREST;
+      }
+  }
+  static _GetTypedArrayConstructor(t, e) {
+    switch (e) {
+      case 5120:
+        return Int8Array;
+      case 5121:
+        return Uint8Array;
+      case 5122:
+        return Int16Array;
+      case 5123:
+        return Uint16Array;
+      case 5125:
+        return Uint32Array;
+      case 5126:
+        return Float32Array;
+      default:
+        throw new Error(`${t}: Invalid component type ${e}`);
+    }
+  }
+  static _GetTypedArray(t, e, n, s, r) {
+    const o = n.buffer;
+    s = n.byteOffset + (s || 0);
+    const i = u._GetTypedArrayConstructor(`${t}/componentType`, e), a = p.GetTypeByteLength(e);
+    return s % a !== 0 ? ($.Warn(`${t}: Copying buffer as byte offset (${s}) is not a multiple of component type byte length (${a})`), new i(o.slice(s, s + r * a), 0)) : new i(o, s, r);
+  }
+  static _GetNumComponents(t, e) {
+    switch (e) {
+      case "SCALAR":
+        return 1;
+      case "VEC2":
+        return 2;
+      case "VEC3":
+        return 3;
+      case "VEC4":
+        return 4;
+      case "MAT2":
+        return 4;
+      case "MAT3":
+        return 9;
+      case "MAT4":
+        return 16;
+    }
+    throw new Error(`${t}: Invalid type (${e})`);
+  }
+  static _ValidateUri(t) {
+    return L.IsBase64(t) || t.indexOf("..") === -1;
+  }
+  /**
+   * @internal
+   */
+  static _GetDrawMode(t, e) {
+    switch (e == null && (e = 4), e) {
+      case 0:
+        return C.PointListDrawMode;
+      case 1:
+        return C.LineListDrawMode;
+      case 2:
+        return C.LineLoopDrawMode;
+      case 3:
+        return C.LineStripDrawMode;
+      case 4:
+        return C.TriangleFillMode;
+      case 5:
+        return C.TriangleStripDrawMode;
+      case 6:
+        return C.TriangleFanDrawMode;
+    }
+    throw new Error(`${t}: Invalid mesh primitive mode (${e})`);
+  }
+  _compileMaterialsAsync() {
+    this._parent._startPerformanceCounter("Compile materials");
+    const t = new Array();
+    if (this._gltf.materials) {
+      for (const e of this._gltf.materials)
+        if (e._data)
+          for (const n in e._data) {
+            const s = e._data[n];
+            for (const r of s.babylonMeshes) {
+              r.computeWorldMatrix(!0);
+              const o = s.babylonMaterial;
+              t.push(o.forceCompilationAsync(r)), t.push(o.forceCompilationAsync(r, { useInstances: !0 })), this._parent.useClipPlane && (t.push(o.forceCompilationAsync(r, { clipPlane: !0 })), t.push(o.forceCompilationAsync(r, { clipPlane: !0, useInstances: !0 })));
+            }
+          }
+    }
+    return Promise.all(t).then(() => {
+      this._parent._endPerformanceCounter("Compile materials");
+    });
+  }
+  _compileShadowGeneratorsAsync() {
+    this._parent._startPerformanceCounter("Compile shadow generators");
+    const t = new Array(), e = this._babylonScene.lights;
+    for (const n of e) {
+      const s = n.getShadowGenerator();
+      s && t.push(s.forceCompilationAsync());
+    }
+    return Promise.all(t).then(() => {
+      this._parent._endPerformanceCounter("Compile shadow generators");
+    });
+  }
+  _forEachExtensions(t) {
+    for (const e of this._extensions)
+      e.enabled && t(e);
+  }
+  _applyExtensions(t, e, n) {
+    for (const s of this._extensions)
+      if (s.enabled) {
+        const r = `${s.name}.${e}`, o = t;
+        o._activeLoaderExtensionFunctions = o._activeLoaderExtensionFunctions || {};
+        const i = o._activeLoaderExtensionFunctions;
+        if (!i[r]) {
+          i[r] = !0;
+          try {
+            const a = n(s);
+            if (a)
+              return a;
+          } finally {
+            delete i[r];
+          }
+        }
+      }
+    return null;
+  }
+  _extensionsOnLoading() {
+    this._forEachExtensions((t) => t.onLoading && t.onLoading());
+  }
+  _extensionsOnReady() {
+    this._forEachExtensions((t) => t.onReady && t.onReady());
+  }
+  _extensionsLoadSceneAsync(t, e) {
+    return this._applyExtensions(e, "loadScene", (n) => n.loadSceneAsync && n.loadSceneAsync(t, e));
+  }
+  _extensionsLoadNodeAsync(t, e, n) {
+    return this._applyExtensions(e, "loadNode", (s) => s.loadNodeAsync && s.loadNodeAsync(t, e, n));
+  }
+  _extensionsLoadCameraAsync(t, e, n) {
+    return this._applyExtensions(e, "loadCamera", (s) => s.loadCameraAsync && s.loadCameraAsync(t, e, n));
+  }
+  _extensionsLoadVertexDataAsync(t, e, n) {
+    return this._applyExtensions(e, "loadVertexData", (s) => s._loadVertexDataAsync && s._loadVertexDataAsync(t, e, n));
+  }
+  _extensionsLoadMeshPrimitiveAsync(t, e, n, s, r, o) {
+    return this._applyExtensions(r, "loadMeshPrimitive", (i) => i._loadMeshPrimitiveAsync && i._loadMeshPrimitiveAsync(t, e, n, s, r, o));
+  }
+  _extensionsLoadMaterialAsync(t, e, n, s, r) {
+    return this._applyExtensions(e, "loadMaterial", (o) => o._loadMaterialAsync && o._loadMaterialAsync(t, e, n, s, r));
+  }
+  _extensionsCreateMaterial(t, e, n) {
+    return this._applyExtensions(e, "createMaterial", (s) => s.createMaterial && s.createMaterial(t, e, n));
+  }
+  _extensionsLoadMaterialPropertiesAsync(t, e, n) {
+    return this._applyExtensions(e, "loadMaterialProperties", (s) => s.loadMaterialPropertiesAsync && s.loadMaterialPropertiesAsync(t, e, n));
+  }
+  _extensionsLoadTextureInfoAsync(t, e, n) {
+    return this._applyExtensions(e, "loadTextureInfo", (s) => s.loadTextureInfoAsync && s.loadTextureInfoAsync(t, e, n));
+  }
+  _extensionsLoadTextureAsync(t, e, n) {
+    return this._applyExtensions(e, "loadTexture", (s) => s._loadTextureAsync && s._loadTextureAsync(t, e, n));
+  }
+  _extensionsLoadAnimationAsync(t, e) {
+    return this._applyExtensions(e, "loadAnimation", (n) => n.loadAnimationAsync && n.loadAnimationAsync(t, e));
+  }
+  _extensionsLoadAnimationChannelAsync(t, e, n, s, r) {
+    return this._applyExtensions(n, "loadAnimationChannel", (o) => o._loadAnimationChannelAsync && o._loadAnimationChannelAsync(t, e, n, s, r));
+  }
+  _extensionsLoadSkinAsync(t, e, n) {
+    return this._applyExtensions(n, "loadSkin", (s) => s._loadSkinAsync && s._loadSkinAsync(t, e, n));
+  }
+  _extensionsLoadUriAsync(t, e, n) {
+    return this._applyExtensions(e, "loadUri", (s) => s._loadUriAsync && s._loadUriAsync(t, e, n));
+  }
+  _extensionsLoadBufferViewAsync(t, e) {
+    return this._applyExtensions(e, "loadBufferView", (n) => n.loadBufferViewAsync && n.loadBufferViewAsync(t, e));
+  }
+  _extensionsLoadBufferAsync(t, e, n, s) {
+    return this._applyExtensions(e, "loadBuffer", (r) => r.loadBufferAsync && r.loadBufferAsync(t, e, n, s));
+  }
+  /**
+   * Helper method called by a loader extension to load an glTF extension.
+   * @param context The context when loading the asset
+   * @param property The glTF property to load the extension from
+   * @param extensionName The name of the extension to load
+   * @param actionAsync The action to run
+   * @returns The promise returned by actionAsync or null if the extension does not exist
+   */
+  static LoadExtensionAsync(t, e, n, s) {
+    if (!e.extensions)
+      return null;
+    const o = e.extensions[n];
+    return o ? s(`${t}/extensions/${n}`, o) : null;
+  }
+  /**
+   * Helper method called by a loader extension to load a glTF extra.
+   * @param context The context when loading the asset
+   * @param property The glTF property to load the extra from
+   * @param extensionName The name of the extension to load
+   * @param actionAsync The action to run
+   * @returns The promise returned by actionAsync or null if the extra does not exist
+   */
+  static LoadExtraAsync(t, e, n, s) {
+    if (!e.extras)
+      return null;
+    const o = e.extras[n];
+    return o ? s(`${t}/extras/${n}`, o) : null;
+  }
+  /**
+   * Checks for presence of an extension.
+   * @param name The name of the extension to check
+   * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
+   */
+  isExtensionUsed(t) {
+    return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(t) !== -1;
+  }
+  /**
+   * Increments the indentation level and logs a message.
+   * @param message The message to log
+   */
+  logOpen(t) {
+    this._parent._logOpen(t);
+  }
+  /**
+   * Decrements the indentation level.
+   */
+  logClose() {
+    this._parent._logClose();
+  }
+  /**
+   * Logs a message
+   * @param message The message to log
+   */
+  log(t) {
+    this._parent._log(t);
+  }
+  /**
+   * Starts a performance counter.
+   * @param counterName The name of the performance counter
+   */
+  startPerformanceCounter(t) {
+    this._parent._startPerformanceCounter(t);
+  }
+  /**
+   * Ends a performance counter.
+   * @param counterName The name of the performance counter
+   */
+  endPerformanceCounter(t) {
+    this._parent._endPerformanceCounter(t);
+  }
+}
+u._RegisteredExtensions = {};
+u.DefaultSampler = { index: -1 };
+q._CreateGLTF2Loader = (v) => new u(v);
+export {
+  c as ArrayItem,
+  u as GLTFLoader
+};