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

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

@@ -1,421 +0,0 @@
-import { __decorate as _ } from "../../tslib.es6.esm.js";
-import { SerializationHelper as F, serialize as d } from "../../Misc/decorators.esm.js";
-import { Observable as j } from "../../Misc/observable.esm.js";
-import { Vector3 as b, Matrix as f, TmpVectors as M } from "../../Maths/math.vector.esm.js";
-import { BaseTexture as k } from "./baseTexture.esm.js";
-import { GetClass as q, RegisterClass as H } from "../../Misc/typeStore.esm.js";
-import { _WarnImport as G } from "../../Misc/devTools.esm.js";
-import { TimingTools as z } from "../../Misc/timingTools.esm.js";
-import { InstantiationTools as Z } from "../../Misc/instantiationTools.esm.js";
-import { Plane as X } from "../../Maths/math.plane.esm.js";
-import { EncodeArrayBufferToBase64 as J } from "../../Misc/stringTools.esm.js";
-import { GenerateBase64StringFromTexture as Q, GenerateBase64StringFromTextureAsync as K } from "../../Misc/copyTools.esm.js";
-import { CompatibilityOptions as Y } from "../../Compat/compatibilityOptions.esm.js";
-class t extends k {
-  /**
-   * Are mip maps generated for this texture or not.
-   */
-  get noMipmap() {
-    return this._noMipmap;
-  }
-  /** Returns the texture mime type if it was defined by a loader (undefined else) */
-  get mimeType() {
-    return this._mimeType;
-  }
-  /**
-   * Is the texture preventing material to render while loading.
-   * If false, a default texture will be used instead of the loading one during the preparation step.
-   */
-  set isBlocking(e) {
-    this._isBlocking = e;
-  }
-  get isBlocking() {
-    return this._isBlocking;
-  }
-  /**
-   * Gets a boolean indicating if the texture needs to be inverted on the y axis during loading
-   */
-  get invertY() {
-    return this._invertY;
-  }
-  /**
-   * Instantiates a new texture.
-   * This represents a texture in babylon. It can be easily loaded from a network, base64 or html input.
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction#texture
-   * @param url defines the url of the picture to load as a texture
-   * @param sceneOrEngine defines the scene or engine the texture will belong to
-   * @param noMipmapOrOptions defines if the texture will require mip maps or not or set of all options to create the texture
-   * @param invertY defines if the texture needs to be inverted on the y axis during loading
-   * @param samplingMode defines the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)
-   * @param onLoad defines a callback triggered when the texture has been loaded
-   * @param onError defines a callback triggered when an error occurred during the loading session
-   * @param buffer defines the buffer to load the texture from in case the texture is loaded from a buffer representation
-   * @param deleteBuffer defines if the buffer we are loading the texture from should be deleted after load
-   * @param format defines the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)
-   * @param mimeType defines an optional mime type information
-   * @param loaderOptions options to be passed to the loader
-   * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
-   * @param forcedExtension defines the extension to use to pick the right loader
-   */
-  constructor(e, s, i, a, l = t.TRILINEAR_SAMPLINGMODE, u = null, m = null, r = null, n = !1, h, c, o, R, S) {
-    var L, C, p, y, U, N, B, P, V;
-    super(s), this.url = null, this.uOffset = 0, this.vOffset = 0, this.uScale = 1, this.vScale = 1, this.uAng = 0, this.vAng = 0, this.wAng = 0, this.uRotationCenter = 0.5, this.vRotationCenter = 0.5, this.wRotationCenter = 0.5, this.homogeneousRotationInUVTransform = !1, this.inspectableCustomProperties = null, this._noMipmap = !1, this._invertY = !1, this._rowGenerationMatrix = null, this._cachedTextureMatrix = null, this._projectionModeMatrix = null, this._t0 = null, this._t1 = null, this._t2 = null, this._cachedUOffset = -1, this._cachedVOffset = -1, this._cachedUScale = 0, this._cachedVScale = 0, this._cachedUAng = -1, this._cachedVAng = -1, this._cachedWAng = -1, this._cachedReflectionProjectionMatrixId = -1, this._cachedURotationCenter = -1, this._cachedVRotationCenter = -1, this._cachedWRotationCenter = -1, this._cachedHomogeneousRotationInUVTransform = !1, this._cachedReflectionTextureMatrix = null, this._cachedReflectionUOffset = -1, this._cachedReflectionVOffset = -1, this._cachedReflectionUScale = 0, this._cachedReflectionVScale = 0, this._cachedReflectionCoordinatesMode = -1, this._buffer = null, this._deleteBuffer = !1, this._format = null, this._delayedOnLoad = null, this._delayedOnError = null, this.onLoadObservable = new j(), this._isBlocking = !0, this.name = e || "", this.url = e;
-    let E, O = !1, A = null;
-    typeof i == "object" && i !== null ? (E = (L = i.noMipmap) !== null && L !== void 0 ? L : !1, a = (C = i.invertY) !== null && C !== void 0 ? C : !Y.UseOpenGLOrientationForUV, l = (p = i.samplingMode) !== null && p !== void 0 ? p : t.TRILINEAR_SAMPLINGMODE, u = (y = i.onLoad) !== null && y !== void 0 ? y : null, m = (U = i.onError) !== null && U !== void 0 ? U : null, r = (N = i.buffer) !== null && N !== void 0 ? N : null, n = (B = i.deleteBuffer) !== null && B !== void 0 ? B : !1, h = i.format, c = i.mimeType, o = i.loaderOptions, R = i.creationFlags, O = (P = i.useSRGBBuffer) !== null && P !== void 0 ? P : !1, A = (V = i.internalTexture) !== null && V !== void 0 ? V : null) : E = !!i, this._noMipmap = E, this._invertY = a === void 0 ? !Y.UseOpenGLOrientationForUV : a, this._initialSamplingMode = l, this._buffer = r, this._deleteBuffer = n, this._mimeType = c, this._loaderOptions = o, this._creationFlags = R, this._useSRGBBuffer = O, this._forcedExtension = S, h && (this._format = h);
-    const v = this.getScene(), w = this._getEngine();
-    if (!w)
-      return;
-    w.onBeforeTextureInitObservable.notifyObservers(this);
-    const x = () => {
-      this._texture && (this._texture._invertVScale && (this.vScale *= -1, this.vOffset += 1), this._texture._cachedWrapU !== null && (this.wrapU = this._texture._cachedWrapU, this._texture._cachedWrapU = null), this._texture._cachedWrapV !== null && (this.wrapV = this._texture._cachedWrapV, this._texture._cachedWrapV = null), this._texture._cachedWrapR !== null && (this.wrapR = this._texture._cachedWrapR, this._texture._cachedWrapR = null)), this.onLoadObservable.hasObservers() && this.onLoadObservable.notifyObservers(this), u && u(), !this.isBlocking && v && v.resetCachedMaterial();
-    }, I = (g, T) => {
-      this._loadingError = !0, this._errorObject = { message: g, exception: T }, m && m(g, T), t.OnTextureLoadErrorObservable.notifyObservers(this);
-    };
-    if (!this.url && !A) {
-      this._delayedOnLoad = x, this._delayedOnError = I;
-      return;
-    }
-    if (this._texture = A ?? this._getFromCache(this.url, E, l, this._invertY, O), this._texture)
-      if (this._texture.isReady)
-        z.SetImmediate(() => x());
-      else {
-        const g = this._texture.onLoadedObservable.add(x);
-        this._texture.onErrorObservable.add((T) => {
-          var D;
-          I(T.message, T.exception), (D = this._texture) === null || D === void 0 || D.onLoadedObservable.remove(g);
-        });
-      }
-    else if (!v || !v.useDelayedTextureLoading) {
-      try {
-        this._texture = w.createTexture(this.url, E, this._invertY, v, l, x, I, this._buffer, void 0, this._format, this._forcedExtension, c, o, R, O);
-      } catch (g) {
-        throw I("error loading", g), g;
-      }
-      n && (this._buffer = null);
-    } else
-      this.delayLoadState = 4, this._delayedOnLoad = x, this._delayedOnError = I;
-  }
-  /**
-   * Update the url (and optional buffer) of this texture if url was null during construction.
-   * @param url the url of the texture
-   * @param buffer the buffer of the texture (defaults to null)
-   * @param onLoad callback called when the texture is loaded  (defaults to null)
-   * @param forcedExtension defines the extension to use to pick the right loader
-   */
-  updateURL(e, s = null, i, a) {
-    this.url && (this.releaseInternalTexture(), this.getScene().markAllMaterialsAsDirty(1)), (!this.name || this.name.startsWith("data:")) && (this.name = e), this.url = e, this._buffer = s, this._forcedExtension = a, this.delayLoadState = 4, i && (this._delayedOnLoad = i), this.delayLoad();
-  }
-  /**
-   * Finish the loading sequence of a texture flagged as delayed load.
-   * @internal
-   */
-  delayLoad() {
-    if (this.delayLoadState !== 4)
-      return;
-    const e = this.getScene();
-    e && (this.delayLoadState = 1, this._texture = this._getFromCache(this.url, this._noMipmap, this.samplingMode, this._invertY, this._useSRGBBuffer), this._texture ? this._delayedOnLoad && (this._texture.isReady ? z.SetImmediate(this._delayedOnLoad) : this._texture.onLoadedObservable.add(this._delayedOnLoad)) : (this._texture = e.getEngine().createTexture(this.url, this._noMipmap, this._invertY, e, this.samplingMode, this._delayedOnLoad, this._delayedOnError, this._buffer, null, this._format, this._forcedExtension, this._mimeType, this._loaderOptions, this._creationFlags, this._useSRGBBuffer), this._deleteBuffer && (this._buffer = null)), this._delayedOnLoad = null, this._delayedOnError = null);
-  }
-  _prepareRowForTextureGeneration(e, s, i, a) {
-    e *= this._cachedUScale, s *= this._cachedVScale, e -= this.uRotationCenter * this._cachedUScale, s -= this.vRotationCenter * this._cachedVScale, i -= this.wRotationCenter, b.TransformCoordinatesFromFloatsToRef(e, s, i, this._rowGenerationMatrix, a), a.x += this.uRotationCenter * this._cachedUScale + this._cachedUOffset, a.y += this.vRotationCenter * this._cachedVScale + this._cachedVOffset, a.z += this.wRotationCenter;
-  }
-  /**
-   * 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 && this.uOffset === e.uOffset && this.vOffset === e.vOffset && this.uScale === e.uScale && this.vScale === e.vScale && this.uAng === e.uAng && this.vAng === e.vAng && this.wAng === e.wAng;
-  }
-  /**
-   * Get the current texture matrix which includes the requested offsetting, tiling and rotation components.
-   * @param uBase
-   * @returns the transform matrix of the texture.
-   */
-  getTextureMatrix(e = 1) {
-    if (this.uOffset === this._cachedUOffset && this.vOffset === this._cachedVOffset && this.uScale * e === this._cachedUScale && this.vScale === this._cachedVScale && this.uAng === this._cachedUAng && this.vAng === this._cachedVAng && this.wAng === this._cachedWAng && this.uRotationCenter === this._cachedURotationCenter && this.vRotationCenter === this._cachedVRotationCenter && this.wRotationCenter === this._cachedWRotationCenter && this.homogeneousRotationInUVTransform === this._cachedHomogeneousRotationInUVTransform)
-      return this._cachedTextureMatrix;
-    this._cachedUOffset = this.uOffset, this._cachedVOffset = this.vOffset, this._cachedUScale = this.uScale * e, this._cachedVScale = this.vScale, this._cachedUAng = this.uAng, this._cachedVAng = this.vAng, this._cachedWAng = this.wAng, this._cachedURotationCenter = this.uRotationCenter, this._cachedVRotationCenter = this.vRotationCenter, this._cachedWRotationCenter = this.wRotationCenter, this._cachedHomogeneousRotationInUVTransform = this.homogeneousRotationInUVTransform, (!this._cachedTextureMatrix || !this._rowGenerationMatrix) && (this._cachedTextureMatrix = f.Zero(), this._rowGenerationMatrix = new f(), this._t0 = b.Zero(), this._t1 = b.Zero(), this._t2 = b.Zero()), f.RotationYawPitchRollToRef(this.vAng, this.uAng, this.wAng, this._rowGenerationMatrix), this.homogeneousRotationInUVTransform ? (f.TranslationToRef(-this._cachedURotationCenter, -this._cachedVRotationCenter, -this._cachedWRotationCenter, M.Matrix[0]), f.TranslationToRef(this._cachedURotationCenter, this._cachedVRotationCenter, this._cachedWRotationCenter, M.Matrix[1]), f.ScalingToRef(this._cachedUScale, this._cachedVScale, 0, M.Matrix[2]), f.TranslationToRef(this._cachedUOffset, this._cachedVOffset, 0, M.Matrix[3]), M.Matrix[0].multiplyToRef(this._rowGenerationMatrix, this._cachedTextureMatrix), this._cachedTextureMatrix.multiplyToRef(M.Matrix[1], this._cachedTextureMatrix), this._cachedTextureMatrix.multiplyToRef(M.Matrix[2], this._cachedTextureMatrix), this._cachedTextureMatrix.multiplyToRef(M.Matrix[3], this._cachedTextureMatrix), this._cachedTextureMatrix.setRowFromFloats(2, this._cachedTextureMatrix.m[12], this._cachedTextureMatrix.m[13], this._cachedTextureMatrix.m[14], 1)) : (this._prepareRowForTextureGeneration(0, 0, 0, this._t0), this._prepareRowForTextureGeneration(1, 0, 0, this._t1), this._prepareRowForTextureGeneration(0, 1, 0, this._t2), this._t1.subtractInPlace(this._t0), this._t2.subtractInPlace(this._t0), f.FromValuesToRef(this._t1.x, this._t1.y, this._t1.z, 0, this._t2.x, this._t2.y, this._t2.z, 0, this._t0.x, this._t0.y, this._t0.z, 0, 0, 0, 0, 1, this._cachedTextureMatrix));
-    const s = this.getScene();
-    return s ? (this.optimizeUVAllocation && s.markAllMaterialsAsDirty(1, (i) => i.hasTexture(this)), this._cachedTextureMatrix) : this._cachedTextureMatrix;
-  }
-  /**
-   * Get the current matrix used to apply reflection. This is useful to rotate an environment texture for instance.
-   * @returns The reflection texture transform
-   */
-  getReflectionTextureMatrix() {
-    const e = this.getScene();
-    if (!e)
-      return this._cachedReflectionTextureMatrix;
-    if (this.uOffset === this._cachedReflectionUOffset && this.vOffset === this._cachedReflectionVOffset && this.uScale === this._cachedReflectionUScale && this.vScale === this._cachedReflectionVScale && this.coordinatesMode === this._cachedReflectionCoordinatesMode)
-      if (this.coordinatesMode === t.PROJECTION_MODE) {
-        if (this._cachedReflectionProjectionMatrixId === e.getProjectionMatrix().updateFlag)
-          return this._cachedReflectionTextureMatrix;
-      } else
-        return this._cachedReflectionTextureMatrix;
-    this._cachedReflectionTextureMatrix || (this._cachedReflectionTextureMatrix = f.Zero()), this._projectionModeMatrix || (this._projectionModeMatrix = f.Zero());
-    const s = this._cachedReflectionCoordinatesMode !== this.coordinatesMode;
-    switch (this._cachedReflectionUOffset = this.uOffset, this._cachedReflectionVOffset = this.vOffset, this._cachedReflectionUScale = this.uScale, this._cachedReflectionVScale = this.vScale, this._cachedReflectionCoordinatesMode = this.coordinatesMode, this.coordinatesMode) {
-      case t.PLANAR_MODE: {
-        f.IdentityToRef(this._cachedReflectionTextureMatrix), this._cachedReflectionTextureMatrix[0] = this.uScale, this._cachedReflectionTextureMatrix[5] = this.vScale, this._cachedReflectionTextureMatrix[12] = this.uOffset, this._cachedReflectionTextureMatrix[13] = this.vOffset;
-        break;
-      }
-      case t.PROJECTION_MODE: {
-        f.FromValuesToRef(0.5, 0, 0, 0, 0, -0.5, 0, 0, 0, 0, 0, 0, 0.5, 0.5, 1, 1, this._projectionModeMatrix);
-        const i = e.getProjectionMatrix();
-        this._cachedReflectionProjectionMatrixId = i.updateFlag, i.multiplyToRef(this._projectionModeMatrix, this._cachedReflectionTextureMatrix);
-        break;
-      }
-      default:
-        f.IdentityToRef(this._cachedReflectionTextureMatrix);
-        break;
-    }
-    return s && e.markAllMaterialsAsDirty(1, (i) => i.getActiveTextures().indexOf(this) !== -1), this._cachedReflectionTextureMatrix;
-  }
-  /**
-   * Clones the texture.
-   * @returns the cloned texture
-   */
-  clone() {
-    const e = {
-      noMipmap: this._noMipmap,
-      invertY: this._invertY,
-      samplingMode: this.samplingMode,
-      onLoad: void 0,
-      onError: void 0,
-      buffer: this._texture ? this._texture._buffer : void 0,
-      deleteBuffer: this._deleteBuffer,
-      format: this.textureFormat,
-      mimeType: this.mimeType,
-      loaderOptions: this._loaderOptions,
-      creationFlags: this._creationFlags,
-      useSRGBBuffer: this._useSRGBBuffer
-    };
-    return F.Clone(() => new t(this._texture ? this._texture.url : null, this.getScene(), e), this);
-  }
-  /**
-   * Serialize the texture to a JSON representation we can easily use in the respective Parse function.
-   * @returns The JSON representation of the texture
-   */
-  serialize() {
-    var e, s;
-    const i = this.name;
-    t.SerializeBuffers || this.name.startsWith("data:") && (this.name = ""), this.name.startsWith("data:") && this.url === this.name && (this.url = "");
-    const a = super.serialize(t._SerializeInternalTextureUniqueId);
-    return a ? ((t.SerializeBuffers || t.ForceSerializeBuffers) && (typeof this._buffer == "string" && this._buffer.substr(0, 5) === "data:" ? (a.base64String = this._buffer, a.name = a.name.replace("data:", "")) : this.url && this.url.startsWith("data:") && this._buffer instanceof Uint8Array ? a.base64String = "data:image/png;base64," + J(this._buffer) : (t.ForceSerializeBuffers || this.url && this.url.startsWith("blob:") || this._forceSerialize) && (a.base64String = !this._engine || this._engine._features.supportSyncTextureRead ? Q(this) : K(this))), a.invertY = this._invertY, a.samplingMode = this.samplingMode, a._creationFlags = this._creationFlags, a._useSRGBBuffer = this._useSRGBBuffer, t._SerializeInternalTextureUniqueId && (a.internalTextureUniqueId = (s = (e = this._texture) === null || e === void 0 ? void 0 : e.uniqueId) !== null && s !== void 0 ? s : void 0), this.name = i, a) : null;
-  }
-  /**
-   * Get the current class name of the texture useful for serialization or dynamic coding.
-   * @returns "Texture"
-   */
-  getClassName() {
-    return "Texture";
-  }
-  /**
-   * Dispose the texture and release its associated resources.
-   */
-  dispose() {
-    super.dispose(), this.onLoadObservable.clear(), this._delayedOnLoad = null, this._delayedOnError = null, this._buffer = null;
-  }
-  /**
-   * Parse the JSON representation of a texture in order to recreate the texture in the given scene.
-   * @param parsedTexture Define the JSON representation of the texture
-   * @param scene Define the scene the parsed texture should be instantiated in
-   * @param rootUrl Define the root url of the parsing sequence in the case of relative dependencies
-   * @returns The parsed texture if successful
-   */
-  static Parse(e, s, i) {
-    if (e.customType) {
-      const n = Z.Instantiate(e.customType).Parse(e, s, i);
-      return e.samplingMode && n.updateSamplingMode && n._samplingMode && n._samplingMode !== e.samplingMode && n.updateSamplingMode(e.samplingMode), n;
-    }
-    if (e.isCube && !e.isRenderTarget)
-      return t._CubeTextureParser(e, s, i);
-    const a = e.internalTextureUniqueId !== void 0;
-    if (!e.name && !e.isRenderTarget && !a)
-      return null;
-    let l;
-    if (a) {
-      const r = s.getEngine().getLoadedTexturesCache();
-      for (const n of r)
-        if (n.uniqueId === e.internalTextureUniqueId) {
-          l = n;
-          break;
-        }
-    }
-    const u = (r) => {
-      var n;
-      if (r && r._texture && (r._texture._cachedWrapU = null, r._texture._cachedWrapV = null, r._texture._cachedWrapR = null), e.samplingMode) {
-        const h = e.samplingMode;
-        r && r.samplingMode !== h && r.updateSamplingMode(h);
-      }
-      if (r && e.animations)
-        for (let h = 0; h < e.animations.length; h++) {
-          const c = e.animations[h], o = q("BABYLON.Animation");
-          o && r.animations.push(o.Parse(c));
-        }
-      a && !l && ((n = r == null ? void 0 : r._texture) === null || n === void 0 || n._setUniqueId(e.internalTextureUniqueId));
-    };
-    return F.Parse(() => {
-      var r, n, h;
-      let c = !0;
-      if (e.noMipmap && (c = !1), e.mirrorPlane) {
-        const o = t._CreateMirror(e.name, e.renderTargetSize, s, c);
-        return o._waitingRenderList = e.renderList, o.mirrorPlane = X.FromArray(e.mirrorPlane), u(o), o;
-      } else if (e.isRenderTarget) {
-        let o = null;
-        if (e.isCube) {
-          if (s.reflectionProbes)
-            for (let R = 0; R < s.reflectionProbes.length; R++) {
-              const S = s.reflectionProbes[R];
-              if (S.name === e.name)
-                return S.cubeTexture;
-            }
-        } else
-          o = t._CreateRenderTargetTexture(e.name, e.renderTargetSize, s, c, (r = e._creationFlags) !== null && r !== void 0 ? r : 0), o._waitingRenderList = e.renderList;
-        return u(o), o;
-      } else {
-        let o;
-        if (e.base64String && !l)
-          o = t.CreateFromBase64String(e.base64String, e.base64String, s, !c, e.invertY, e.samplingMode, () => {
-            u(o);
-          }, (n = e._creationFlags) !== null && n !== void 0 ? n : 0, (h = e._useSRGBBuffer) !== null && h !== void 0 ? h : !1), o.name = e.name;
-        else {
-          let R;
-          e.name && (e.name.indexOf("://") > 0 || e.name.startsWith("data:")) ? R = e.name : R = i + e.name, e.url && (e.url.startsWith("data:") || t.UseSerializedUrlIfAny) && (R = e.url);
-          const S = {
-            noMipmap: !c,
-            invertY: e.invertY,
-            samplingMode: e.samplingMode,
-            onLoad: () => {
-              u(o);
-            },
-            internalTexture: l
-          };
-          o = new t(R, s, S);
-        }
-        return o;
-      }
-    }, e, s);
-  }
-  /**
-   * Creates a texture from its base 64 representation.
-   * @param data Define the base64 payload without the data: prefix
-   * @param name Define the name of the texture in the scene useful fo caching purpose for instance
-   * @param scene Define the scene the texture should belong to
-   * @param noMipmapOrOptions defines if the texture will require mip maps or not or set of all options to create the texture
-   * @param invertY define if the texture needs to be inverted on the y axis during loading
-   * @param samplingMode define the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)
-   * @param onLoad define a callback triggered when the texture has been loaded
-   * @param onError define a callback triggered when an error occurred during the loading session
-   * @param format define the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)
-   * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
-   * @returns the created texture
-   */
-  static CreateFromBase64String(e, s, i, a, l, u = t.TRILINEAR_SAMPLINGMODE, m = null, r = null, n = 5, h) {
-    return new t("data:" + s, i, a, l, u, m, r, e, !1, n, void 0, void 0, h);
-  }
-  /**
-   * Creates a texture from its data: representation. (data: will be added in case only the payload has been passed in)
-   * @param name Define the name of the texture in the scene useful fo caching purpose for instance
-   * @param buffer define the buffer to load the texture from in case the texture is loaded from a buffer representation
-   * @param scene Define the scene the texture should belong to
-   * @param deleteBuffer define if the buffer we are loading the texture from should be deleted after load
-   * @param noMipmapOrOptions defines if the texture will require mip maps or not or set of all options to create the texture
-   * @param invertY define if the texture needs to be inverted on the y axis during loading
-   * @param samplingMode define the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)
-   * @param onLoad define a callback triggered when the texture has been loaded
-   * @param onError define a callback triggered when an error occurred during the loading session
-   * @param format define the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)
-   * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
-   * @returns the created texture
-   */
-  static LoadFromDataString(e, s, i, a = !1, l, u = !0, m = t.TRILINEAR_SAMPLINGMODE, r = null, n = null, h = 5, c) {
-    return e.substr(0, 5) !== "data:" && (e = "data:" + e), new t(e, i, l, u, m, r, n, s, a, h, void 0, void 0, c);
-  }
-}
-t.SerializeBuffers = !0;
-t.ForceSerializeBuffers = !1;
-t.OnTextureLoadErrorObservable = new j();
-t._SerializeInternalTextureUniqueId = !1;
-t._CubeTextureParser = (W, e, s) => {
-  throw G("CubeTexture");
-};
-t._CreateMirror = (W, e, s, i) => {
-  throw G("MirrorTexture");
-};
-t._CreateRenderTargetTexture = (W, e, s, i, a) => {
-  throw G("RenderTargetTexture");
-};
-t.NEAREST_SAMPLINGMODE = 1;
-t.NEAREST_NEAREST_MIPLINEAR = 8;
-t.BILINEAR_SAMPLINGMODE = 2;
-t.LINEAR_LINEAR_MIPNEAREST = 11;
-t.TRILINEAR_SAMPLINGMODE = 3;
-t.LINEAR_LINEAR_MIPLINEAR = 3;
-t.NEAREST_NEAREST_MIPNEAREST = 4;
-t.NEAREST_LINEAR_MIPNEAREST = 5;
-t.NEAREST_LINEAR_MIPLINEAR = 6;
-t.NEAREST_LINEAR = 7;
-t.NEAREST_NEAREST = 1;
-t.LINEAR_NEAREST_MIPNEAREST = 9;
-t.LINEAR_NEAREST_MIPLINEAR = 10;
-t.LINEAR_LINEAR = 2;
-t.LINEAR_NEAREST = 12;
-t.EXPLICIT_MODE = 0;
-t.SPHERICAL_MODE = 1;
-t.PLANAR_MODE = 2;
-t.CUBIC_MODE = 3;
-t.PROJECTION_MODE = 4;
-t.SKYBOX_MODE = 5;
-t.INVCUBIC_MODE = 6;
-t.EQUIRECTANGULAR_MODE = 7;
-t.FIXED_EQUIRECTANGULAR_MODE = 8;
-t.FIXED_EQUIRECTANGULAR_MIRRORED_MODE = 9;
-t.CLAMP_ADDRESSMODE = 0;
-t.WRAP_ADDRESSMODE = 1;
-t.MIRROR_ADDRESSMODE = 2;
-t.UseSerializedUrlIfAny = !1;
-_([
-  d()
-], t.prototype, "url", void 0);
-_([
-  d()
-], t.prototype, "uOffset", void 0);
-_([
-  d()
-], t.prototype, "vOffset", void 0);
-_([
-  d()
-], t.prototype, "uScale", void 0);
-_([
-  d()
-], t.prototype, "vScale", void 0);
-_([
-  d()
-], t.prototype, "uAng", void 0);
-_([
-  d()
-], t.prototype, "vAng", void 0);
-_([
-  d()
-], t.prototype, "wAng", void 0);
-_([
-  d()
-], t.prototype, "uRotationCenter", void 0);
-_([
-  d()
-], t.prototype, "vRotationCenter", void 0);
-_([
-  d()
-], t.prototype, "wRotationCenter", void 0);
-_([
-  d()
-], t.prototype, "homogeneousRotationInUVTransform", void 0);
-_([
-  d()
-], t.prototype, "isBlocking", null);
-H("BABYLON.Texture", t);
-F._TextureParser = t.Parse;
-export {
-  t as Texture
-};

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

