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

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.data.esm.js

@@ -0,0 +1,173 @@
+import { Animation as e } from "../../../../core/Animations/animation.esm.js";
+import { AnimationPropertyInfo as N, nodeAnimationData as F } from "../glTFLoaderAnimation.esm.js";
+import { Color3 as M } from "../../../../core/Maths/math.color.esm.js";
+function T(o, r, a, i) {
+  return M.FromArray(r, a).scale(i);
+}
+function P(o, r, a, i) {
+  return r[a + 3] * i;
+}
+function t(o, r, a, i) {
+  return r[a] * i;
+}
+function l(o, r, a, i) {
+  return -r[a] * i;
+}
+function c(o, r, a, i) {
+  return r[a + 1] * i;
+}
+function m(o, r, a, i) {
+  return r[a] * i * 2;
+}
+function I(o) {
+  return {
+    scale: [
+      new n(e.ANIMATIONTYPE_FLOAT, `${o}.uScale`, t, () => 2),
+      new n(e.ANIMATIONTYPE_FLOAT, `${o}.vScale`, c, () => 2)
+    ],
+    offset: [
+      new n(e.ANIMATIONTYPE_FLOAT, `${o}.uOffset`, t, () => 2),
+      new n(e.ANIMATIONTYPE_FLOAT, `${o}.vOffset`, c, () => 2)
+    ],
+    rotation: [new n(e.ANIMATIONTYPE_FLOAT, `${o}.wAng`, l, () => 1)]
+  };
+}
+class s extends N {
+  /** @internal */
+  buildAnimations(r, a, i, A, _) {
+    _(r._babylonCamera, this._buildAnimation(a, i, A));
+  }
+}
+class n extends N {
+  /** @internal */
+  buildAnimations(r, a, i, A, _) {
+    for (const u in r._data)
+      _(r._data[u].babylonMaterial, this._buildAnimation(a, i, A));
+  }
+}
+class O extends N {
+  /** @internal */
+  buildAnimations(r, a, i, A, _) {
+    _(r._babylonLight, this._buildAnimation(a, i, A));
+  }
+}
+const L = {
+  __array__: {
+    __target__: !0,
+    ...F
+  }
+}, w = {
+  __array__: {
+    __target__: !0,
+    orthographic: {
+      xmag: [
+        new s(e.ANIMATIONTYPE_FLOAT, "orthoLeft", l, () => 1),
+        new s(e.ANIMATIONTYPE_FLOAT, "orthoRight", c, () => 1)
+      ],
+      ymag: [
+        new s(e.ANIMATIONTYPE_FLOAT, "orthoBottom", l, () => 1),
+        new s(e.ANIMATIONTYPE_FLOAT, "orthoTop", c, () => 1)
+      ],
+      zfar: [new s(e.ANIMATIONTYPE_FLOAT, "maxZ", t, () => 1)],
+      znear: [new s(e.ANIMATIONTYPE_FLOAT, "minZ", t, () => 1)]
+    },
+    perspective: {
+      yfov: [new s(e.ANIMATIONTYPE_FLOAT, "fov", t, () => 1)],
+      zfar: [new s(e.ANIMATIONTYPE_FLOAT, "maxZ", t, () => 1)],
+      znear: [new s(e.ANIMATIONTYPE_FLOAT, "minZ", t, () => 1)]
+    }
+  }
+}, g = {
+  __array__: {
+    __target__: !0,
+    pbrMetallicRoughness: {
+      baseColorFactor: [
+        new n(e.ANIMATIONTYPE_COLOR3, "albedoColor", T, () => 4),
+        new n(e.ANIMATIONTYPE_FLOAT, "alpha", P, () => 4)
+      ],
+      metallicFactor: [new n(e.ANIMATIONTYPE_FLOAT, "metallic", t, () => 1)],
+      roughnessFactor: [new n(e.ANIMATIONTYPE_FLOAT, "roughness", t, () => 1)],
+      baseColorTexture: {
+        extensions: {
+          KHR_texture_transform: I("albedoTexture")
+        }
+      }
+    },
+    emissiveFactor: [new n(e.ANIMATIONTYPE_COLOR3, "emissiveColor", T, () => 3)],
+    normalTexture: {
+      scale: [new n(e.ANIMATIONTYPE_FLOAT, "bumpTexture.level", t, () => 1)]
+    },
+    occlusionTexture: {
+      strength: [new n(e.ANIMATIONTYPE_FLOAT, "ambientTextureStrength", t, () => 1)],
+      extensions: {
+        KHR_texture_transform: I("ambientTexture")
+      }
+    },
+    emissiveTexture: {
+      extensions: {
+        KHR_texture_transform: I("emissiveTexture")
+      }
+    },
+    extensions: {
+      KHR_materials_ior: {
+        ior: [new n(e.ANIMATIONTYPE_FLOAT, "indexOfRefraction", t, () => 1)]
+      },
+      KHR_materials_clearcoat: {
+        clearcoatFactor: [new n(e.ANIMATIONTYPE_FLOAT, "clearCoat.intensity", t, () => 1)],
+        clearcoatRoughnessFactor: [new n(e.ANIMATIONTYPE_FLOAT, "clearCoat.roughness", t, () => 1)]
+      },
+      KHR_materials_sheen: {
+        sheenColorFactor: [new n(e.ANIMATIONTYPE_COLOR3, "sheen.color", T, () => 3)],
+        sheenRoughnessFactor: [new n(e.ANIMATIONTYPE_FLOAT, "sheen.roughness", t, () => 1)]
+      },
+      KHR_materials_specular: {
+        specularFactor: [new n(e.ANIMATIONTYPE_FLOAT, "metallicF0Factor", t, () => 1)],
+        specularColorFactor: [new n(e.ANIMATIONTYPE_COLOR3, "metallicReflectanceColor", T, () => 3)]
+      },
+      KHR_materials_emissive_strength: {
+        emissiveStrength: [new n(e.ANIMATIONTYPE_FLOAT, "emissiveIntensity", t, () => 1)]
+      },
+      KHR_materials_transmission: {
+        transmissionFactor: [new n(e.ANIMATIONTYPE_FLOAT, "subSurface.refractionIntensity", t, () => 1)]
+      },
+      KHR_materials_volume: {
+        attenuationColor: [new n(e.ANIMATIONTYPE_COLOR3, "subSurface.tintColor", T, () => 3)],
+        attenuationDistance: [new n(e.ANIMATIONTYPE_FLOAT, "subSurface.tintColorAtDistance", t, () => 1)],
+        thicknessFactor: [new n(e.ANIMATIONTYPE_FLOAT, "subSurface.maximumThickness", t, () => 1)]
+      },
+      KHR_materials_iridescence: {
+        iridescenceFactor: [new n(e.ANIMATIONTYPE_FLOAT, "iridescence.intensity", t, () => 1)],
+        iridescenceIor: [new n(e.ANIMATIONTYPE_FLOAT, "iridescence.indexOfRefraction", t, () => 1)],
+        iridescenceThicknessMinimum: [new n(e.ANIMATIONTYPE_FLOAT, "iridescence.minimumThickness", t, () => 1)],
+        iridescenceThicknessMaximum: [new n(e.ANIMATIONTYPE_FLOAT, "iridescence.maximumThickness", t, () => 1)]
+      },
+      KHR_materials_anisotropy: {
+        anisotropyStrength: [new n(e.ANIMATIONTYPE_FLOAT, "anisotropy.intensity", t, () => 1)],
+        anisotropyRotation: [new n(e.ANIMATIONTYPE_FLOAT, "anisotropy.angle", t, () => 1)]
+      }
+    }
+  }
+}, E = {
+  KHR_lights_punctual: {
+    lights: {
+      __array__: {
+        __target__: !0,
+        color: [new O(e.ANIMATIONTYPE_COLOR3, "diffuse", T, () => 3)],
+        intensity: [new O(e.ANIMATIONTYPE_FLOAT, "intensity", t, () => 1)],
+        range: [new O(e.ANIMATIONTYPE_FLOAT, "range", t, () => 1)],
+        spot: {
+          innerConeAngle: [new O(e.ANIMATIONTYPE_FLOAT, "innerAngle", m, () => 1)],
+          outerConeAngle: [new O(e.ANIMATIONTYPE_FLOAT, "angle", m, () => 1)]
+        }
+      }
+    }
+  }
+}, d = {
+  nodes: L,
+  materials: g,
+  cameras: w,
+  extensions: E
+};
+export {
+  d as animationPointerTree
+};

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

