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

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

@@ -0,0 +1,244 @@
+import { __decorate as u } from "../../tslib.es6.esm.js";
+import { SerializationHelper as S, serialize as _, serializeAsVector3 as M, serializeAsMatrix as O } from "../../Misc/decorators.esm.js";
+import { Tools as L } from "../../Misc/tools.esm.js";
+import { Matrix as c, Vector3 as b, TmpVectors as y } from "../../Maths/math.vector.esm.js";
+import { BaseTexture as R } from "./baseTexture.esm.js";
+import { Texture as v } from "./texture.esm.js";
+import { GetClass as z, RegisterClass as C } from "../../Misc/typeStore.esm.js";
+import "../../Engines/Extensions/engine.cubeTexture.esm.js";
+import { Observable as A } from "../../Misc/observable.esm.js";
+class r extends R {
+  /**
+   * Gets or sets the size of the bounding box associated with the cube texture
+   * When defined, the cubemap will switch to local mode
+   * @see https://community.arm.com/graphics/b/blog/posts/reflections-based-on-local-cubemaps-in-unity
+   * @example https://www.babylonjs-playground.com/#RNASML
+   */
+  set boundingBoxSize(t) {
+    if (this._boundingBoxSize && this._boundingBoxSize.equals(t))
+      return;
+    this._boundingBoxSize = t;
+    const e = this.getScene();
+    e && e.markAllMaterialsAsDirty(1);
+  }
+  /**
+   * Returns the bounding box size
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#using-local-cubemap-mode
+   */
+  get boundingBoxSize() {
+    return this._boundingBoxSize;
+  }
+  /**
+   * Sets texture matrix rotation angle around Y axis in radians.
+   */
+  set rotationY(t) {
+    this._rotationY = t, this.setReflectionTextureMatrix(c.RotationY(this._rotationY));
+  }
+  /**
+   * Gets texture matrix rotation angle around Y axis radians.
+   */
+  get rotationY() {
+    return this._rotationY;
+  }
+  /**
+   * Are mip maps generated for this texture or not.
+   */
+  get noMipmap() {
+    return this._noMipmap;
+  }
+  /**
+   * Gets the forced extension (if any)
+   */
+  get forcedExtension() {
+    return this._forcedExtension;
+  }
+  /**
+   * Creates a cube texture from an array of image urls
+   * @param files defines an array of image urls
+   * @param scene defines the hosting scene
+   * @param noMipmap specifies if mip maps are not used
+   * @returns a cube texture
+   */
+  static CreateFromImages(t, e, s) {
+    let n = "";
+    return t.forEach((i) => n += i), new r(n, e, null, s, t);
+  }
+  /**
+   * Creates and return a texture created from prefilterd data by tools like IBL Baker or Lys.
+   * @param url defines the url of the prefiltered texture
+   * @param scene defines the scene the texture is attached to
+   * @param forcedExtension defines the extension of the file if different from the url
+   * @param createPolynomials defines whether or not to create polynomial harmonics from the texture data if necessary
+   * @returns the prefiltered texture
+   */
+  static CreateFromPrefilteredData(t, e, s = null, n = !0) {
+    const i = e.useDelayedTextureLoading;
+    e.useDelayedTextureLoading = !1;
+    const o = new r(t, e, null, !1, null, null, null, void 0, !0, s, n);
+    return e.useDelayedTextureLoading = i, o;
+  }
+  /**
+   * Creates a cube texture to use with reflection for instance. It can be based upon dds or six images as well
+   * as prefiltered data.
+   * @param rootUrl defines the url of the texture or the root name of the six images
+   * @param sceneOrEngine defines the scene or engine the texture is attached to
+   * @param extensions defines the suffixes add to the picture name in case six images are in use like _px.jpg...
+   * @param noMipmap defines if mipmaps should be created or not
+   * @param files defines the six files to load for the different faces in that order: px, py, pz, nx, ny, nz
+   * @param onLoad defines a callback triggered at the end of the file load if no errors occurred
+   * @param onError defines a callback triggered in case of error during load
+   * @param format defines the internal format to use for the texture once loaded
+   * @param prefiltered defines whether or not the texture is created from prefiltered data
+   * @param forcedExtension defines the extensions to use (force a special type of file to load) in case it is different from the file name
+   * @param createPolynomials defines whether or not to create polynomial harmonics from the texture data if necessary
+   * @param lodScale defines the scale applied to environment texture. This manages the range of LOD level used for IBL according to the roughness
+   * @param lodOffset defines the offset applied to environment texture. This manages first LOD level used for IBL according to the roughness
+   * @param loaderOptions options to be passed to the loader
+   * @param useSRGBBuffer Defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU) (default: false)
+   * @returns the cube texture
+   */
+  constructor(t, e, s = null, n = !1, i = null, o = null, a = null, l = 5, h = !1, d = null, g = !1, x = 0.8, m = 0, f, B) {
+    var p;
+    super(e), this._lodScale = 0.8, this._lodOffset = 0, this.onLoadObservable = new A(), this.boundingBoxPosition = b.Zero(), this._rotationY = 0, this._files = null, this._forcedExtension = null, this._extensions = null, this._textureMatrixRefraction = new c(), this.name = t, this.url = t, this._noMipmap = n, this.hasAlpha = !1, this._format = l, this.isCube = !0, this._textureMatrix = c.Identity(), this._createPolynomials = g, this.coordinatesMode = v.CUBIC_MODE, this._extensions = s, this._files = i, this._forcedExtension = d, this._loaderOptions = f, this._useSRGBBuffer = B, this._lodScale = x, this._lodOffset = m, !(!t && !i) && this.updateURL(t, d, o, h, a, s, (p = this.getScene()) === null || p === void 0 ? void 0 : p.useDelayedTextureLoading, i);
+  }
+  /**
+   * Get the current class name of the texture useful for serialization or dynamic coding.
+   * @returns "CubeTexture"
+   */
+  getClassName() {
+    return "CubeTexture";
+  }
+  /**
+   * Update the url (and optional buffer) of this texture if url was null during construction.
+   * @param url the url of the texture
+   * @param forcedExtension defines the extension to use
+   * @param onLoad callback called when the texture is loaded  (defaults to null)
+   * @param prefiltered Defines whether the updated texture is prefiltered or not
+   * @param onError callback called if there was an error during the loading process (defaults to null)
+   * @param extensions defines the suffixes add to the picture name in case six images are in use like _px.jpg...
+   * @param delayLoad defines if the texture should be loaded now (false by default)
+   * @param files defines the six files to load for the different faces in that order: px, py, pz, nx, ny, nz
+   */
+  updateURL(t, e, s = null, n = !1, i = null, o = null, a = !1, l = null) {
+    (!this.name || this.name.startsWith("data:")) && (this.name = t), this.url = t, e && (this._forcedExtension = e);
+    const h = t.lastIndexOf("."), d = e || (h > -1 ? t.substring(h).toLowerCase() : ""), g = d.indexOf(".dds") === 0, x = d.indexOf(".env") === 0, m = d.indexOf(".basis") === 0;
+    if (x ? (this.gammaSpace = !1, this._prefiltered = !1, this.anisotropicFilteringLevel = 1) : (this._prefiltered = n, n && (this.gammaSpace = !1, this.anisotropicFilteringLevel = 1)), l)
+      this._files = l;
+    else if (!m && !x && !g && !o && (o = ["_px.jpg", "_py.jpg", "_pz.jpg", "_nx.jpg", "_ny.jpg", "_nz.jpg"]), this._files = this._files || [], this._files.length = 0, o) {
+      for (let f = 0; f < o.length; f++)
+        this._files.push(t + o[f]);
+      this._extensions = o;
+    }
+    a ? (this.delayLoadState = 4, this._delayedOnLoad = s, this._delayedOnError = i) : this._loadTexture(s, i);
+  }
+  /**
+   * Delays loading of the cube texture
+   * @param forcedExtension defines the extension to use
+   */
+  delayLoad(t) {
+    this.delayLoadState === 4 && (t && (this._forcedExtension = t), this.delayLoadState = 1, this._loadTexture(this._delayedOnLoad, this._delayedOnError));
+  }
+  /**
+   * Returns the reflection texture matrix
+   * @returns the reflection texture matrix
+   */
+  getReflectionTextureMatrix() {
+    return this._textureMatrix;
+  }
+  /**
+   * Sets the reflection texture matrix
+   * @param value Reflection texture matrix
+   */
+  setReflectionTextureMatrix(t) {
+    var e, s;
+    if (t.updateFlag === this._textureMatrix.updateFlag || (t.isIdentity() !== this._textureMatrix.isIdentity() && ((e = this.getScene()) === null || e === void 0 || e.markAllMaterialsAsDirty(1, (a) => a.getActiveTextures().indexOf(this) !== -1)), this._textureMatrix = t, !(!((s = this.getScene()) === null || s === void 0) && s.useRightHandedSystem)))
+      return;
+    const n = y.Vector3[0], i = y.Quaternion[0], o = y.Vector3[1];
+    this._textureMatrix.decompose(n, i, o), i.z *= -1, i.w *= -1, c.ComposeToRef(n, i, o, this._textureMatrixRefraction);
+  }
+  /**
+   * Gets a suitable rotate/transform matrix when the texture is used for refraction.
+   * There's a separate function from getReflectionTextureMatrix because refraction requires a special configuration of the matrix in right-handed mode.
+   * @returns The refraction matrix
+   */
+  getRefractionTextureMatrix() {
+    var t;
+    return !((t = this.getScene()) === null || t === void 0) && t.useRightHandedSystem ? this._textureMatrixRefraction : this._textureMatrix;
+  }
+  _loadTexture(t = null, e = null) {
+    var s;
+    const n = this.getScene(), i = this._texture;
+    this._texture = this._getFromCache(this.url, this._noMipmap, void 0, void 0, this._useSRGBBuffer, this.isCube);
+    const o = () => {
+      var l;
+      this.onLoadObservable.notifyObservers(this), i && (i.dispose(), (l = this.getScene()) === null || l === void 0 || l.markAllMaterialsAsDirty(1)), t && t();
+    }, a = (l, h) => {
+      this._loadingError = !0, this._errorObject = { message: l, exception: h }, e && e(l, h), v.OnTextureLoadErrorObservable.notifyObservers(this);
+    };
+    this._texture ? this._texture.isReady ? L.SetImmediate(() => o()) : this._texture.onLoadedObservable.add(() => o()) : (this._prefiltered ? this._texture = this._getEngine().createPrefilteredCubeTexture(this.url, n, this._lodScale, this._lodOffset, t, a, this._format, this._forcedExtension, this._createPolynomials) : this._texture = this._getEngine().createCubeTexture(this.url, n, this._files, this._noMipmap, t, a, this._format, this._forcedExtension, !1, this._lodScale, this._lodOffset, null, this._loaderOptions, !!this._useSRGBBuffer), (s = this._texture) === null || s === void 0 || s.onLoadedObservable.add(() => this.onLoadObservable.notifyObservers(this)));
+  }
+  /**
+   * Parses text to create a cube texture
+   * @param parsedTexture define the serialized text to read from
+   * @param scene defines the hosting scene
+   * @param rootUrl defines the root url of the cube texture
+   * @returns a cube texture
+   */
+  static Parse(t, e, s) {
+    const n = S.Parse(() => {
+      var i;
+      let o = !1;
+      return t.prefiltered && (o = t.prefiltered), new r(s + ((i = t.url) !== null && i !== void 0 ? i : t.name), e, t.extensions, !1, t.files || null, null, null, void 0, o, t.forcedExtension);
+    }, t, e);
+    if (t.boundingBoxPosition && (n.boundingBoxPosition = b.FromArray(t.boundingBoxPosition)), t.boundingBoxSize && (n.boundingBoxSize = b.FromArray(t.boundingBoxSize)), t.animations)
+      for (let i = 0; i < t.animations.length; i++) {
+        const o = t.animations[i], a = z("BABYLON.Animation");
+        a && n.animations.push(a.Parse(o));
+      }
+    return n;
+  }
+  /**
+   * Makes a clone, or deep copy, of the cube texture
+   * @returns a new cube texture
+   */
+  clone() {
+    let t = 0;
+    const e = S.Clone(() => {
+      const s = new r(this.url, this.getScene() || this._getEngine(), this._extensions, this._noMipmap, this._files);
+      return t = s.uniqueId, s;
+    }, this);
+    return e.uniqueId = t, e;
+  }
+}
+u([
+  _()
+], r.prototype, "url", void 0);
+u([
+  M()
+], r.prototype, "boundingBoxPosition", void 0);
+u([
+  M()
+], r.prototype, "boundingBoxSize", null);
+u([
+  _("rotationY")
+], r.prototype, "rotationY", null);
+u([
+  _("files")
+], r.prototype, "_files", void 0);
+u([
+  _("forcedExtension")
+], r.prototype, "_forcedExtension", void 0);
+u([
+  _("extensions")
+], r.prototype, "_extensions", void 0);
+u([
+  O("textureMatrix")
+], r.prototype, "_textureMatrix", void 0);
+u([
+  O("textureMatrixRefraction")
+], r.prototype, "_textureMatrixRefraction", void 0);
+v._CubeTextureParser = r.Parse;
+C("BABYLON.CubeTexture", r);
+export {
+  r as CubeTexture
+};

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

