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

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

@@ -0,0 +1,421 @@
+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

@@ -0,0 +1,101 @@
+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
+};