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

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

@@ -0,0 +1,542 @@
+import { __decorate as i } from "../../tslib.es6.esm.js";
+import { SerializationHelper as f, serialize as s, serializeAsTexture as m } from "../../Misc/decorators.esm.js";
+import { Observable as y } from "../../Misc/observable.esm.js";
+import { Matrix as g } from "../../Maths/math.vector.esm.js";
+import { EngineStore as A } from "../../Engines/engineStore.esm.js";
+import { RandomGUID as S } from "../../Misc/guid.esm.js";
+import "../../Misc/fileTools.esm.js";
+import { ThinTexture as T } from "./thinTexture.esm.js";
+class r extends T {
+  /**
+   * Define if the texture is having a usable alpha value (can be use for transparency or glossiness for instance).
+   */
+  set hasAlpha(e) {
+    this._hasAlpha !== e && (this._hasAlpha = e, this._scene && this._scene.markAllMaterialsAsDirty(1, (t) => t.hasTexture(this)));
+  }
+  get hasAlpha() {
+    return this._hasAlpha;
+  }
+  /**
+   * Defines if the alpha value should be determined via the rgb values.
+   * If true the luminance of the pixel might be used to find the corresponding alpha value.
+   */
+  set getAlphaFromRGB(e) {
+    this._getAlphaFromRGB !== e && (this._getAlphaFromRGB = e, this._scene && this._scene.markAllMaterialsAsDirty(1, (t) => t.hasTexture(this)));
+  }
+  get getAlphaFromRGB() {
+    return this._getAlphaFromRGB;
+  }
+  /**
+   * Define the UV channel to use starting from 0 and defaulting to 0.
+   * This is part of the texture as textures usually maps to one uv set.
+   */
+  set coordinatesIndex(e) {
+    this._coordinatesIndex !== e && (this._coordinatesIndex = e, this._scene && this._scene.markAllMaterialsAsDirty(1, (t) => t.hasTexture(this)));
+  }
+  get coordinatesIndex() {
+    return this._coordinatesIndex;
+  }
+  /**
+   * How a texture is mapped.
+   *
+   * | Value | Type                                | Description |
+   * | ----- | ----------------------------------- | ----------- |
+   * | 0     | EXPLICIT_MODE                       |             |
+   * | 1     | SPHERICAL_MODE                      |             |
+   * | 2     | PLANAR_MODE                         |             |
+   * | 3     | CUBIC_MODE                          |             |
+   * | 4     | PROJECTION_MODE                     |             |
+   * | 5     | SKYBOX_MODE                         |             |
+   * | 6     | INVCUBIC_MODE                       |             |
+   * | 7     | EQUIRECTANGULAR_MODE                |             |
+   * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
+   * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+   */
+  set coordinatesMode(e) {
+    this._coordinatesMode !== e && (this._coordinatesMode = e, this._scene && this._scene.markAllMaterialsAsDirty(1, (t) => t.hasTexture(this)));
+  }
+  get coordinatesMode() {
+    return this._coordinatesMode;
+  }
+  /**
+   * | Value | Type               | Description |
+   * | ----- | ------------------ | ----------- |
+   * | 0     | CLAMP_ADDRESSMODE  |             |
+   * | 1     | WRAP_ADDRESSMODE   |             |
+   * | 2     | MIRROR_ADDRESSMODE |             |
+   */
+  get wrapU() {
+    return this._wrapU;
+  }
+  set wrapU(e) {
+    this._wrapU = e;
+  }
+  /**
+   * | Value | Type               | Description |
+   * | ----- | ------------------ | ----------- |
+   * | 0     | CLAMP_ADDRESSMODE  |             |
+   * | 1     | WRAP_ADDRESSMODE   |             |
+   * | 2     | MIRROR_ADDRESSMODE |             |
+   */
+  get wrapV() {
+    return this._wrapV;
+  }
+  set wrapV(e) {
+    this._wrapV = e;
+  }
+  /**
+   * Define if the texture is a cube texture or if false a 2d texture.
+   */
+  get isCube() {
+    return this._texture ? this._texture.isCube : this._isCube;
+  }
+  set isCube(e) {
+    this._texture ? this._texture.isCube = e : this._isCube = e;
+  }
+  /**
+   * Define if the texture is a 3d texture (webgl 2) or if false a 2d texture.
+   */
+  get is3D() {
+    return this._texture ? this._texture.is3D : !1;
+  }
+  set is3D(e) {
+    this._texture && (this._texture.is3D = e);
+  }
+  /**
+   * Define if the texture is a 2d array texture (webgl 2) or if false a 2d texture.
+   */
+  get is2DArray() {
+    return this._texture ? this._texture.is2DArray : !1;
+  }
+  set is2DArray(e) {
+    this._texture && (this._texture.is2DArray = e);
+  }
+  /**
+   * Define if the texture contains data in gamma space (most of the png/jpg aside bump).
+   * HDR texture are usually stored in linear space.
+   * This only impacts the PBR and Background materials
+   */
+  get gammaSpace() {
+    if (this._texture)
+      this._texture._gammaSpace === null && (this._texture._gammaSpace = this._gammaSpace);
+    else
+      return this._gammaSpace;
+    return this._texture._gammaSpace && !this._texture._useSRGBBuffer;
+  }
+  set gammaSpace(e) {
+    if (this._texture) {
+      if (this._texture._gammaSpace === e)
+        return;
+      this._texture._gammaSpace = e;
+    } else {
+      if (this._gammaSpace === e)
+        return;
+      this._gammaSpace = e;
+    }
+    this._markAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * Gets or sets whether or not the texture contains RGBD data.
+   */
+  get isRGBD() {
+    return this._texture != null && this._texture._isRGBD;
+  }
+  set isRGBD(e) {
+    this._texture && (this._texture._isRGBD = e);
+  }
+  /**
+   * Are mip maps generated for this texture or not.
+   */
+  get noMipmap() {
+    return !1;
+  }
+  /**
+   * With prefiltered texture, defined the offset used during the prefiltering steps.
+   */
+  get lodGenerationOffset() {
+    return this._texture ? this._texture._lodGenerationOffset : 0;
+  }
+  set lodGenerationOffset(e) {
+    this._texture && (this._texture._lodGenerationOffset = e);
+  }
+  /**
+   * With prefiltered texture, defined the scale used during the prefiltering steps.
+   */
+  get lodGenerationScale() {
+    return this._texture ? this._texture._lodGenerationScale : 0;
+  }
+  set lodGenerationScale(e) {
+    this._texture && (this._texture._lodGenerationScale = e);
+  }
+  /**
+   * With prefiltered texture, defined if the specular generation is based on a linear ramp.
+   * By default we are using a log2 of the linear roughness helping to keep a better resolution for
+   * average roughness values.
+   */
+  get linearSpecularLOD() {
+    return this._texture ? this._texture._linearSpecularLOD : !1;
+  }
+  set linearSpecularLOD(e) {
+    this._texture && (this._texture._linearSpecularLOD = e);
+  }
+  /**
+   * In case a better definition than spherical harmonics is required for the diffuse part of the environment.
+   * You can set the irradiance texture to rely on a texture instead of the spherical approach.
+   * This texture need to have the same characteristics than its parent (Cube vs 2d, coordinates mode, Gamma/Linear, RGBD).
+   */
+  get irradianceTexture() {
+    return this._texture ? this._texture._irradianceTexture : null;
+  }
+  set irradianceTexture(e) {
+    this._texture && (this._texture._irradianceTexture = e);
+  }
+  /**
+   * Define the unique id of the texture in the scene.
+   */
+  get uid() {
+    return this._uid || (this._uid = S()), this._uid;
+  }
+  /**
+   * Return a string representation of the texture.
+   * @returns the texture as a string
+   */
+  toString() {
+    return this.name;
+  }
+  /**
+   * Get the class name of the texture.
+   * @returns "BaseTexture"
+   */
+  getClassName() {
+    return "BaseTexture";
+  }
+  /**
+   * Callback triggered when the texture has been disposed.
+   * Kept for back compatibility, you can use the onDisposeObservable instead.
+   */
+  set onDispose(e) {
+    this._onDisposeObserver && this.onDisposeObservable.remove(this._onDisposeObserver), this._onDisposeObserver = this.onDisposeObservable.add(e);
+  }
+  /**
+   * Define if the texture is preventing a material to render or not.
+   * If not and the texture is not ready, the engine will use a default black texture instead.
+   */
+  get isBlocking() {
+    return !0;
+  }
+  /**
+   * Was there any loading error?
+   */
+  get loadingError() {
+    return this._loadingError;
+  }
+  /**
+   * If a loading error occurred this object will be populated with information about the error.
+   */
+  get errorObject() {
+    return this._errorObject;
+  }
+  /**
+   * Instantiates a new BaseTexture.
+   * Base class of all the textures in babylon.
+   * It groups all the common properties the materials, post process, lights... might need
+   * in order to make a correct use of the texture.
+   * @param sceneOrEngine Define the scene or engine the texture belongs to
+   * @param internalTexture Define the internal texture associated with the texture
+   */
+  constructor(e, t = null) {
+    super(null), this.metadata = null, this.reservedDataStore = null, this._hasAlpha = !1, this._getAlphaFromRGB = !1, this.level = 1, this._coordinatesIndex = 0, this.optimizeUVAllocation = !0, this._coordinatesMode = 0, this.wrapR = 1, this.anisotropicFilteringLevel = r.DEFAULT_ANISOTROPIC_FILTERING_LEVEL, this._isCube = !1, this._gammaSpace = !0, this.invertZ = !1, this.lodLevelInAlpha = !1, this.isRenderTarget = !1, this._prefiltered = !1, this._forceSerialize = !1, this.animations = new Array(), this.onDisposeObservable = new y(), this._onDisposeObserver = null, this._scene = null, this._uid = null, this._parentContainer = null, this._loadingError = !1, e ? r._IsScene(e) ? this._scene = e : this._engine = e : this._scene = A.LastCreatedScene, this._scene && (this.uniqueId = this._scene.getUniqueId(), this._scene.addTexture(this), this._engine = this._scene.getEngine()), this._texture = t, this._uid = null;
+  }
+  /**
+   * Get the scene the texture belongs to.
+   * @returns the scene or null if undefined
+   */
+  getScene() {
+    return this._scene;
+  }
+  /** @internal */
+  _getEngine() {
+    return this._engine;
+  }
+  /**
+   * Checks if the texture has the same transform matrix than another texture
+   * @param texture texture to check against
+   * @returns true if the transforms are the same, else false
+   */
+  checkTransformsAreIdentical(e) {
+    return e !== null;
+  }
+  /**
+   * Get the texture transform matrix used to offset tile the texture for instance.
+   * @returns the transformation matrix
+   */
+  getTextureMatrix() {
+    return g.IdentityReadOnly;
+  }
+  /**
+   * Get the texture reflection matrix used to rotate/transform the reflection.
+   * @returns the reflection matrix
+   */
+  getReflectionTextureMatrix() {
+    return g.IdentityReadOnly;
+  }
+  /**
+   * 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() {
+    return this.getReflectionTextureMatrix();
+  }
+  /**
+   * Get if the texture is ready to be consumed (either it is ready or it is not blocking)
+   * @returns true if ready, not blocking or if there was an error loading the texture
+   */
+  isReadyOrNotBlocking() {
+    return !this.isBlocking || this.isReady() || this.loadingError;
+  }
+  /**
+   * Scales the texture if is `canRescale()`
+   * @param ratio the resize factor we want to use to rescale
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  scale(e) {
+  }
+  /**
+   * Get if the texture can rescale.
+   */
+  get canRescale() {
+    return !1;
+  }
+  /**
+   * @internal
+   */
+  _getFromCache(e, t, n, u, h, l) {
+    const a = this._getEngine();
+    if (!a)
+      return null;
+    const o = a._getUseSRGBBuffer(!!h, t), _ = a.getLoadedTexturesCache();
+    for (let p = 0; p < _.length; p++) {
+      const d = _[p];
+      if ((h === void 0 || o === d._useSRGBBuffer) && (u === void 0 || u === d.invertY) && d.url === e && d.generateMipMaps === !t && (!n || n === d.samplingMode) && (l === void 0 || l === d.isCube))
+        return d.incrementReferences(), d;
+    }
+    return null;
+  }
+  /** @internal */
+  _rebuild() {
+  }
+  /**
+   * Clones the texture.
+   * @returns the cloned texture
+   */
+  clone() {
+    return null;
+  }
+  /**
+   * Get the texture underlying type (INT, FLOAT...)
+   */
+  get textureType() {
+    return this._texture && this._texture.type !== void 0 ? this._texture.type : 0;
+  }
+  /**
+   * Get the texture underlying format (RGB, RGBA...)
+   */
+  get textureFormat() {
+    return this._texture && this._texture.format !== void 0 ? this._texture.format : 5;
+  }
+  /**
+   * Indicates that textures need to be re-calculated for all materials
+   */
+  _markAllSubMeshesAsTexturesDirty() {
+    const e = this.getScene();
+    e && e.markAllMaterialsAsDirty(1);
+  }
+  /**
+   * Reads the pixels stored in the webgl texture and returns them as an ArrayBuffer.
+   * This will returns an RGBA array buffer containing either in values (0-255) or
+   * float values (0-1) depending of the underlying buffer type.
+   * @param faceIndex defines the face of the texture to read (in case of cube texture)
+   * @param level defines the LOD level of the texture to read (in case of Mip Maps)
+   * @param buffer defines a user defined buffer to fill with data (can be null)
+   * @param flushRenderer true to flush the renderer from the pending commands before reading the pixels
+   * @param noDataConversion false to convert the data to Uint8Array (if texture type is UNSIGNED_BYTE) or to Float32Array (if texture type is anything but UNSIGNED_BYTE). If true, the type of the generated buffer (if buffer==null) will depend on the type of the texture
+   * @param x defines the region x coordinates to start reading from (default to 0)
+   * @param y defines the region y coordinates to start reading from (default to 0)
+   * @param width defines the region width to read from (default to the texture size at level)
+   * @param height defines the region width to read from (default to the texture size at level)
+   * @returns The Array buffer promise containing the pixels data.
+   */
+  readPixels(e = 0, t = 0, n = null, u = !0, h = !1, l = 0, a = 0, o = Number.MAX_VALUE, _ = Number.MAX_VALUE) {
+    if (!this._texture)
+      return null;
+    const p = this._getEngine();
+    if (!p)
+      return null;
+    const d = this.getSize();
+    let c = d.width, x = d.height;
+    t !== 0 && (c = c / Math.pow(2, t), x = x / Math.pow(2, t), c = Math.round(c), x = Math.round(x)), o = Math.min(c, o), _ = Math.min(x, _);
+    try {
+      return this._texture.isCube ? p._readTexturePixels(this._texture, o, _, e, t, n, u, h, l, a) : p._readTexturePixels(this._texture, o, _, -1, t, n, u, h, l, a);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * @internal
+   */
+  _readPixelsSync(e = 0, t = 0, n = null, u = !0, h = !1) {
+    if (!this._texture)
+      return null;
+    const l = this.getSize();
+    let a = l.width, o = l.height;
+    const _ = this._getEngine();
+    if (!_)
+      return null;
+    t != 0 && (a = a / Math.pow(2, t), o = o / Math.pow(2, t), a = Math.round(a), o = Math.round(o));
+    try {
+      return this._texture.isCube ? _._readTexturePixelsSync(this._texture, a, o, e, t, n, u, h) : _._readTexturePixelsSync(this._texture, a, o, -1, t, n, u, h);
+    } catch {
+      return null;
+    }
+  }
+  /** @internal */
+  get _lodTextureHigh() {
+    return this._texture ? this._texture._lodTextureHigh : null;
+  }
+  /** @internal */
+  get _lodTextureMid() {
+    return this._texture ? this._texture._lodTextureMid : null;
+  }
+  /** @internal */
+  get _lodTextureLow() {
+    return this._texture ? this._texture._lodTextureLow : null;
+  }
+  /**
+   * Dispose the texture and release its associated resources.
+   */
+  dispose() {
+    if (this._scene) {
+      this._scene.stopAnimation && this._scene.stopAnimation(this), this._scene.removePendingData(this);
+      const e = this._scene.textures.indexOf(this);
+      if (e >= 0 && this._scene.textures.splice(e, 1), this._scene.onTextureRemovedObservable.notifyObservers(this), this._scene = null, this._parentContainer) {
+        const t = this._parentContainer.textures.indexOf(this);
+        t > -1 && this._parentContainer.textures.splice(t, 1), this._parentContainer = null;
+      }
+    }
+    this.onDisposeObservable.notifyObservers(this), this.onDisposeObservable.clear(), this.metadata = null, super.dispose();
+  }
+  /**
+   * Serialize the texture into a JSON representation that can be parsed later on.
+   * @param allowEmptyName True to force serialization even if name is empty. Default: false
+   * @returns the JSON representation of the texture
+   */
+  serialize(e = !1) {
+    if (!this.name && !e)
+      return null;
+    const t = f.Serialize(this);
+    return f.AppendSerializedAnimations(this, t), t;
+  }
+  /**
+   * Helper function to be called back once a list of texture contains only ready textures.
+   * @param textures Define the list of textures to wait for
+   * @param callback Define the callback triggered once the entire list will be ready
+   */
+  static WhenAllReady(e, t) {
+    let n = e.length;
+    if (n === 0) {
+      t();
+      return;
+    }
+    for (let u = 0; u < e.length; u++) {
+      const h = e[u];
+      if (h.isReady())
+        --n === 0 && t();
+      else {
+        const l = h.onLoadObservable;
+        l ? l.addOnce(() => {
+          --n === 0 && t();
+        }) : --n === 0 && t();
+      }
+    }
+  }
+  static _IsScene(e) {
+    return e.getClassName() === "Scene";
+  }
+}
+r.DEFAULT_ANISOTROPIC_FILTERING_LEVEL = 4;
+i([
+  s()
+], r.prototype, "uniqueId", void 0);
+i([
+  s()
+], r.prototype, "name", void 0);
+i([
+  s()
+], r.prototype, "metadata", void 0);
+i([
+  s("hasAlpha")
+], r.prototype, "_hasAlpha", void 0);
+i([
+  s("getAlphaFromRGB")
+], r.prototype, "_getAlphaFromRGB", void 0);
+i([
+  s()
+], r.prototype, "level", void 0);
+i([
+  s("coordinatesIndex")
+], r.prototype, "_coordinatesIndex", void 0);
+i([
+  s()
+], r.prototype, "optimizeUVAllocation", void 0);
+i([
+  s("coordinatesMode")
+], r.prototype, "_coordinatesMode", void 0);
+i([
+  s()
+], r.prototype, "wrapU", null);
+i([
+  s()
+], r.prototype, "wrapV", null);
+i([
+  s()
+], r.prototype, "wrapR", void 0);
+i([
+  s()
+], r.prototype, "anisotropicFilteringLevel", void 0);
+i([
+  s()
+], r.prototype, "isCube", null);
+i([
+  s()
+], r.prototype, "is3D", null);
+i([
+  s()
+], r.prototype, "is2DArray", null);
+i([
+  s()
+], r.prototype, "gammaSpace", null);
+i([
+  s()
+], r.prototype, "invertZ", void 0);
+i([
+  s()
+], r.prototype, "lodLevelInAlpha", void 0);
+i([
+  s()
+], r.prototype, "lodGenerationOffset", null);
+i([
+  s()
+], r.prototype, "lodGenerationScale", null);
+i([
+  s()
+], r.prototype, "linearSpecularLOD", null);
+i([
+  m()
+], r.prototype, "irradianceTexture", null);
+i([
+  s()
+], r.prototype, "isRenderTarget", void 0);
+export {
+  r as BaseTexture
+};

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

@@ -0,0 +1,23 @@
+import { CubeMapToSphericalPolynomialTools as i } from "../../Misc/HighDynamicRange/cubemapToSphericalPolynomial.esm.js";
+import { BaseTexture as t } from "./baseTexture.esm.js";
+t.prototype.forceSphericalPolynomialsRecompute = function() {
+  this._texture && (this._texture._sphericalPolynomial = null, this._texture._sphericalPolynomialPromise = null, this._texture._sphericalPolynomialComputed = !1);
+};
+Object.defineProperty(t.prototype, "sphericalPolynomial", {
+  get: function() {
+    if (this._texture) {
+      if (this._texture._sphericalPolynomial || this._texture._sphericalPolynomialComputed)
+        return this._texture._sphericalPolynomial;
+      if (this._texture.isReady)
+        return this._texture._sphericalPolynomialPromise || (this._texture._sphericalPolynomialPromise = i.ConvertCubeMapTextureToSphericalPolynomial(this), this._texture._sphericalPolynomialPromise === null ? this._texture._sphericalPolynomialComputed = !0 : this._texture._sphericalPolynomialPromise.then((e) => {
+          this._texture._sphericalPolynomial = e, this._texture._sphericalPolynomialComputed = !0;
+        })), null;
+    }
+    return null;
+  },
+  set: function(e) {
+    this._texture && (this._texture._sphericalPolynomial = e);
+  },
+  enumerable: !0,
+  configurable: !0
+});