@@ -0,0 +1,134 @@
+import { Logger as _ } from "../../Misc/logger.esm.js";
+import { Texture as d } from "./texture.esm.js";
+import "../../Engines/Extensions/engine.dynamicTexture.esm.js";
+class l extends d {
+  /**
+   * Creates a DynamicTexture
+   * @param name defines the name of the texture
+   * @param options provides 3 alternatives for width and height of texture, a canvas, object with width and height properties, number for both width and height
+   * @param scene defines the scene where you want the texture
+   * @param generateMipMaps defines the use of MinMaps or not (default is false)
+   * @param samplingMode defines the sampling mode to use (default is Texture.TRILINEAR_SAMPLINGMODE)
+   * @param format defines the texture format to use (default is Engine.TEXTUREFORMAT_RGBA)
+   * @param invertY defines if the texture needs to be inverted on the y axis during loading
+   */
+  constructor(t, e, i = null, h = !1, a = 3, r = 5, c) {
+    super(null, i, !h, c, a, void 0, void 0, void 0, void 0, r), this.name = t, this.wrapU = d.CLAMP_ADDRESSMODE, this.wrapV = d.CLAMP_ADDRESSMODE, this._generateMipMaps = h;
+    const n = this._getEngine();
+    if (!n)
+      return;
+    e.getContext ? (this._canvas = e, this._texture = n.createDynamicTexture(e.width, e.height, h, a)) : (this._canvas = n.createCanvas(1, 1), e.width || e.width === 0 ? this._texture = n.createDynamicTexture(e.width, e.height, h, a) : this._texture = n.createDynamicTexture(e, e, h, a));
+    const s = this.getSize();
+    this._canvas.width !== s.width && (this._canvas.width = s.width), this._canvas.height !== s.height && (this._canvas.height = s.height), this._context = this._canvas.getContext("2d");
+  }
+  /**
+   * Get the current class name of the texture useful for serialization or dynamic coding.
+   * @returns "DynamicTexture"
+   */
+  getClassName() {
+    return "DynamicTexture";
+  }
+  /**
+   * Gets the current state of canRescale
+   */
+  get canRescale() {
+    return !0;
+  }
+  _recreate(t) {
+    this._canvas.width = t.width, this._canvas.height = t.height, this.releaseInternalTexture(), this._texture = this._getEngine().createDynamicTexture(t.width, t.height, this._generateMipMaps, this.samplingMode);
+  }
+  /**
+   * Scales the texture
+   * @param ratio the scale factor to apply to both width and height
+   */
+  scale(t) {
+    const e = this.getSize();
+    e.width *= t, e.height *= t, this._recreate(e);
+  }
+  /**
+   * Resizes the texture
+   * @param width the new width
+   * @param height the new height
+   */
+  scaleTo(t, e) {
+    const i = this.getSize();
+    i.width = t, i.height = e, this._recreate(i);
+  }
+  /**
+   * Gets the context of the canvas used by the texture
+   * @returns the canvas context of the dynamic texture
+   */
+  getContext() {
+    return this._context;
+  }
+  /**
+   * Clears the texture
+   */
+  clear() {
+    const t = this.getSize();
+    this._context.fillRect(0, 0, t.width, t.height);
+  }
+  /**
+   * Updates the texture
+   * @param invertY defines the direction for the Y axis (default is true - y increases downwards)
+   * @param premulAlpha defines if alpha is stored as premultiplied (default is false)
+   * @param allowGPUOptimization true to allow some specific GPU optimizations (subject to engine feature "allowGPUOptimizationsForGUI" being true)
+   */
+  update(t, e = !1, i = !1) {
+    this._getEngine().updateDynamicTexture(this._texture, this._canvas, t === void 0 ? !0 : t, e, this._format || void 0, void 0, i);
+  }
+  /**
+   * Draws text onto the texture
+   * @param text defines the text to be drawn
+   * @param x defines the placement of the text from the left
+   * @param y defines the placement of the text from the top when invertY is true and from the bottom when false
+   * @param font defines the font to be used with font-style, font-size, font-name
+   * @param color defines the color used for the text
+   * @param clearColor defines the color for the canvas, use null to not overwrite canvas
+   * @param invertY defines the direction for the Y axis (default is true - y increases downwards)
+   * @param update defines whether texture is immediately update (default is true)
+   */
+  drawText(t, e, i, h, a, r, c, n = !0) {
+    const s = this.getSize();
+    if (r && (this._context.fillStyle = r, this._context.fillRect(0, 0, s.width, s.height)), this._context.font = h, e == null) {
+      const u = this._context.measureText(t);
+      e = (s.width - u.width) / 2;
+    }
+    if (i == null) {
+      const u = parseInt(h.replace(/\D/g, ""));
+      i = s.height / 2 + u / 3.65;
+    }
+    this._context.fillStyle = a || "", this._context.fillText(t, e, i), n && this.update(c);
+  }
+  /**
+   * Clones the texture
+   * @returns the clone of the texture.
+   */
+  clone() {
+    const t = this.getScene();
+    if (!t)
+      return this;
+    const e = this.getSize(), i = new l(this.name, e, t, this._generateMipMaps);
+    return i.hasAlpha = this.hasAlpha, i.level = this.level, i.wrapU = this.wrapU, i.wrapV = this.wrapV, i;
+  }
+  /**
+   * Serializes the dynamic texture.  The scene should be ready before the dynamic texture is serialized
+   * @returns a serialized dynamic texture object
+   */
+  serialize() {
+    const t = this.getScene();
+    t && !t.isReady() && _.Warn("The scene must be ready before serializing the dynamic texture");
+    const e = super.serialize();
+    return l._IsCanvasElement(this._canvas) && (e.base64String = this._canvas.toDataURL()), e.invertY = this._invertY, e.samplingMode = this.samplingMode, e;
+  }
+  static _IsCanvasElement(t) {
+    return t.toDataURL !== void 0;
+  }
+  /** @internal */
+  _rebuild() {
+    this.update();
+  }
+}
+export {
+  l as DynamicTexture
+};

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