@@ -1,101 +0,0 @@
-class p {
-  /**
-   * | Value | Type               | Description |
-   * | ----- | ------------------ | ----------- |
-   * | 0     | CLAMP_ADDRESSMODE  |             |
-   * | 1     | WRAP_ADDRESSMODE   |             |
-   * | 2     | MIRROR_ADDRESSMODE |             |
-   */
-  get wrapU() {
-    return this._cachedWrapU;
-  }
-  set wrapU(i) {
-    this._cachedWrapU = i;
-  }
-  /**
-   * | Value | Type               | Description |
-   * | ----- | ------------------ | ----------- |
-   * | 0     | CLAMP_ADDRESSMODE  |             |
-   * | 1     | WRAP_ADDRESSMODE   |             |
-   * | 2     | MIRROR_ADDRESSMODE |             |
-   */
-  get wrapV() {
-    return this._cachedWrapV;
-  }
-  set wrapV(i) {
-    this._cachedWrapV = i;
-  }
-  /**
-   * | Value | Type               | Description |
-   * | ----- | ------------------ | ----------- |
-   * | 0     | CLAMP_ADDRESSMODE  |             |
-   * | 1     | WRAP_ADDRESSMODE   |             |
-   * | 2     | MIRROR_ADDRESSMODE |             |
-   */
-  get wrapR() {
-    return this._cachedWrapR;
-  }
-  set wrapR(i) {
-    this._cachedWrapR = i;
-  }
-  /**
-   * With compliant hardware and browser (supporting anisotropic filtering)
-   * this defines the level of anisotropic filtering in the texture.
-   * The higher the better but the slower.
-   */
-  get anisotropicFilteringLevel() {
-    return this._cachedAnisotropicFilteringLevel;
-  }
-  set anisotropicFilteringLevel(i) {
-    this._cachedAnisotropicFilteringLevel = i;
-  }
-  /**
-   * Gets or sets the comparison function (513, 514, etc). Set 0 to not use a comparison function
-   */
-  get comparisonFunction() {
-    return this._comparisonFunction;
-  }
-  set comparisonFunction(i) {
-    this._comparisonFunction = i;
-  }
-  /**
-   * Indicates to use the mip maps (if available on the texture).
-   * Thanks to this flag, you can instruct the sampler to not sample the mipmaps even if they exist (and if the sampling mode is set to a value that normally samples the mipmaps!)
-   */
-  get useMipMaps() {
-    return this._useMipMaps;
-  }
-  set useMipMaps(i) {
-    this._useMipMaps = i;
-  }
-  /**
-   * Creates a Sampler instance
-   */
-  constructor() {
-    this.samplingMode = -1, this._useMipMaps = !0, this._cachedWrapU = null, this._cachedWrapV = null, this._cachedWrapR = null, this._cachedAnisotropicFilteringLevel = null, this._comparisonFunction = 0;
-  }
-  /**
-   * Sets all the parameters of the sampler
-   * @param wrapU u address mode (default: TEXTURE_WRAP_ADDRESSMODE)
-   * @param wrapV v address mode (default: TEXTURE_WRAP_ADDRESSMODE)
-   * @param wrapR r address mode (default: TEXTURE_WRAP_ADDRESSMODE)
-   * @param anisotropicFilteringLevel anisotropic level (default: 1)
-   * @param samplingMode sampling mode (default: 2)
-   * @param comparisonFunction comparison function (default: 0 - no comparison function)
-   * @returns the current sampler instance
-   */
-  setParameters(i = 1, e = 1, s = 1, t = 1, c = 2, a = 0) {
-    return this._cachedWrapU = i, this._cachedWrapV = e, this._cachedWrapR = s, this._cachedAnisotropicFilteringLevel = t, this.samplingMode = c, this._comparisonFunction = a, this;
-  }
-  /**
-   * Compares this sampler with another one
-   * @param other sampler to compare with
-   * @returns true if the samplers have the same parametres, else false
-   */
-  compareSampler(i) {
-    return this._cachedWrapU === i._cachedWrapU && this._cachedWrapV === i._cachedWrapV && this._cachedWrapR === i._cachedWrapR && this._cachedAnisotropicFilteringLevel === i._cachedAnisotropicFilteringLevel && this.samplingMode === i.samplingMode && this._comparisonFunction === i._comparisonFunction && this._useMipMaps === i._useMipMaps;
-  }
-}
-export {
-  p as TextureSampler
-};