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

package/dist/node_modules/@babylonjs/core/Materials/PBR/pbrSubSurfaceConfiguration.esm.js

@@ -0,0 +1,270 @@
+import { __decorate as t } from "../../tslib.es6.esm.js";
+import { serialize as r, expandToProperty as o, serializeAsTexture as h, serializeAsColor3 as A } from "../../Misc/decorators.esm.js";
+import { Color3 as f } from "../../Maths/math.color.esm.js";
+import { MaterialFlags as n } from "../materialFlags.esm.js";
+import { MaterialHelper as c } from "../materialHelper.esm.js";
+import { Scalar as p } from "../../Maths/math.scalar.esm.js";
+import { TmpVectors as u } from "../../Maths/math.vector.esm.js";
+import { MaterialPluginBase as O } from "../materialPluginBase.esm.js";
+import { MaterialDefines as d } from "../materialDefines.esm.js";
+class F extends d {
+  constructor() {
+    super(...arguments), this.SUBSURFACE = !1, this.SS_REFRACTION = !1, this.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = !1, this.SS_TRANSLUCENCY = !1, this.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = !1, this.SS_SCATTERING = !1, this.SS_THICKNESSANDMASK_TEXTURE = !1, this.SS_THICKNESSANDMASK_TEXTUREDIRECTUV = 0, this.SS_HAS_THICKNESS = !1, this.SS_REFRACTIONINTENSITY_TEXTURE = !1, this.SS_REFRACTIONINTENSITY_TEXTUREDIRECTUV = 0, this.SS_TRANSLUCENCYINTENSITY_TEXTURE = !1, this.SS_TRANSLUCENCYINTENSITY_TEXTUREDIRECTUV = 0, this.SS_REFRACTIONMAP_3D = !1, this.SS_REFRACTIONMAP_OPPOSITEZ = !1, this.SS_LODINREFRACTIONALPHA = !1, this.SS_GAMMAREFRACTION = !1, this.SS_RGBDREFRACTION = !1, this.SS_LINEARSPECULARREFRACTION = !1, this.SS_LINKREFRACTIONTOTRANSPARENCY = !1, this.SS_ALBEDOFORREFRACTIONTINT = !1, this.SS_ALBEDOFORTRANSLUCENCYTINT = !1, this.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = !1, this.SS_USE_THICKNESS_AS_DEPTH = !1, this.SS_MASK_FROM_THICKNESS_TEXTURE = !1, this.SS_USE_GLTF_TEXTURES = !1;
+  }
+}
+class s extends O {
+  /**
+   * Diffusion profile for subsurface scattering.
+   * Useful for better scattering in the skins or foliages.
+   */
+  get scatteringDiffusionProfile() {
+    return this._scene.subSurfaceConfiguration ? this._scene.subSurfaceConfiguration.ssDiffusionProfileColors[this._scatteringDiffusionProfileIndex] : null;
+  }
+  set scatteringDiffusionProfile(e) {
+    this._scene.enableSubSurfaceForPrePass() && e && (this._scatteringDiffusionProfileIndex = this._scene.subSurfaceConfiguration.addDiffusionProfile(e));
+  }
+  /**
+   * Index of refraction of the material's volume.
+   * https://en.wikipedia.org/wiki/List_of_refractive_indices
+   *
+   * This ONLY impacts refraction. If not provided or given a non-valid value,
+   * the volume will use the same IOR as the surface.
+   */
+  get volumeIndexOfRefraction() {
+    return this._volumeIndexOfRefraction >= 1 ? this._volumeIndexOfRefraction : this._indexOfRefraction;
+  }
+  set volumeIndexOfRefraction(e) {
+    e >= 1 ? this._volumeIndexOfRefraction = e : this._volumeIndexOfRefraction = -1;
+  }
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isRefractionEnabled || this._isTranslucencyEnabled || this._isScatteringEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  /** @internal */
+  _markScenePrePassDirty() {
+    this._internalMarkAllSubMeshesAsTexturesDirty(), this._internalMarkScenePrePassDirty();
+  }
+  constructor(e, a = !0) {
+    super(e, "PBRSubSurface", 130, new F(), a), this._isRefractionEnabled = !1, this.isRefractionEnabled = !1, this._isTranslucencyEnabled = !1, this.isTranslucencyEnabled = !1, this._isScatteringEnabled = !1, this.isScatteringEnabled = !1, this._scatteringDiffusionProfileIndex = 0, this.refractionIntensity = 1, this.translucencyIntensity = 1, this.useAlbedoToTintRefraction = !1, this.useAlbedoToTintTranslucency = !1, this._thicknessTexture = null, this.thicknessTexture = null, this._refractionTexture = null, this.refractionTexture = null, this._indexOfRefraction = 1.5, this.indexOfRefraction = 1.5, this._volumeIndexOfRefraction = -1, this._invertRefractionY = !1, this.invertRefractionY = !1, this._linkRefractionWithTransparency = !1, this.linkRefractionWithTransparency = !1, this.minimumThickness = 0, this.maximumThickness = 1, this.useThicknessAsDepth = !1, this.tintColor = f.White(), this.tintColorAtDistance = 1, this.diffusionDistance = f.White(), this._useMaskFromThicknessTexture = !1, this.useMaskFromThicknessTexture = !1, this._refractionIntensityTexture = null, this.refractionIntensityTexture = null, this._translucencyIntensityTexture = null, this.translucencyIntensityTexture = null, this._useGltfStyleTextures = !1, this.useGltfStyleTextures = !1, this._scene = e.getScene(), this.registerForExtraEvents = !0, this._internalMarkAllSubMeshesAsTexturesDirty = e._dirtyCallbacks[1], this._internalMarkScenePrePassDirty = e._dirtyCallbacks[32];
+  }
+  isReadyForSubMesh(e, a) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled)
+      return !0;
+    if (e._areTexturesDirty && a.texturesEnabled) {
+      if (this._thicknessTexture && n.ThicknessTextureEnabled && !this._thicknessTexture.isReadyOrNotBlocking())
+        return !1;
+      const l = this._getRefractionTexture(a);
+      if (l && n.RefractionTextureEnabled && !l.isReadyOrNotBlocking())
+        return !1;
+    }
+    return !0;
+  }
+  prepareDefinesBeforeAttributes(e, a) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled) {
+      e.SUBSURFACE = !1, e.SS_TRANSLUCENCY = !1, e.SS_SCATTERING = !1, e.SS_REFRACTION = !1, e.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = !1, e.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = !1, e.SS_THICKNESSANDMASK_TEXTURE = !1, e.SS_THICKNESSANDMASK_TEXTUREDIRECTUV = 0, e.SS_HAS_THICKNESS = !1, e.SS_REFRACTIONINTENSITY_TEXTURE = !1, e.SS_REFRACTIONINTENSITY_TEXTUREDIRECTUV = 0, e.SS_TRANSLUCENCYINTENSITY_TEXTURE = !1, e.SS_TRANSLUCENCYINTENSITY_TEXTUREDIRECTUV = 0, e.SS_REFRACTIONMAP_3D = !1, e.SS_REFRACTIONMAP_OPPOSITEZ = !1, e.SS_LODINREFRACTIONALPHA = !1, e.SS_GAMMAREFRACTION = !1, e.SS_RGBDREFRACTION = !1, e.SS_LINEARSPECULARREFRACTION = !1, e.SS_LINKREFRACTIONTOTRANSPARENCY = !1, e.SS_ALBEDOFORREFRACTIONTINT = !1, e.SS_ALBEDOFORTRANSLUCENCYTINT = !1, e.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = !1, e.SS_USE_THICKNESS_AS_DEPTH = !1, e.SS_MASK_FROM_THICKNESS_TEXTURE = !1, e.SS_USE_GLTF_TEXTURES = !1;
+      return;
+    }
+    if (e._areTexturesDirty) {
+      e.SUBSURFACE = !0, e.SS_TRANSLUCENCY = this._isTranslucencyEnabled, e.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = !1, e.SS_SCATTERING = this._isScatteringEnabled, e.SS_THICKNESSANDMASK_TEXTURE = !1, e.SS_REFRACTIONINTENSITY_TEXTURE = !1, e.SS_TRANSLUCENCYINTENSITY_TEXTURE = !1, e.SS_HAS_THICKNESS = !1, e.SS_MASK_FROM_THICKNESS_TEXTURE = !1, e.SS_USE_GLTF_TEXTURES = !1, e.SS_REFRACTION = !1, e.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = !1, e.SS_REFRACTIONMAP_3D = !1, e.SS_GAMMAREFRACTION = !1, e.SS_RGBDREFRACTION = !1, e.SS_LINEARSPECULARREFRACTION = !1, e.SS_REFRACTIONMAP_OPPOSITEZ = !1, e.SS_LODINREFRACTIONALPHA = !1, e.SS_LINKREFRACTIONTOTRANSPARENCY = !1, e.SS_ALBEDOFORREFRACTIONTINT = !1, e.SS_ALBEDOFORTRANSLUCENCYTINT = !1, e.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = !1, e.SS_USE_THICKNESS_AS_DEPTH = !1;
+      const l = !!this._thicknessTexture && !!this._refractionIntensityTexture && this._refractionIntensityTexture.checkTransformsAreIdentical(this._thicknessTexture) && this._refractionIntensityTexture._texture === this._thicknessTexture._texture, _ = !!this._thicknessTexture && !!this._translucencyIntensityTexture && this._translucencyIntensityTexture.checkTransformsAreIdentical(this._thicknessTexture) && this._translucencyIntensityTexture._texture === this._thicknessTexture._texture, T = (l || !this._refractionIntensityTexture) && (_ || !this._translucencyIntensityTexture);
+      if (e._areTexturesDirty && a.texturesEnabled && (this._thicknessTexture && n.ThicknessTextureEnabled && c.PrepareDefinesForMergedUV(this._thicknessTexture, e, "SS_THICKNESSANDMASK_TEXTURE"), this._refractionIntensityTexture && n.RefractionIntensityTextureEnabled && !T && c.PrepareDefinesForMergedUV(this._refractionIntensityTexture, e, "SS_REFRACTIONINTENSITY_TEXTURE"), this._translucencyIntensityTexture && n.TranslucencyIntensityTextureEnabled && !T && c.PrepareDefinesForMergedUV(this._translucencyIntensityTexture, e, "SS_TRANSLUCENCYINTENSITY_TEXTURE")), e.SS_HAS_THICKNESS = this.maximumThickness - this.minimumThickness !== 0, e.SS_MASK_FROM_THICKNESS_TEXTURE = (this._useMaskFromThicknessTexture || !!this._refractionIntensityTexture || !!this._translucencyIntensityTexture) && T, e.SS_USE_GLTF_TEXTURES = this._useGltfStyleTextures, e.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = (this._useMaskFromThicknessTexture || !!this._refractionIntensityTexture) && T, e.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = (this._useMaskFromThicknessTexture || !!this._translucencyIntensityTexture) && T, this._isRefractionEnabled && a.texturesEnabled) {
+        const S = this._getRefractionTexture(a);
+        S && n.RefractionTextureEnabled && (e.SS_REFRACTION = !0, e.SS_REFRACTIONMAP_3D = S.isCube, e.SS_GAMMAREFRACTION = S.gammaSpace, e.SS_RGBDREFRACTION = S.isRGBD, e.SS_LINEARSPECULARREFRACTION = S.linearSpecularLOD, e.SS_REFRACTIONMAP_OPPOSITEZ = this._scene.useRightHandedSystem && S.isCube ? !S.invertZ : S.invertZ, e.SS_LODINREFRACTIONALPHA = S.lodLevelInAlpha, e.SS_LINKREFRACTIONTOTRANSPARENCY = this._linkRefractionWithTransparency, e.SS_ALBEDOFORREFRACTIONTINT = this.useAlbedoToTintRefraction, e.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = S.isCube && S.boundingBoxSize, e.SS_USE_THICKNESS_AS_DEPTH = this.useThicknessAsDepth);
+      }
+      this._isTranslucencyEnabled && (e.SS_ALBEDOFORTRANSLUCENCYTINT = this.useAlbedoToTintTranslucency);
+    }
+  }
+  /**
+   * Binds the material data (this function is called even if mustRebind() returns false)
+   * @param uniformBuffer defines the Uniform buffer to fill in.
+   * @param scene defines the scene the material belongs to.
+   * @param engine defines the engine the material belongs to.
+   * @param subMesh the submesh to bind data for
+   */
+  hardBindForSubMesh(e, a, l, _) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled)
+      return;
+    _.getRenderingMesh().getWorldMatrix().decompose(u.Vector3[0]);
+    const T = Math.max(Math.abs(u.Vector3[0].x), Math.abs(u.Vector3[0].y), Math.abs(u.Vector3[0].z));
+    e.updateFloat2("vThicknessParam", this.minimumThickness * T, (this.maximumThickness - this.minimumThickness) * T);
+  }
+  bindForSubMesh(e, a, l, _) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled)
+      return;
+    const T = _.materialDefines, S = this._material.isFrozen, N = this._material.realTimeFiltering, y = T.LODBASEDMICROSFURACE, i = this._getRefractionTexture(a);
+    if (!e.useUbo || !S || !e.isSync) {
+      if (this._thicknessTexture && n.ThicknessTextureEnabled && (e.updateFloat2("vThicknessInfos", this._thicknessTexture.coordinatesIndex, this._thicknessTexture.level), c.BindTextureMatrix(this._thicknessTexture, e, "thickness")), this._refractionIntensityTexture && n.RefractionIntensityTextureEnabled && T.SS_REFRACTIONINTENSITY_TEXTURE && (e.updateFloat2("vRefractionIntensityInfos", this._refractionIntensityTexture.coordinatesIndex, this._refractionIntensityTexture.level), c.BindTextureMatrix(this._refractionIntensityTexture, e, "refractionIntensity")), this._translucencyIntensityTexture && n.TranslucencyIntensityTextureEnabled && T.SS_TRANSLUCENCYINTENSITY_TEXTURE && (e.updateFloat2("vTranslucencyIntensityInfos", this._translucencyIntensityTexture.coordinatesIndex, this._translucencyIntensityTexture.level), c.BindTextureMatrix(this._translucencyIntensityTexture, e, "translucencyIntensity")), i && n.RefractionTextureEnabled) {
+        e.updateMatrix("refractionMatrix", i.getRefractionTextureMatrix());
+        let R = 1;
+        i.isCube || i.depth && (R = i.depth);
+        const E = i.getSize().width, C = this.volumeIndexOfRefraction;
+        if (e.updateFloat4("vRefractionInfos", i.level, 1 / C, R, this._invertRefractionY ? -1 : 1), e.updateFloat4("vRefractionMicrosurfaceInfos", E, i.lodGenerationScale, i.lodGenerationOffset, 1 / this.indexOfRefraction), N && e.updateFloat2("vRefractionFilteringInfo", E, p.Log2(E)), i.boundingBoxSize) {
+          const I = i;
+          e.updateVector3("vRefractionPosition", I.boundingBoxPosition), e.updateVector3("vRefractionSize", I.boundingBoxSize);
+        }
+      }
+      this._isScatteringEnabled && e.updateFloat("scatteringDiffusionProfile", this._scatteringDiffusionProfileIndex), e.updateColor3("vDiffusionDistance", this.diffusionDistance), e.updateFloat4("vTintColor", this.tintColor.r, this.tintColor.g, this.tintColor.b, Math.max(1e-5, this.tintColorAtDistance)), e.updateFloat3("vSubSurfaceIntensity", this.refractionIntensity, this.translucencyIntensity, 0);
+    }
+    a.texturesEnabled && (this._thicknessTexture && n.ThicknessTextureEnabled && e.setTexture("thicknessSampler", this._thicknessTexture), this._refractionIntensityTexture && n.RefractionIntensityTextureEnabled && T.SS_REFRACTIONINTENSITY_TEXTURE && e.setTexture("refractionIntensitySampler", this._refractionIntensityTexture), this._translucencyIntensityTexture && n.TranslucencyIntensityTextureEnabled && T.SS_TRANSLUCENCYINTENSITY_TEXTURE && e.setTexture("translucencyIntensitySampler", this._translucencyIntensityTexture), i && n.RefractionTextureEnabled && (y ? e.setTexture("refractionSampler", i) : (e.setTexture("refractionSampler", i._lodTextureMid || i), e.setTexture("refractionSamplerLow", i._lodTextureLow || i), e.setTexture("refractionSamplerHigh", i._lodTextureHigh || i))));
+  }
+  /**
+   * Returns the texture used for refraction or null if none is used.
+   * @param scene defines the scene the material belongs to.
+   * @returns - Refraction texture if present.  If no refraction texture and refraction
+   * is linked with transparency, returns environment texture.  Otherwise, returns null.
+   */
+  _getRefractionTexture(e) {
+    return this._refractionTexture ? this._refractionTexture : this._isRefractionEnabled ? e.environmentTexture : null;
+  }
+  /**
+   * Returns true if alpha blending should be disabled.
+   */
+  get disableAlphaBlending() {
+    return this._isRefractionEnabled && this._linkRefractionWithTransparency;
+  }
+  /**
+   * Fills the list of render target textures.
+   * @param renderTargets the list of render targets to update
+   */
+  fillRenderTargetTextures(e) {
+    n.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget && e.push(this._refractionTexture);
+  }
+  hasTexture(e) {
+    return this._thicknessTexture === e || this._refractionTexture === e;
+  }
+  hasRenderTargetTextures() {
+    return !!(n.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget);
+  }
+  getActiveTextures(e) {
+    this._thicknessTexture && e.push(this._thicknessTexture), this._refractionTexture && e.push(this._refractionTexture);
+  }
+  getAnimatables(e) {
+    this._thicknessTexture && this._thicknessTexture.animations && this._thicknessTexture.animations.length > 0 && e.push(this._thicknessTexture), this._refractionTexture && this._refractionTexture.animations && this._refractionTexture.animations.length > 0 && e.push(this._refractionTexture);
+  }
+  dispose(e) {
+    e && (this._thicknessTexture && this._thicknessTexture.dispose(), this._refractionTexture && this._refractionTexture.dispose());
+  }
+  getClassName() {
+    return "PBRSubSurfaceConfiguration";
+  }
+  addFallbacks(e, a, l) {
+    return e.SS_SCATTERING && a.addFallback(l++, "SS_SCATTERING"), e.SS_TRANSLUCENCY && a.addFallback(l++, "SS_TRANSLUCENCY"), l;
+  }
+  getSamplers(e) {
+    e.push("thicknessSampler", "refractionIntensitySampler", "translucencyIntensitySampler", "refractionSampler", "refractionSamplerLow", "refractionSamplerHigh");
+  }
+  getUniforms() {
+    return {
+      ubo: [
+        { name: "vRefractionMicrosurfaceInfos", size: 4, type: "vec4" },
+        { name: "vRefractionFilteringInfo", size: 2, type: "vec2" },
+        { name: "vTranslucencyIntensityInfos", size: 2, type: "vec2" },
+        { name: "vRefractionInfos", size: 4, type: "vec4" },
+        { name: "refractionMatrix", size: 16, type: "mat4" },
+        { name: "vThicknessInfos", size: 2, type: "vec2" },
+        { name: "vRefractionIntensityInfos", size: 2, type: "vec2" },
+        { name: "thicknessMatrix", size: 16, type: "mat4" },
+        { name: "refractionIntensityMatrix", size: 16, type: "mat4" },
+        { name: "translucencyIntensityMatrix", size: 16, type: "mat4" },
+        { name: "vThicknessParam", size: 2, type: "vec2" },
+        { name: "vDiffusionDistance", size: 3, type: "vec3" },
+        { name: "vTintColor", size: 4, type: "vec4" },
+        { name: "vSubSurfaceIntensity", size: 3, type: "vec3" },
+        { name: "vRefractionPosition", size: 3, type: "vec3" },
+        { name: "vRefractionSize", size: 3, type: "vec3" },
+        { name: "scatteringDiffusionProfile", size: 1, type: "float" }
+      ]
+    };
+  }
+}
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "isRefractionEnabled", void 0);
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "isTranslucencyEnabled", void 0);
+t([
+  r(),
+  o("_markScenePrePassDirty")
+], s.prototype, "isScatteringEnabled", void 0);
+t([
+  r()
+], s.prototype, "_scatteringDiffusionProfileIndex", void 0);
+t([
+  r()
+], s.prototype, "refractionIntensity", void 0);
+t([
+  r()
+], s.prototype, "translucencyIntensity", void 0);
+t([
+  r()
+], s.prototype, "useAlbedoToTintRefraction", void 0);
+t([
+  r()
+], s.prototype, "useAlbedoToTintTranslucency", void 0);
+t([
+  h(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "thicknessTexture", void 0);
+t([
+  h(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "refractionTexture", void 0);
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "indexOfRefraction", void 0);
+t([
+  r()
+], s.prototype, "_volumeIndexOfRefraction", void 0);
+t([
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "volumeIndexOfRefraction", null);
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "invertRefractionY", void 0);
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "linkRefractionWithTransparency", void 0);
+t([
+  r()
+], s.prototype, "minimumThickness", void 0);
+t([
+  r()
+], s.prototype, "maximumThickness", void 0);
+t([
+  r()
+], s.prototype, "useThicknessAsDepth", void 0);
+t([
+  A()
+], s.prototype, "tintColor", void 0);
+t([
+  r()
+], s.prototype, "tintColorAtDistance", void 0);
+t([
+  A()
+], s.prototype, "diffusionDistance", void 0);
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "useMaskFromThicknessTexture", void 0);
+t([
+  h(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "refractionIntensityTexture", void 0);
+t([
+  h(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "translucencyIntensityTexture", void 0);
+t([
+  r(),
+  o("_markAllSubMeshesAsTexturesDirty")
+], s.prototype, "useGltfStyleTextures", void 0);
+export {
+  F as MaterialSubSurfaceDefines,
+  s as PBRSubSurfaceConfiguration
+};

package/dist/node_modules/@babylonjs/core/Materials/Textures/Filtering/hdrFiltering.esm.js

@@ -0,0 +1,103 @@
+import "../../../Maths/math.axis.esm.js";
+import "../../../Maths/math.color.esm.js";
+import "../../../Maths/math.plane.esm.js";
+import "../../../Maths/math.path.esm.js";
+import { Vector3 as t } from "../../../Maths/math.vector.esm.js";
+import { Scalar as d } from "../../../Maths/math.scalar.esm.js";
+import { EffectWrapper as u, EffectRenderer as g } from "../../effectRenderer.esm.js";
+import "../../../Shaders/hdrFiltering.vertex.esm.js";
+import "../../../Shaders/hdrFiltering.fragment.esm.js";
+import { Logger as _ } from "../../../Misc/logger.esm.js";
+class b {
+  /**
+   * Instantiates HDR filter for reflection maps
+   *
+   * @param engine Thin engine
+   * @param options Options
+   */
+  constructor(e, r = {}) {
+    this._lodGenerationOffset = 0, this._lodGenerationScale = 0.8, this.quality = 4096, this.hdrScale = 1, this._engine = e, this.hdrScale = r.hdrScale || this.hdrScale, this.quality = r.quality || this.quality;
+  }
+  _createRenderTarget(e) {
+    let r = 0;
+    this._engine.getCaps().textureHalfFloatRender ? r = 2 : this._engine.getCaps().textureFloatRender && (r = 1);
+    const i = this._engine.createRenderTargetCubeTexture(e, {
+      format: 5,
+      type: r,
+      createMipMaps: !0,
+      generateMipMaps: !1,
+      generateDepthBuffer: !1,
+      generateStencilBuffer: !1,
+      samplingMode: 1
+    });
+    return this._engine.updateTextureWrappingMode(i.texture, 0, 0, 0), this._engine.updateTextureSamplingMode(3, i.texture, !0), i;
+  }
+  _prefilterInternal(e) {
+    const r = e.getSize().width, i = d.ILog2(r) + 1, n = this._effectWrapper.effect, s = this._createRenderTarget(r);
+    this._effectRenderer.setViewport();
+    const p = e.getInternalTexture();
+    p && this._engine.updateTextureSamplingMode(3, p, !0), this._effectRenderer.applyEffectWrapper(this._effectWrapper);
+    const o = [
+      [new t(0, 0, -1), new t(0, -1, 0), new t(1, 0, 0)],
+      [new t(0, 0, 1), new t(0, -1, 0), new t(-1, 0, 0)],
+      [new t(1, 0, 0), new t(0, 0, 1), new t(0, 1, 0)],
+      [new t(1, 0, 0), new t(0, 0, -1), new t(0, -1, 0)],
+      [new t(1, 0, 0), new t(0, -1, 0), new t(0, 0, 1)],
+      [new t(-1, 0, 0), new t(0, -1, 0), new t(0, 0, -1)]
+      // NegativeZ
+    ];
+    n.setFloat("hdrScale", this.hdrScale), n.setFloat2("vFilteringInfo", e.getSize().width, i), n.setTexture("inputTexture", e);
+    for (let a = 0; a < 6; a++) {
+      n.setVector3("up", o[a][0]), n.setVector3("right", o[a][1]), n.setVector3("front", o[a][2]);
+      for (let f = 0; f < i; f++) {
+        this._engine.bindFramebuffer(s, a, void 0, void 0, !0, f), this._effectRenderer.applyEffectWrapper(this._effectWrapper);
+        let l = Math.pow(2, (f - this._lodGenerationOffset) / this._lodGenerationScale) / r;
+        f === 0 && (l = 0), n.setFloat("alphaG", l), this._effectRenderer.draw();
+      }
+    }
+    this._effectRenderer.restoreStates(), this._engine.restoreDefaultFramebuffer(), this._engine._releaseTexture(e._texture);
+    const c = s.texture.type, h = s.texture.format;
+    return s._swapAndDie(e._texture), e._texture.type = c, e._texture.format = h, e.gammaSpace = !1, e.lodGenerationOffset = this._lodGenerationOffset, e.lodGenerationScale = this._lodGenerationScale, e._prefiltered = !0, e;
+  }
+  _createEffect(e, r) {
+    const i = [];
+    return e.gammaSpace && i.push("#define GAMMA_INPUT"), i.push("#define NUM_SAMPLES " + this.quality + "u"), new u({
+      engine: this._engine,
+      name: "hdrFiltering",
+      vertexShader: "hdrFiltering",
+      fragmentShader: "hdrFiltering",
+      samplerNames: ["inputTexture"],
+      uniformNames: ["vSampleDirections", "vWeights", "up", "right", "front", "vFilteringInfo", "hdrScale", "alphaG"],
+      useShaderStore: !0,
+      defines: i,
+      onCompiled: r
+    });
+  }
+  /**
+   * Get a value indicating if the filter is ready to be used
+   * @param texture Texture to filter
+   * @returns true if the filter is ready
+   */
+  isReady(e) {
+    return e.isReady() && this._effectWrapper.effect.isReady();
+  }
+  /**
+   * Prefilters a cube texture to have mipmap levels representing roughness values.
+   * Prefiltering will be invoked at the end of next rendering pass.
+   * This has to be done once the map is loaded, and has not been prefiltered by a third party software.
+   * See http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf for more information
+   * @param texture Texture to filter
+   * @param onFinished Callback when filtering is done
+   * @returns Promise called when prefiltering is done
+   */
+  prefilter(e, r = null) {
+    return this._engine._features.allowTexturePrefiltering ? new Promise((i) => {
+      this._effectRenderer = new g(this._engine), this._effectWrapper = this._createEffect(e), this._effectWrapper.effect.executeWhenCompiled(() => {
+        this._prefilterInternal(e), this._effectRenderer.dispose(), this._effectWrapper.dispose(), i(), r && r();
+      });
+    }) : (_.Warn("HDR prefiltering is not available in WebGL 1., you can use real time filtering instead."), Promise.reject("HDR prefiltering is not available in WebGL 1., you can use real time filtering instead."));
+  }
+}
+export {
+  b as HDRFiltering
+};

package/dist/node_modules/@babylonjs/core/Materials/Textures/Loaders/ddsTextureLoader.esm.js

@@ -0,0 +1,53 @@
+import { SphericalPolynomial as t } from "../../../Maths/sphericalPolynomial.esm.js";
+import { Engine as h } from "../../../Engines/engine.esm.js";
+import { DDSTools as s } from "../../../Misc/dds.esm.js";
+class C {
+  constructor() {
+    this.supportCascades = !0;
+  }
+  /**
+   * This returns if the loader support the current file information.
+   * @param extension defines the file extension of the file being loaded
+   * @returns true if the loader can load the specified file
+   */
+  canLoad(o) {
+    return o.endsWith(".dds");
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   * @param imgs contains the cube maps
+   * @param texture defines the BabylonJS internal texture
+   * @param createPolynomials will be true if polynomials have been requested
+   * @param onLoad defines the callback to trigger once the texture is ready
+   */
+  loadCubeData(o, i, d, e) {
+    const n = i.getEngine();
+    let a, l = !1, m = 1e3;
+    if (Array.isArray(o))
+      for (let p = 0; p < o.length; p++) {
+        const r = o[p];
+        a = s.GetDDSInfo(r), i.width = a.width, i.height = a.height, l = (a.isRGB || a.isLuminance || a.mipmapCount > 1) && i.generateMipMaps, n._unpackFlipY(a.isCompressed), s.UploadDDSLevels(n, i, r, a, l, 6, -1, p), !a.isFourCC && a.mipmapCount === 1 ? n.generateMipMapsForCubemap(i) : m = a.mipmapCount - 1;
+      }
+    else {
+      const p = o;
+      a = s.GetDDSInfo(p), i.width = a.width, i.height = a.height, d && (a.sphericalPolynomial = new t()), l = (a.isRGB || a.isLuminance || a.mipmapCount > 1) && i.generateMipMaps, n._unpackFlipY(a.isCompressed), s.UploadDDSLevels(n, i, p, a, l, 6), !a.isFourCC && a.mipmapCount === 1 ? n.generateMipMapsForCubemap(i, !1) : m = a.mipmapCount - 1;
+    }
+    n._setCubeMapTextureParams(i, l, m), i.isReady = !0, i.onLoadedObservable.notifyObservers(i), i.onLoadedObservable.clear(), e && e({ isDDS: !0, width: i.width, info: a, data: o, texture: i });
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param callback defines the method to call once ready to upload
+   */
+  loadData(o, i, d) {
+    const e = s.GetDDSInfo(o), n = (e.isRGB || e.isLuminance || e.mipmapCount > 1) && i.generateMipMaps && e.width >> e.mipmapCount - 1 === 1;
+    d(e.width, e.height, n, e.isFourCC, () => {
+      s.UploadDDSLevels(i.getEngine(), i, o, e, n, 1);
+    });
+  }
+}
+h._TextureLoaders.push(new C());
+export {
+  C as _DDSTextureLoader
+};

package/dist/node_modules/@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.esm.js

@@ -0,0 +1,51 @@
+import { GetEnvInfo as o, UploadEnvSpherical as d, UploadEnvLevelsAsync as t } from "../../../Misc/environmentTextureTools.esm.js";
+import { Engine as v } from "../../../Engines/engine.esm.js";
+class p {
+  constructor() {
+    this.supportCascades = !1;
+  }
+  /**
+   * This returns if the loader support the current file information.
+   * @param extension defines the file extension of the file being loaded
+   * @returns true if the loader can load the specified file
+   */
+  canLoad(a) {
+    return a.endsWith(".env");
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param createPolynomials will be true if polynomials have been requested
+   * @param onLoad defines the callback to trigger once the texture is ready
+   * @param onError defines the callback to trigger in case of error
+   */
+  loadCubeData(a, e, c, s, n) {
+    if (Array.isArray(a))
+      return;
+    const i = o(a);
+    if (i) {
+      e.width = i.width, e.height = i.width;
+      try {
+        d(e, i), t(e, a, i).then(() => {
+          e.isReady = !0, e.onLoadedObservable.notifyObservers(e), e.onLoadedObservable.clear(), s && s();
+        }, (l) => {
+          n == null || n("Can not upload environment levels", l);
+        });
+      } catch (l) {
+        n == null || n("Can not upload environment file", l);
+      }
+    } else
+      n && n("Can not parse the environment file", null);
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   */
+  loadData() {
+    throw ".env not supported in 2d.";
+  }
+}
+v._TextureLoaders.push(new p());
+export {
+  p as _ENVTextureLoader
+};

package/dist/node_modules/@babylonjs/core/Materials/Textures/Loaders/ktxTextureLoader.esm.js

@@ -0,0 +1,81 @@
+import { KhronosTextureContainer as o } from "../../../Misc/khronosTextureContainer.esm.js";
+import { KhronosTextureContainer2 as l } from "../../../Misc/khronosTextureContainer2.esm.js";
+import { Engine as f } from "../../../Engines/engine.esm.js";
+import { Logger as t } from "../../../Misc/logger.esm.js";
+function m(p) {
+  switch (p) {
+    case 35916:
+      return 33776;
+    case 35918:
+      return 33778;
+    case 35919:
+      return 33779;
+    case 37493:
+      return 37492;
+    case 37497:
+      return 37496;
+    case 37495:
+      return 37494;
+    case 37840:
+      return 37808;
+    case 36493:
+      return 36492;
+  }
+  return null;
+}
+class d {
+  constructor() {
+    this.supportCascades = !1;
+  }
+  /**
+   * This returns if the loader support the current file information.
+   * @param extension defines the file extension of the file being loaded
+   * @param mimeType defines the optional mime type of the file being loaded
+   * @returns true if the loader can load the specified file
+   */
+  canLoad(a, e) {
+    return a.endsWith(".ktx") || a.endsWith(".ktx2") || e === "image/ktx" || e === "image/ktx2";
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param createPolynomials will be true if polynomials have been requested
+   * @param onLoad defines the callback to trigger once the texture is ready
+   */
+  loadCubeData(a, e, s, i) {
+    if (Array.isArray(a))
+      return;
+    e._invertVScale = !e.invertY;
+    const n = e.getEngine(), r = new o(a, 6), g = r.numberOfMipmapLevels > 1 && e.generateMipMaps;
+    n._unpackFlipY(!0), r.uploadLevels(e, e.generateMipMaps), e.width = r.pixelWidth, e.height = r.pixelHeight, n._setCubeMapTextureParams(e, g, r.numberOfMipmapLevels - 1), e.isReady = !0, e.onLoadedObservable.notifyObservers(e), e.onLoadedObservable.clear(), i && i();
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param callback defines the method to call once ready to upload
+   * @param options
+   */
+  loadData(a, e, s, i) {
+    if (o.IsValid(a)) {
+      e._invertVScale = !e.invertY;
+      const n = new o(a, 1), r = m(n.glInternalFormat);
+      r ? (e.format = r, e._useSRGBBuffer = e.getEngine()._getUseSRGBBuffer(!0, e.generateMipMaps), e._gammaSpace = !0) : e.format = n.glInternalFormat, s(n.pixelWidth, n.pixelHeight, e.generateMipMaps, !0, () => {
+        n.uploadLevels(e, e.generateMipMaps);
+      }, n.isInvalid);
+    } else
+      l.IsValid(a) ? new l(e.getEngine()).uploadAsync(a, e, i).then(() => {
+        s(e.width, e.height, e.generateMipMaps, !0, () => {
+        }, !1);
+      }, (r) => {
+        t.Warn(`Failed to load KTX2 texture data: ${r.message}`), s(0, 0, !1, !1, () => {
+        }, !0);
+      }) : (t.Error("texture missing KTX identifier"), s(0, 0, !1, !1, () => {
+      }, !0));
+  }
+}
+f._TextureLoaders.unshift(new d());
+export {
+  d as _KTXTextureLoader
+};