@@ -0,0 +1,89 @@
+import { PanoramaToCubeMapTools as l } from "../../Misc/HighDynamicRange/panoramaToCubemap.esm.js";
+import { BaseTexture as d } from "./baseTexture.esm.js";
+import { Texture as u } from "./texture.esm.js";
+import { Tools as c } from "../../Misc/tools.esm.js";
+import "../../Engines/Extensions/engine.rawTexture.esm.js";
+import { LoadImage as m } from "../../Misc/fileTools.esm.js";
+class o extends d {
+  /**
+   * Instantiates an EquiRectangularCubeTexture from the following parameters.
+   * @param url The location of the image
+   * @param scene The scene the texture will be used in
+   * @param size The cubemap desired size (the more it increases the longer the generation will be)
+   * @param noMipmap Forces to not generate the mipmap if true
+   * @param gammaSpace Specifies if the texture will be used in gamma or linear space
+   * (the PBR material requires those textures in linear space, but the standard material would require them in Gamma space)
+   * @param onLoad — defines a callback called when texture is loaded
+   * @param onError — defines a callback called if there is an error
+   */
+  constructor(t, e, a, i = !1, s = !0, r = null, h = null, n = !1) {
+    if (super(e), this._onLoad = null, this._onError = null, !t)
+      throw new Error("Image url is not set");
+    this._coordinatesMode = u.CUBIC_MODE, this.name = t, this.url = t, this._size = a, this._supersample = n, this._noMipmap = i, this.gammaSpace = s, this._onLoad = r, this._onError = h, this.hasAlpha = !1, this.isCube = !0, this._texture = this._getFromCache(t, this._noMipmap, void 0, void 0, void 0, this.isCube), this._texture ? r && (this._texture.isReady ? c.SetImmediate(() => r()) : this._texture.onLoadedObservable.add(r)) : e.useDelayedTextureLoading ? this.delayLoadState = 4 : this._loadImage(this._loadTexture.bind(this), this._onError);
+  }
+  /**
+   * Load the image data, by putting the image on a canvas and extracting its buffer.
+   * @param loadTextureCallback
+   * @param onError
+   */
+  _loadImage(t, e) {
+    const a = document.createElement("canvas");
+    m(this.url, (i) => {
+      this._width = i.width, this._height = i.height, a.width = this._width, a.height = this._height;
+      const s = a.getContext("2d");
+      s.drawImage(i, 0, 0);
+      const r = s.getImageData(0, 0, i.width, i.height);
+      this._buffer = r.data.buffer, a.remove(), t();
+    }, (i, s) => {
+      e && e(`${this.getClassName()} could not be loaded`, s);
+    }, null);
+  }
+  /**
+   * Convert the image buffer into a cubemap and create a CubeTexture.
+   */
+  _loadTexture() {
+    const t = this.getScene(), e = () => {
+      const a = this._getFloat32ArrayFromArrayBuffer(this._buffer), i = l.ConvertPanoramaToCubemap(a, this._width, this._height, this._size, this._supersample), s = [];
+      for (let r = 0; r < 6; r++) {
+        const h = i[o._FacesMapping[r]];
+        s.push(h);
+      }
+      return s;
+    };
+    t && (this._texture = t.getEngine().createRawCubeTextureFromUrl(this.url, t, this._size, 4, t.getEngine().getCaps().textureFloat ? 1 : 7, this._noMipmap, e, null, this._onLoad, this._onError));
+  }
+  /**
+   * Convert the ArrayBuffer into a Float32Array and drop the transparency channel.
+   * @param buffer The ArrayBuffer that should be converted.
+   * @returns The buffer as Float32Array.
+   */
+  _getFloat32ArrayFromArrayBuffer(t) {
+    const e = new DataView(t), a = new Float32Array(t.byteLength * 3 / 4);
+    let i = 0;
+    for (let s = 0; s < t.byteLength; s++)
+      (s + 1) % 4 !== 0 && (a[i++] = e.getUint8(s) / 255);
+    return a;
+  }
+  /**
+   * Get the current class name of the texture useful for serialization or dynamic coding.
+   * @returns "EquiRectangularCubeTexture"
+   */
+  getClassName() {
+    return "EquiRectangularCubeTexture";
+  }
+  /**
+   * Create a clone of the current EquiRectangularCubeTexture and return it.
+   * @returns A clone of the current EquiRectangularCubeTexture.
+   */
+  clone() {
+    const t = this.getScene();
+    if (!t)
+      return this;
+    const e = new o(this.url, t, this._size, this._noMipmap, this.gammaSpace);
+    return e.level = this.level, e.wrapU = this.wrapU, e.wrapV = this.wrapV, e.coordinatesIndex = this.coordinatesIndex, e.coordinatesMode = this.coordinatesMode, e;
+  }
+}
+o._FacesMapping = ["right", "left", "up", "down", "front", "back"];
+export {
+  o as EquiRectangularCubeTexture
+};

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