@@ -0,0 +1,82 @@
+import { GLTFLoader as f } from "../glTFLoader.esm.js";
+import { Logger as s } from "../../../../core/Misc/logger.esm.js";
+import { animationPointerTree as m } from "./KHR_animation_pointer.data.esm.js";
+const u = "KHR_animation_pointer";
+class g {
+  /**
+   * @internal
+   */
+  constructor(e) {
+    this.name = u, this._loader = e;
+  }
+  /**
+   * Defines whether this extension is enabled.
+   */
+  get enabled() {
+    return this._loader.isExtensionUsed(u);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * 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 or null if not handled
+   */
+  _loadAnimationChannelAsync(e, i, a, t, r) {
+    var n;
+    const o = (n = t.target.extensions) === null || n === void 0 ? void 0 : n.KHR_animation_pointer;
+    if (!o)
+      return null;
+    t.target.path !== "pointer" && s.Warn(`${e}/target/path: Value (${t.target.path}) must be (pointer) when using the ${this.name} extension`), t.target.node != null && s.Warn(`${e}/target/node: Value (${t.target.node}) must not be present when using the ${this.name} extension`);
+    const l = `${e}/extensions/${this.name}`, _ = o.pointer;
+    if (!_)
+      throw new Error(`${l}: Pointer is missing`);
+    const d = this._parseAnimationPointer(`${l}/pointer`, _);
+    return d ? this._loader._loadAnimationChannelFromTargetInfoAsync(e, i, a, t, d, r) : (s.Warn(`${l}/pointer: Invalid pointer (${_}) skipped`), null);
+  }
+  /**
+   * The pointer string is represented by a [JSON pointer](https://datatracker.ietf.org/doc/html/rfc6901).
+   * <animationPointer> := /<rootNode>/<assetIndex>/<propertyPath>
+   * <rootNode> := "nodes" | "materials" | "meshes" | "cameras" | "extensions"
+   * <assetIndex> := <digit> | <name>
+   * <propertyPath> := <extensionPath> | <standardPath>
+   * <extensionPath> := "extensions"/<name>/<standardPath>
+   * <standardPath> := <name> | <name>/<standardPath>
+   * <name> := W+
+   * <digit> := D+
+   *
+   * Examples:
+   *  - "/nodes/0/rotation"
+   *  - "/materials/2/emissiveFactor"
+   *  - "/materials/2/pbrMetallicRoughness/baseColorFactor"
+   *  - "/materials/2/extensions/KHR_materials_emissive_strength/emissiveStrength"
+   */
+  _parseAnimationPointer(e, i) {
+    if (!i.startsWith("/"))
+      return s.Warn(`${e}: Value (${i}) must start with a slash`), null;
+    const a = i.split("/");
+    a.shift();
+    let t = m, r = this._loader.gltf, n;
+    for (const o of a) {
+      if (t.__array__)
+        t = t.__array__;
+      else if (t = t[o], !t)
+        return null;
+      r = r && r[o], t.__target__ && (n = r);
+    }
+    return !n || !Array.isArray(t) ? null : {
+      target: n,
+      properties: t
+    };
+  }
+}
+f.RegisterExtension(u, (p) => new g(p));
+export {
+  g as KHR_animation_pointer
+};

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

@@ -0,0 +1,68 @@
+import { DracoCompression as y } from "../../../../core/Meshes/Compression/dracoCompression.esm.js";
+import { VertexBuffer as o } from "../../../../core/Buffers/buffer.esm.js";
+import { Geometry as b } from "../../../../core/Meshes/geometry.esm.js";
+import { GLTFLoader as p, ArrayItem as O } from "../glTFLoader.esm.js";
+const l = "KHR_draco_mesh_compression";
+class E {
+  /**
+   * @internal
+   */
+  constructor(s) {
+    this.name = l, this._loader = s, this.enabled = y.DecoderAvailable && this._loader.isExtensionUsed(l);
+  }
+  /** @internal */
+  dispose() {
+    delete this.dracoCompression, this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  _loadVertexDataAsync(s, r, a) {
+    return p.LoadExtensionAsync(s, r, this.name, (T, u) => {
+      if (r.mode != null) {
+        if (r.mode !== 5 && r.mode !== 4)
+          throw new Error(`${s}: Unsupported mode ${r.mode}`);
+        if (r.mode === 5)
+          throw new Error(`${s}: Mode ${r.mode} is not currently supported`);
+      }
+      const m = {}, h = {}, e = (t, c) => {
+        const n = u.attributes[t];
+        if (n === void 0 || r.attributes[t] === void 0)
+          return;
+        m[c] = n;
+        const d = O.Get(`${s}/attributes/${t}`, this._loader.gltf.accessors, r.attributes[t]);
+        if (d.normalized && d.componentType !== 5126) {
+          let f = 1;
+          switch (d.componentType) {
+            case 5120:
+              f = 127;
+              break;
+            case 5121:
+              f = 255;
+              break;
+            case 5122:
+              f = 32767;
+              break;
+            case 5123:
+              f = 65535;
+              break;
+          }
+          h[c] = f;
+        }
+        a._delayInfo = a._delayInfo || [], a._delayInfo.indexOf(c) === -1 && a._delayInfo.push(c);
+      };
+      e("POSITION", o.PositionKind), e("NORMAL", o.NormalKind), e("TANGENT", o.TangentKind), e("TEXCOORD_0", o.UVKind), e("TEXCOORD_1", o.UV2Kind), e("TEXCOORD_2", o.UV3Kind), e("TEXCOORD_3", o.UV4Kind), e("TEXCOORD_4", o.UV5Kind), e("TEXCOORD_5", o.UV6Kind), e("JOINTS_0", o.MatricesIndicesKind), e("WEIGHTS_0", o.MatricesWeightsKind), e("COLOR_0", o.ColorKind);
+      const i = O.Get(T, this._loader.gltf.bufferViews, u.bufferView);
+      return i._dracoBabylonGeometry || (i._dracoBabylonGeometry = this._loader.loadBufferViewAsync(`/bufferViews/${i.index}`, i).then((t) => (this.dracoCompression || y.Default).decodeMeshAsync(t, m, h).then((n) => {
+        const d = new b(a.name, this._loader.babylonScene);
+        return n.applyToGeometry(d), d;
+      }).catch((n) => {
+        throw new Error(`${s}: ${n.message}`);
+      }))), i._dracoBabylonGeometry;
+    });
+  }
+}
+p.RegisterExtension(l, (_) => new E(_));
+export {
+  E as KHR_draco_mesh_compression
+};

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

@@ -0,0 +1,60 @@
+import { Vector3 as s } from "../../../../core/Maths/math.vector.esm.js";
+import { Color3 as _ } from "../../../../core/Maths/math.color.esm.js";
+import { DirectionalLight as m } from "../../../../core/Lights/directionalLight.esm.js";
+import { PointLight as y } from "../../../../core/Lights/pointLight.esm.js";
+import { SpotLight as f } from "../../../../core/Lights/spotLight.esm.js";
+import { Light as L } from "../../../../core/Lights/light.esm.js";
+import { GLTFLoader as h, ArrayItem as g } from "../glTFLoader.esm.js";
+const c = "KHR_lights_punctual";
+class A {
+  /**
+   * @internal
+   */
+  constructor(o) {
+    this.name = c, this._loader = o, this.enabled = this._loader.isExtensionUsed(c);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null, delete this._lights;
+  }
+  /** @internal */
+  onLoading() {
+    const o = this._loader.gltf.extensions;
+    if (o && o[this.name]) {
+      const i = o[this.name];
+      this._lights = i.lights, g.Assign(this._lights);
+    }
+  }
+  /**
+   * @internal
+   */
+  loadNodeAsync(o, i, b) {
+    return h.LoadExtensionAsync(o, i, this.name, (a, p) => this._loader.loadNodeAsync(o, i, (r) => {
+      let e;
+      const t = g.Get(a, this._lights, p.light), l = t.name || r.name;
+      switch (this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer, t.type) {
+        case "directional": {
+          const n = new m(l, s.Backward(), this._loader.babylonScene);
+          n.position.setAll(0), e = n;
+          break;
+        }
+        case "point": {
+          e = new y(l, s.Zero(), this._loader.babylonScene);
+          break;
+        }
+        case "spot": {
+          const n = new f(l, s.Zero(), s.Backward(), 0, 1, this._loader.babylonScene);
+          n.angle = (t.spot && t.spot.outerConeAngle || Math.PI / 4) * 2, n.innerAngle = (t.spot && t.spot.innerConeAngle || 0) * 2, e = n;
+          break;
+        }
+        default:
+          throw this._loader.babylonScene._blockEntityCollection = !1, new Error(`${a}: Invalid light type (${t.type})`);
+      }
+      e._parentContainer = this._loader._assetContainer, this._loader.babylonScene._blockEntityCollection = !1, t._babylonLight = e, e.falloffType = L.FALLOFF_GLTF, e.diffuse = t.color ? _.FromArray(t.color) : _.White(), e.intensity = t.intensity == null ? 1 : t.intensity, e.range = t.range == null ? Number.MAX_VALUE : t.range, e.parent = r, this._loader._babylonLights.push(e), h.AddPointerMetadata(e, a), b(r);
+    }));
+  }
+}
+h.RegisterExtension(c, (d) => new A(d));
+export {
+  A as KHR_lights
+};

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

@@ -0,0 +1,39 @@
+import { PBRMaterial as h } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as p } from "../glTFLoader.esm.js";
+const i = "KHR_materials_anisotropy";
+class l {
+  /**
+   * @internal
+   */
+  constructor(o) {
+    this.name = i, this.order = 195, this._loader = o, this.enabled = this._loader.isExtensionUsed(i);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(o, r, s) {
+    return p.LoadExtensionAsync(o, r, this.name, (t, n) => {
+      const e = new Array();
+      return e.push(this._loader.loadMaterialPropertiesAsync(o, r, s)), e.push(this._loadIridescencePropertiesAsync(t, n, s)), Promise.all(e).then(() => {
+      });
+    });
+  }
+  _loadIridescencePropertiesAsync(o, r, s) {
+    var t, n;
+    if (!(s instanceof h))
+      throw new Error(`${o}: Material type not supported`);
+    const e = new Array();
+    return s.anisotropy.isEnabled = !0, s.anisotropy.intensity = (t = r.anisotropyStrength) !== null && t !== void 0 ? t : 0, s.anisotropy.angle = (n = r.anisotropyRotation) !== null && n !== void 0 ? n : 0, r.anisotropyTexture && e.push(this._loader.loadTextureInfoAsync(`${o}/anisotropyTexture`, r.anisotropyTexture, (d) => {
+      d.name = `${s.name} (Anisotropy Intensity)`, s.anisotropy.texture = d;
+    })), Promise.all(e).then(() => {
+    });
+  }
+}
+p.RegisterExtension(i, (a) => new l(a));
+export {
+  l as KHR_materials_anisotropy
+};

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

@@ -0,0 +1,42 @@
+import { PBRMaterial as l } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as u } from "../glTFLoader.esm.js";
+const c = "KHR_materials_clearcoat";
+class h {
+  /**
+   * @internal
+   */
+  constructor(t) {
+    this.name = c, this.order = 190, this._loader = t, this.enabled = this._loader.isExtensionUsed(c);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(t, a, e) {
+    return u.LoadExtensionAsync(t, a, this.name, (o, r) => {
+      const s = new Array();
+      return s.push(this._loader.loadMaterialPropertiesAsync(t, a, e)), s.push(this._loadClearCoatPropertiesAsync(o, r, e)), Promise.all(s).then(() => {
+      });
+    });
+  }
+  _loadClearCoatPropertiesAsync(t, a, e) {
+    if (!(e instanceof l))
+      throw new Error(`${t}: Material type not supported`);
+    const o = new Array();
+    return e.clearCoat.isEnabled = !0, e.clearCoat.useRoughnessFromMainTexture = !1, e.clearCoat.remapF0OnInterfaceChange = !1, a.clearcoatFactor != null ? e.clearCoat.intensity = a.clearcoatFactor : e.clearCoat.intensity = 0, a.clearcoatTexture && o.push(this._loader.loadTextureInfoAsync(`${t}/clearcoatTexture`, a.clearcoatTexture, (r) => {
+      r.name = `${e.name} (ClearCoat Intensity)`, e.clearCoat.texture = r;
+    })), a.clearcoatRoughnessFactor != null ? e.clearCoat.roughness = a.clearcoatRoughnessFactor : e.clearCoat.roughness = 0, a.clearcoatRoughnessTexture && (a.clearcoatRoughnessTexture.nonColorData = !0, o.push(this._loader.loadTextureInfoAsync(`${t}/clearcoatRoughnessTexture`, a.clearcoatRoughnessTexture, (r) => {
+      r.name = `${e.name} (ClearCoat Roughness)`, e.clearCoat.textureRoughness = r;
+    }))), a.clearcoatNormalTexture && (a.clearcoatNormalTexture.nonColorData = !0, o.push(this._loader.loadTextureInfoAsync(`${t}/clearcoatNormalTexture`, a.clearcoatNormalTexture, (r) => {
+      r.name = `${e.name} (ClearCoat Normal)`, e.clearCoat.bumpTexture = r;
+    })), e.invertNormalMapX = !e.getScene().useRightHandedSystem, e.invertNormalMapY = e.getScene().useRightHandedSystem, a.clearcoatNormalTexture.scale != null && (e.clearCoat.bumpTexture.level = a.clearcoatNormalTexture.scale)), Promise.all(o).then(() => {
+    });
+  }
+}
+u.RegisterExtension(c, (n) => new h(n));
+export {
+  h as KHR_materials_clearcoat
+};

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

@@ -0,0 +1,32 @@
+import { PBRMaterial as d } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as o } from "../glTFLoader.esm.js";
+const r = "KHR_materials_emissive_strength";
+class h {
+  /**
+   * @internal
+   */
+  constructor(e) {
+    this.name = r, this.order = 170, this._loader = e, this.enabled = this._loader.isExtensionUsed(r);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(e, i, s) {
+    return o.LoadExtensionAsync(e, i, this.name, (n, a) => this._loader.loadMaterialPropertiesAsync(e, i, s).then(() => {
+      this._loadEmissiveProperties(n, a, s);
+    }));
+  }
+  _loadEmissiveProperties(e, i, s) {
+    if (!(s instanceof d))
+      throw new Error(`${e}: Material type not supported`);
+    i.emissiveStrength !== void 0 && s.emissiveColor.scaleToRef(i.emissiveStrength, s.emissiveColor);
+  }
+}
+o.RegisterExtension(r, (t) => new h(t));
+export {
+  h as KHR_materials_emissive_strength
+};

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

@@ -0,0 +1,35 @@
+import { PBRMaterial as h } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as n } from "../glTFLoader.esm.js";
+const t = "KHR_materials_ior";
+class o {
+  /**
+   * @internal
+   */
+  constructor(e) {
+    this.name = t, this.order = 180, this._loader = e, this.enabled = this._loader.isExtensionUsed(t);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(e, s, r) {
+    return n.LoadExtensionAsync(e, s, this.name, (a, l) => {
+      const i = new Array();
+      return i.push(this._loader.loadMaterialPropertiesAsync(e, s, r)), i.push(this._loadIorPropertiesAsync(a, l, r)), Promise.all(i).then(() => {
+      });
+    });
+  }
+  _loadIorPropertiesAsync(e, s, r) {
+    if (!(r instanceof h))
+      throw new Error(`${e}: Material type not supported`);
+    return s.ior !== void 0 ? r.indexOfRefraction = s.ior : r.indexOfRefraction = o._DEFAULT_IOR, Promise.resolve();
+  }
+}
+o._DEFAULT_IOR = 1.5;
+n.RegisterExtension(t, (d) => new o(d));
+export {
+  o as KHR_materials_ior
+};

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

@@ -0,0 +1,41 @@
+import { PBRMaterial as _ } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as T } from "../glTFLoader.esm.js";
+const h = "KHR_materials_iridescence";
+class l {
+  /**
+   * @internal
+   */
+  constructor(s) {
+    this.name = h, this.order = 195, this._loader = s, this.enabled = this._loader.isExtensionUsed(h);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(s, i, e) {
+    return T.LoadExtensionAsync(s, i, this.name, (c, r) => {
+      const n = new Array();
+      return n.push(this._loader.loadMaterialPropertiesAsync(s, i, e)), n.push(this._loadIridescencePropertiesAsync(c, r, e)), Promise.all(n).then(() => {
+      });
+    });
+  }
+  _loadIridescencePropertiesAsync(s, i, e) {
+    var c, r, n, t, o;
+    if (!(e instanceof _))
+      throw new Error(`${s}: Material type not supported`);
+    const u = new Array();
+    return e.iridescence.isEnabled = !0, e.iridescence.intensity = (c = i.iridescenceFactor) !== null && c !== void 0 ? c : 0, e.iridescence.indexOfRefraction = (n = (r = i.iridescenceIor) !== null && r !== void 0 ? r : i.iridescenceIOR) !== null && n !== void 0 ? n : 1.3, e.iridescence.minimumThickness = (t = i.iridescenceThicknessMinimum) !== null && t !== void 0 ? t : 100, e.iridescence.maximumThickness = (o = i.iridescenceThicknessMaximum) !== null && o !== void 0 ? o : 400, i.iridescenceTexture && u.push(this._loader.loadTextureInfoAsync(`${s}/iridescenceTexture`, i.iridescenceTexture, (d) => {
+      d.name = `${e.name} (Iridescence Intensity)`, e.iridescence.texture = d;
+    })), i.iridescenceThicknessTexture && u.push(this._loader.loadTextureInfoAsync(`${s}/iridescenceThicknessTexture`, i.iridescenceThicknessTexture, (d) => {
+      d.name = `${e.name} (Iridescence Thickness)`, e.iridescence.thicknessTexture = d;
+    })), Promise.all(u).then(() => {
+    });
+  }
+}
+T.RegisterExtension(h, (m) => new l(m));
+export {
+  l as KHR_materials_iridescence
+};

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

@@ -0,0 +1,41 @@
+import { Color3 as l } from "../../../../core/Maths/math.color.esm.js";
+import { PBRMaterial as d } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as n } from "../glTFLoader.esm.js";
+const t = "KHR_materials_pbrSpecularGlossiness";
+class f {
+  /**
+   * @internal
+   */
+  constructor(r) {
+    this.name = t, this.order = 200, this._loader = r, this.enabled = this._loader.isExtensionUsed(t);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(r, i, e) {
+    return n.LoadExtensionAsync(r, i, this.name, (s, u) => {
+      const o = new Array();
+      return o.push(this._loader.loadMaterialBasePropertiesAsync(r, i, e)), o.push(this._loadSpecularGlossinessPropertiesAsync(s, i, u, e)), this._loader.loadMaterialAlphaProperties(r, i, e), Promise.all(o).then(() => {
+      });
+    });
+  }
+  _loadSpecularGlossinessPropertiesAsync(r, i, e, s) {
+    if (!(s instanceof d))
+      throw new Error(`${r}: Material type not supported`);
+    const u = new Array();
+    return s.metallic = null, s.roughness = null, e.diffuseFactor ? (s.albedoColor = l.FromArray(e.diffuseFactor), s.alpha = e.diffuseFactor[3]) : s.albedoColor = l.White(), s.reflectivityColor = e.specularFactor ? l.FromArray(e.specularFactor) : l.White(), s.microSurface = e.glossinessFactor == null ? 1 : e.glossinessFactor, e.diffuseTexture && u.push(this._loader.loadTextureInfoAsync(`${r}/diffuseTexture`, e.diffuseTexture, (o) => {
+      o.name = `${s.name} (Diffuse)`, s.albedoTexture = o;
+    })), e.specularGlossinessTexture && (u.push(this._loader.loadTextureInfoAsync(`${r}/specularGlossinessTexture`, e.specularGlossinessTexture, (o) => {
+      o.name = `${s.name} (Specular Glossiness)`, s.reflectivityTexture = o, s.reflectivityTexture.hasAlpha = !0;
+    })), s.useMicroSurfaceFromReflectivityMapAlpha = !0), Promise.all(u).then(() => {
+    });
+  }
+}
+n.RegisterExtension(t, (c) => new f(c));
+export {
+  f as KHR_materials_pbrSpecularGlossiness
+};

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

@@ -0,0 +1,41 @@
+import { PBRMaterial as c } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as i } from "../glTFLoader.esm.js";
+import { Color3 as d } from "../../../../core/Maths/math.color.esm.js";
+const u = "KHR_materials_sheen";
+class m {
+  /**
+   * @internal
+   */
+  constructor(n) {
+    this.name = u, this.order = 190, this._loader = n, this.enabled = this._loader.isExtensionUsed(u);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(n, s, e) {
+    return i.LoadExtensionAsync(n, s, this.name, (h, o) => {
+      const r = new Array();
+      return r.push(this._loader.loadMaterialPropertiesAsync(n, s, e)), r.push(this._loadSheenPropertiesAsync(h, o, e)), Promise.all(r).then(() => {
+      });
+    });
+  }
+  _loadSheenPropertiesAsync(n, s, e) {
+    if (!(e instanceof c))
+      throw new Error(`${n}: Material type not supported`);
+    const h = new Array();
+    return e.sheen.isEnabled = !0, e.sheen.intensity = 1, s.sheenColorFactor != null ? e.sheen.color = d.FromArray(s.sheenColorFactor) : e.sheen.color = d.Black(), s.sheenColorTexture && h.push(this._loader.loadTextureInfoAsync(`${n}/sheenColorTexture`, s.sheenColorTexture, (o) => {
+      o.name = `${e.name} (Sheen Color)`, e.sheen.texture = o;
+    })), s.sheenRoughnessFactor !== void 0 ? e.sheen.roughness = s.sheenRoughnessFactor : e.sheen.roughness = 0, s.sheenRoughnessTexture && (s.sheenRoughnessTexture.nonColorData = !0, h.push(this._loader.loadTextureInfoAsync(`${n}/sheenRoughnessTexture`, s.sheenRoughnessTexture, (o) => {
+      o.name = `${e.name} (Sheen Roughness)`, e.sheen.textureRoughness = o;
+    }))), e.sheen.albedoScaling = !0, e.sheen.useRoughnessFromMainTexture = !1, Promise.all(h).then(() => {
+    });
+  }
+}
+i.RegisterExtension(u, (t) => new m(t));
+export {
+  m as KHR_materials_sheen
+};