@@ -0,0 +1,175 @@
+import { Matrix as S, Vector3 as p } from "../../Maths/math.vector.esm.js";
+import { BaseTexture as B } from "./baseTexture.esm.js";
+import { Texture as y } from "./texture.esm.js";
+import { HDRTools as z } from "../../Misc/HighDynamicRange/hdr.esm.js";
+import { CubeMapToSphericalPolynomialTools as L } from "../../Misc/HighDynamicRange/cubemapToSphericalPolynomial.esm.js";
+import { RegisterClass as F } from "../../Misc/typeStore.esm.js";
+import { Observable as v } from "../../Misc/observable.esm.js";
+import { Tools as A } from "../../Misc/tools.esm.js";
+import { ToGammaSpace as x } from "../../Maths/math.constants.esm.js";
+import { HDRFiltering as w } from "./Filtering/hdrFiltering.esm.js";
+import { ToHalfFloat as M } from "../../Misc/textureTools.esm.js";
+import "../../Engines/Extensions/engine.rawTexture.esm.js";
+import "./baseTexture.polynomial.esm.js";
+class u extends B {
+  /**
+   * Sets whether or not the texture is blocking during loading.
+   */
+  set isBlocking(t) {
+    this._isBlocking = t;
+  }
+  /**
+   * Gets whether or not the texture is blocking during loading.
+   */
+  get isBlocking() {
+    return this._isBlocking;
+  }
+  /**
+   * Sets texture matrix rotation angle around Y axis in radians.
+   */
+  set rotationY(t) {
+    this._rotationY = t, this.setReflectionTextureMatrix(S.RotationY(this._rotationY));
+  }
+  /**
+   * Gets texture matrix rotation angle around Y axis radians.
+   */
+  get rotationY() {
+    return this._rotationY;
+  }
+  /**
+   * Gets or sets the size of the bounding box associated with the cube texture
+   * When defined, the cubemap will switch to local mode
+   * @see https://community.arm.com/graphics/b/blog/posts/reflections-based-on-local-cubemaps-in-unity
+   * @example https://www.babylonjs-playground.com/#RNASML
+   */
+  set boundingBoxSize(t) {
+    if (this._boundingBoxSize && this._boundingBoxSize.equals(t))
+      return;
+    this._boundingBoxSize = t;
+    const o = this.getScene();
+    o && o.markAllMaterialsAsDirty(1);
+  }
+  get boundingBoxSize() {
+    return this._boundingBoxSize;
+  }
+  /**
+   * Instantiates an HDRTexture from the following parameters.
+   *
+   * @param url The location of the HDR raw data (Panorama stored in RGBE format)
+   * @param sceneOrEngine The scene or engine the texture will be used in
+   * @param size The cubemap desired size (the more it increases the longer the generation will be)
+   * @param noMipmap Forces to not generate the mipmap if true
+   * @param generateHarmonics Specifies whether you want to extract the polynomial harmonics during the generation process
+   * @param gammaSpace Specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space)
+   * @param prefilterOnLoad Prefilters HDR texture to allow use of this texture as a PBR reflection texture.
+   * @param onLoad
+   * @param onError
+   */
+  constructor(t, o, a, s = !1, c = !0, h = !1, m = !1, n = null, r = null, l = !1) {
+    var e;
+    super(o), this._generateHarmonics = !0, this._onError = null, this._isBlocking = !0, this._rotationY = 0, this.boundingBoxPosition = p.Zero(), this.onLoadObservable = new v(), t && (this._coordinatesMode = y.CUBIC_MODE, this.name = t, this.url = t, this.hasAlpha = !1, this.isCube = !0, this._textureMatrix = S.Identity(), this._prefilterOnLoad = m, this._onLoad = () => {
+      this.onLoadObservable.notifyObservers(this), n && n();
+    }, this._onError = r, this.gammaSpace = h, this._noMipmap = s, this._size = a, this._supersample = l, this._generateHarmonics = c, this._texture = this._getFromCache(t, this._noMipmap, void 0, void 0, void 0, this.isCube), this._texture ? this._texture.isReady ? A.SetImmediate(() => this._onLoad()) : this._texture.onLoadedObservable.add(this._onLoad) : !((e = this.getScene()) === null || e === void 0) && e.useDelayedTextureLoading ? this.delayLoadState = 4 : this._loadTexture());
+  }
+  /**
+   * Get the current class name of the texture useful for serialization or dynamic coding.
+   * @returns "HDRCubeTexture"
+   */
+  getClassName() {
+    return "HDRCubeTexture";
+  }
+  /**
+   * Occurs when the file is raw .hdr file.
+   */
+  _loadTexture() {
+    const t = this._getEngine(), o = t.getCaps();
+    let a = 0;
+    o.textureFloat && o.textureFloatLinearFiltering ? a = 1 : o.textureHalfFloat && o.textureHalfFloatLinearFiltering && (a = 2);
+    const s = (c) => {
+      this.lodGenerationOffset = 0, this.lodGenerationScale = 0.8;
+      const h = z.GetCubeMapTextureData(c, this._size, this._supersample);
+      if (this._generateHarmonics) {
+        const l = L.ConvertCubeMapToSphericalPolynomial(h);
+        this.sphericalPolynomial = l;
+      }
+      const m = [];
+      let n = null, r = null;
+      for (let l = 0; l < 6; l++) {
+        a === 2 ? r = new Uint16Array(this._size * this._size * 3) : a === 0 && (n = new Uint8Array(this._size * this._size * 3));
+        const e = h[u._FacesMapping[l]];
+        if (this.gammaSpace || r || n) {
+          for (let i = 0; i < this._size * this._size; i++)
+            if (this.gammaSpace && (e[i * 3 + 0] = Math.pow(e[i * 3 + 0], x), e[i * 3 + 1] = Math.pow(e[i * 3 + 1], x), e[i * 3 + 2] = Math.pow(e[i * 3 + 2], x)), r && (r[i * 3 + 0] = M(e[i * 3 + 0]), r[i * 3 + 1] = M(e[i * 3 + 1]), r[i * 3 + 2] = M(e[i * 3 + 2])), n) {
+              let _ = Math.max(e[i * 3 + 0] * 255, 0), d = Math.max(e[i * 3 + 1] * 255, 0), f = Math.max(e[i * 3 + 2] * 255, 0);
+              const b = Math.max(Math.max(_, d), f);
+              if (b > 255) {
+                const g = 255 / b;
+                _ *= g, d *= g, f *= g;
+              }
+              n[i * 3 + 0] = _, n[i * 3 + 1] = d, n[i * 3 + 2] = f;
+            }
+        }
+        r ? m.push(r) : n ? m.push(n) : m.push(e);
+      }
+      return m;
+    };
+    if (t._features.allowTexturePrefiltering && this._prefilterOnLoad) {
+      const c = this._onLoad, h = new w(t);
+      this._onLoad = () => {
+        h.prefilter(this, c);
+      };
+    }
+    this._texture = t.createRawCubeTextureFromUrl(this.url, this.getScene(), this._size, 4, a, this._noMipmap, s, null, this._onLoad, this._onError);
+  }
+  clone() {
+    const t = new u(this.url, this.getScene() || this._getEngine(), this._size, this._noMipmap, this._generateHarmonics, this.gammaSpace);
+    return t.level = this.level, t.wrapU = this.wrapU, t.wrapV = this.wrapV, t.coordinatesIndex = this.coordinatesIndex, t.coordinatesMode = this.coordinatesMode, t;
+  }
+  // Methods
+  delayLoad() {
+    this.delayLoadState === 4 && (this.delayLoadState = 1, this._texture = this._getFromCache(this.url, this._noMipmap), this._texture || this._loadTexture());
+  }
+  /**
+   * Get the texture reflection matrix used to rotate/transform the reflection.
+   * @returns the reflection matrix
+   */
+  getReflectionTextureMatrix() {
+    return this._textureMatrix;
+  }
+  /**
+   * Set the texture reflection matrix used to rotate/transform the reflection.
+   * @param value Define the reflection matrix to set
+   */
+  setReflectionTextureMatrix(t) {
+    var o;
+    this._textureMatrix = t, t.updateFlag !== this._textureMatrix.updateFlag && t.isIdentity() !== this._textureMatrix.isIdentity() && ((o = this.getScene()) === null || o === void 0 || o.markAllMaterialsAsDirty(1, (a) => a.getActiveTextures().indexOf(this) !== -1));
+  }
+  /**
+   * Dispose the texture and release its associated resources.
+   */
+  dispose() {
+    this.onLoadObservable.clear(), super.dispose();
+  }
+  /**
+   * Parses a JSON representation of an HDR Texture in order to create the texture
+   * @param parsedTexture Define the JSON representation
+   * @param scene Define the scene the texture should be created in
+   * @param rootUrl Define the root url in case we need to load relative dependencies
+   * @returns the newly created texture after parsing
+   */
+  static Parse(t, o, a) {
+    let s = null;
+    return t.name && !t.isRenderTarget && (s = new u(a + t.name, o, t.size, t.noMipmap, t.generateHarmonics, t.useInGammaSpace), s.name = t.name, s.hasAlpha = t.hasAlpha, s.level = t.level, s.coordinatesMode = t.coordinatesMode, s.isBlocking = t.isBlocking), s && (t.boundingBoxPosition && (s.boundingBoxPosition = p.FromArray(t.boundingBoxPosition)), t.boundingBoxSize && (s.boundingBoxSize = p.FromArray(t.boundingBoxSize)), t.rotationY && (s.rotationY = t.rotationY)), s;
+  }
+  serialize() {
+    if (!this.name)
+      return null;
+    const t = {};
+    return t.name = this.name, t.hasAlpha = this.hasAlpha, t.isCube = !0, t.level = this.level, t.size = this._size, t.coordinatesMode = this.coordinatesMode, t.useInGammaSpace = this.gammaSpace, t.generateHarmonics = this._generateHarmonics, t.customType = "BABYLON.HDRCubeTexture", t.noMipmap = this._noMipmap, t.isBlocking = this._isBlocking, t.rotationY = this._rotationY, t;
+  }
+}
+u._FacesMapping = ["right", "left", "up", "down", "front", "back"];
+F("BABYLON.HDRCubeTexture", u);
+export {
+  u as HDRCubeTexture
+};