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

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

@@ -1,150 +0,0 @@
-import { Observable as l } from "../../Misc/observable.esm.js";
-import { TextureSampler as d } from "./textureSampler.esm.js";
-var h;
-(function(i) {
-  i[i.Unknown = 0] = "Unknown", i[i.Url = 1] = "Url", i[i.Temp = 2] = "Temp", i[i.Raw = 3] = "Raw", i[i.Dynamic = 4] = "Dynamic", i[i.RenderTarget = 5] = "RenderTarget", i[i.MultiRenderTarget = 6] = "MultiRenderTarget", i[i.Cube = 7] = "Cube", i[i.CubeRaw = 8] = "CubeRaw", i[i.CubePrefiltered = 9] = "CubePrefiltered", i[i.Raw3D = 10] = "Raw3D", i[i.Raw2DArray = 11] = "Raw2DArray", i[i.DepthStencil = 12] = "DepthStencil", i[i.CubeRawRGBD = 13] = "CubeRawRGBD", i[i.Depth = 14] = "Depth";
-})(h || (h = {}));
-class r extends d {
-  /**
-   * Gets a boolean indicating if the texture uses mipmaps
-   * TODO implements useMipMaps as a separate setting from generateMipMaps
-   */
-  get useMipMaps() {
-    return this.generateMipMaps;
-  }
-  set useMipMaps(e) {
-    this.generateMipMaps = e;
-  }
-  /** Gets the unique id of the internal texture */
-  get uniqueId() {
-    return this._uniqueId;
-  }
-  /** @internal */
-  _setUniqueId(e) {
-    this._uniqueId = e;
-  }
-  /**
-   * Gets the Engine the texture belongs to.
-   * @returns The babylon engine
-   */
-  getEngine() {
-    return this._engine;
-  }
-  /**
-   * Gets the data source type of the texture
-   */
-  get source() {
-    return this._source;
-  }
-  /**
-   * Creates a new InternalTexture
-   * @param engine defines the engine to use
-   * @param source defines the type of data that will be used
-   * @param delayAllocation if the texture allocation should be delayed (default: false)
-   */
-  constructor(e, s, t = !1) {
-    super(), this.isReady = !1, this.isCube = !1, this.is3D = !1, this.is2DArray = !1, this.isMultiview = !1, this.url = "", this.generateMipMaps = !1, this.samples = 0, this.type = -1, this.format = -1, this.onLoadedObservable = new l(), this.onErrorObservable = new l(), this.onRebuildCallback = null, this.width = 0, this.height = 0, this.depth = 0, this.baseWidth = 0, this.baseHeight = 0, this.baseDepth = 0, this.invertY = !1, this._invertVScale = !1, this._associatedChannel = -1, this._source = h.Unknown, this._buffer = null, this._bufferView = null, this._bufferViewArray = null, this._bufferViewArrayArray = null, this._size = 0, this._extension = "", this._files = null, this._workingCanvas = null, this._workingContext = null, this._cachedCoordinatesMode = null, this._isDisabled = !1, this._compression = null, this._sphericalPolynomial = null, this._sphericalPolynomialPromise = null, this._sphericalPolynomialComputed = !1, this._lodGenerationScale = 0, this._lodGenerationOffset = 0, this._useSRGBBuffer = !1, this._lodTextureHigh = null, this._lodTextureMid = null, this._lodTextureLow = null, this._isRGBD = !1, this._linearSpecularLOD = !1, this._irradianceTexture = null, this._hardwareTexture = null, this._maxLodLevel = null, this._references = 1, this._gammaSpace = null, this._engine = e, this._source = s, this._uniqueId = r._Counter++, t || (this._hardwareTexture = e._createHardwareTexture());
-  }
-  /**
-   * Increments the number of references (ie. the number of Texture that point to it)
-   */
-  incrementReferences() {
-    this._references++;
-  }
-  /**
-   * Change the size of the texture (not the size of the content)
-   * @param width defines the new width
-   * @param height defines the new height
-   * @param depth defines the new depth (1 by default)
-   */
-  updateSize(e, s, t = 1) {
-    this._engine.updateTextureDimensions(this, e, s, t), this.width = e, this.height = s, this.depth = t, this.baseWidth = e, this.baseHeight = s, this.baseDepth = t, this._size = e * s * t;
-  }
-  /** @internal */
-  _rebuild() {
-    var e;
-    if (this.isReady = !1, this._cachedCoordinatesMode = null, this._cachedWrapU = null, this._cachedWrapV = null, this._cachedWrapR = null, this._cachedAnisotropicFilteringLevel = null, this.onRebuildCallback) {
-      const t = this.onRebuildCallback(this), a = (n) => {
-        n._swapAndDie(this, !1), this.isReady = t.isReady;
-      };
-      t.isAsync ? t.proxy.then(a) : a(t.proxy);
-      return;
-    }
-    let s;
-    switch (this.source) {
-      case h.Temp:
-        break;
-      case h.Url:
-        s = this._engine.createTexture(
-          (e = this._originalUrl) !== null && e !== void 0 ? e : this.url,
-          !this.generateMipMaps,
-          this.invertY,
-          null,
-          this.samplingMode,
-          // Do not use Proxy here as it could be fully synchronous
-          // and proxy would be undefined.
-          (t) => {
-            t._swapAndDie(this, !1), this.isReady = !0;
-          },
-          null,
-          this._buffer,
-          void 0,
-          this.format,
-          this._extension,
-          void 0,
-          void 0,
-          void 0,
-          this._useSRGBBuffer
-        );
-        return;
-      case h.Raw:
-        s = this._engine.createRawTexture(this._bufferView, this.baseWidth, this.baseHeight, this.format, this.generateMipMaps, this.invertY, this.samplingMode, this._compression, this.type, void 0, this._useSRGBBuffer), s._swapAndDie(this, !1), this.isReady = !0;
-        break;
-      case h.Raw3D:
-        s = this._engine.createRawTexture3D(this._bufferView, this.baseWidth, this.baseHeight, this.baseDepth, this.format, this.generateMipMaps, this.invertY, this.samplingMode, this._compression, this.type), s._swapAndDie(this, !1), this.isReady = !0;
-        break;
-      case h.Raw2DArray:
-        s = this._engine.createRawTexture2DArray(this._bufferView, this.baseWidth, this.baseHeight, this.baseDepth, this.format, this.generateMipMaps, this.invertY, this.samplingMode, this._compression, this.type), s._swapAndDie(this, !1), this.isReady = !0;
-        break;
-      case h.Dynamic:
-        s = this._engine.createDynamicTexture(this.baseWidth, this.baseHeight, this.generateMipMaps, this.samplingMode), s._swapAndDie(this, !1), this._engine.updateDynamicTexture(this, this._engine.getRenderingCanvas(), this.invertY, void 0, void 0, !0);
-        break;
-      case h.Cube:
-        s = this._engine.createCubeTexture(this.url, null, this._files, !this.generateMipMaps, () => {
-          s._swapAndDie(this, !1), this.isReady = !0;
-        }, null, this.format, this._extension, !1, 0, 0, null, void 0, this._useSRGBBuffer);
-        return;
-      case h.CubeRaw:
-        s = this._engine.createRawCubeTexture(this._bufferViewArray, this.width, this.format, this.type, this.generateMipMaps, this.invertY, this.samplingMode, this._compression), s._swapAndDie(this, !1), this.isReady = !0;
-        break;
-      case h.CubeRawRGBD:
-        return;
-      case h.CubePrefiltered:
-        s = this._engine.createPrefilteredCubeTexture(this.url, null, this._lodGenerationScale, this._lodGenerationOffset, (t) => {
-          t && t._swapAndDie(this, !1), this.isReady = !0;
-        }, null, this.format, this._extension), s._sphericalPolynomial = this._sphericalPolynomial;
-        return;
-    }
-  }
-  /**
-   * @internal
-   */
-  _swapAndDie(e, s = !0) {
-    var t;
-    (t = this._hardwareTexture) === null || t === void 0 || t.setUsage(e._source, this.generateMipMaps, this.isCube, this.width, this.height), e._hardwareTexture = this._hardwareTexture, s && (e._isRGBD = this._isRGBD), this._lodTextureHigh && (e._lodTextureHigh && e._lodTextureHigh.dispose(), e._lodTextureHigh = this._lodTextureHigh), this._lodTextureMid && (e._lodTextureMid && e._lodTextureMid.dispose(), e._lodTextureMid = this._lodTextureMid), this._lodTextureLow && (e._lodTextureLow && e._lodTextureLow.dispose(), e._lodTextureLow = this._lodTextureLow), this._irradianceTexture && (e._irradianceTexture && e._irradianceTexture.dispose(), e._irradianceTexture = this._irradianceTexture);
-    const a = this._engine.getLoadedTexturesCache();
-    let n = a.indexOf(this);
-    n !== -1 && a.splice(n, 1), n = a.indexOf(e), n === -1 && a.push(e);
-  }
-  /**
-   * Dispose the current allocated resources
-   */
-  dispose() {
-    this._references--, this.onLoadedObservable.clear(), this.onErrorObservable.clear(), this._references === 0 && (this._engine._releaseTexture(this), this._hardwareTexture = null);
-  }
-}
-r._Counter = 0;
-export {
-  r as InternalTexture,
-  h as InternalTextureSource
-};

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

@@ -1,17 +0,0 @@
-var R;
-(function(_) {
-  _[_.ETC1S = 0] = "ETC1S", _[_.UASTC4x4 = 1] = "UASTC4x4";
-})(R || (R = {}));
-var C;
-(function(_) {
-  _[_.ASTC_4X4_RGBA = 0] = "ASTC_4X4_RGBA", _[_.BC7_RGBA = 1] = "BC7_RGBA", _[_.BC3_RGBA = 2] = "BC3_RGBA", _[_.BC1_RGB = 3] = "BC1_RGB", _[_.PVRTC1_4_RGBA = 4] = "PVRTC1_4_RGBA", _[_.PVRTC1_4_RGB = 5] = "PVRTC1_4_RGB", _[_.ETC2_RGBA = 6] = "ETC2_RGBA", _[_.ETC1_RGB = 7] = "ETC1_RGB", _[_.RGBA32 = 8] = "RGBA32", _[_.R8 = 9] = "R8", _[_.RG8 = 10] = "RG8";
-})(C || (C = {}));
-var B;
-(function(_) {
-  _[_.COMPRESSED_RGBA_BPTC_UNORM_EXT = 36492] = "COMPRESSED_RGBA_BPTC_UNORM_EXT", _[_.COMPRESSED_RGBA_ASTC_4X4_KHR = 37808] = "COMPRESSED_RGBA_ASTC_4X4_KHR", _[_.COMPRESSED_RGB_S3TC_DXT1_EXT = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT", _[_.COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT", _[_.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG", _[_.COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG", _[_.COMPRESSED_RGBA8_ETC2_EAC = 37496] = "COMPRESSED_RGBA8_ETC2_EAC", _[_.COMPRESSED_RGB8_ETC2 = 37492] = "COMPRESSED_RGB8_ETC2", _[_.COMPRESSED_RGB_ETC1_WEBGL = 36196] = "COMPRESSED_RGB_ETC1_WEBGL", _[_.RGBA8Format = 32856] = "RGBA8Format", _[_.R8Format = 33321] = "R8Format", _[_.RG8Format = 33323] = "RG8Format";
-})(B || (B = {}));
-export {
-  B as EngineFormat,
-  R as SourceTextureFormat,
-  C as TranscodeTarget
-};

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

@@ -1,138 +0,0 @@
-import { Matrix as a, Vector3 as g, Vector2 as u } from "../../Maths/math.vector.esm.js";
-import { Texture as n } from "./texture.esm.js";
-import { RenderTargetTexture as m } from "./renderTargetTexture.esm.js";
-import { BlurPostProcess as h } from "../../PostProcesses/blurPostProcess.esm.js";
-import { Plane as c } from "../../Maths/math.plane.esm.js";
-class o extends m {
-  /**
-   * Define the blur ratio used to blur the reflection if needed.
-   */
-  set blurRatio(e) {
-    this._blurRatio !== e && (this._blurRatio = e, this._preparePostProcesses());
-  }
-  get blurRatio() {
-    return this._blurRatio;
-  }
-  /**
-   * Define the adaptive blur kernel used to blur the reflection if needed.
-   * This will autocompute the closest best match for the `blurKernel`
-   */
-  set adaptiveBlurKernel(e) {
-    this._adaptiveBlurKernel = e, this._autoComputeBlurKernel();
-  }
-  /**
-   * Define the blur kernel used to blur the reflection if needed.
-   * Please consider using `adaptiveBlurKernel` as it could find the closest best value for you.
-   */
-  set blurKernel(e) {
-    this.blurKernelX = e, this.blurKernelY = e;
-  }
-  /**
-   * Define the blur kernel on the X Axis used to blur the reflection if needed.
-   * Please consider using `adaptiveBlurKernel` as it could find the closest best value for you.
-   */
-  set blurKernelX(e) {
-    this._blurKernelX !== e && (this._blurKernelX = e, this._preparePostProcesses());
-  }
-  get blurKernelX() {
-    return this._blurKernelX;
-  }
-  /**
-   * Define the blur kernel on the Y Axis used to blur the reflection if needed.
-   * Please consider using `adaptiveBlurKernel` as it could find the closest best value for you.
-   */
-  set blurKernelY(e) {
-    this._blurKernelY !== e && (this._blurKernelY = e, this._preparePostProcesses());
-  }
-  get blurKernelY() {
-    return this._blurKernelY;
-  }
-  _autoComputeBlurKernel() {
-    const e = this.getScene().getEngine(), t = this.getRenderWidth() / e.getRenderWidth(), r = this.getRenderHeight() / e.getRenderHeight();
-    this.blurKernelX = this._adaptiveBlurKernel * t, this.blurKernelY = this._adaptiveBlurKernel * r;
-  }
-  _onRatioRescale() {
-    this._sizeRatio && (this.resize(this._initialSizeParameter), this._adaptiveBlurKernel || this._preparePostProcesses()), this._adaptiveBlurKernel && this._autoComputeBlurKernel();
-  }
-  _updateGammaSpace() {
-    const e = this.getScene();
-    e && (this.gammaSpace = !e.imageProcessingConfiguration.isEnabled || !e.imageProcessingConfiguration.applyByPostProcess);
-  }
-  /**
-   * Instantiates a Mirror Texture.
-   * Mirror texture can be used to simulate the view from a mirror in a scene.
-   * It will dynamically be rendered every frame to adapt to the camera point of view.
-   * You can then easily use it as a reflectionTexture on a flat surface.
-   * In case the surface is not a plane, please consider relying on reflection probes.
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrors
-   * @param name
-   * @param size
-   * @param scene
-   * @param generateMipMaps
-   * @param type
-   * @param samplingMode
-   * @param generateDepthBuffer
-   */
-  constructor(e, t, r, p, f = 0, d = n.BILINEAR_SAMPLINGMODE, b = !0) {
-    if (super(e, t, r, p, !0, f, !1, d, b), this.mirrorPlane = new c(0, 1, 0, 1), this._transformMatrix = a.Zero(), this._mirrorMatrix = a.Zero(), this._adaptiveBlurKernel = 0, this._blurKernelX = 0, this._blurKernelY = 0, this._blurRatio = 1, r = this.getScene(), !r)
-      return this;
-    this.ignoreCameraViewport = !0, this._updateGammaSpace(), this._imageProcessingConfigChangeObserver = r.imageProcessingConfiguration.onUpdateParameters.add(() => {
-      this._updateGammaSpace();
-    });
-    const s = r.getEngine();
-    s.supportsUniformBuffers && (this._sceneUBO = r.createSceneUniformBuffer(`Scene for Mirror Texture (name "${e}")`)), this.onBeforeBindObservable.add(() => {
-      var i;
-      (i = s._debugPushGroup) === null || i === void 0 || i.call(s, `mirror generation for ${e}`, 1);
-    }), this.onAfterUnbindObservable.add(() => {
-      var i;
-      (i = s._debugPopGroup) === null || i === void 0 || i.call(s, 1);
-    });
-    let l;
-    this.onBeforeRenderObservable.add(() => {
-      this._sceneUBO && (this._currentSceneUBO = r.getSceneUniformBuffer(), r.setSceneUniformBuffer(this._sceneUBO), r.getSceneUniformBuffer().unbindEffect()), a.ReflectionToRef(this.mirrorPlane, this._mirrorMatrix), this._mirrorMatrix.multiplyToRef(r.getViewMatrix(), this._transformMatrix), r.setTransformMatrix(this._transformMatrix, r.getProjectionMatrix()), l = r.clipPlane, r.clipPlane = this.mirrorPlane, r._mirroredCameraPosition = g.TransformCoordinates(r.activeCamera.globalPosition, this._mirrorMatrix);
-    }), this.onAfterRenderObservable.add(() => {
-      this._sceneUBO && r.setSceneUniformBuffer(this._currentSceneUBO), r.updateTransformMatrix(), r._mirroredCameraPosition = null, r.clipPlane = l;
-    });
-  }
-  _preparePostProcesses() {
-    if (this.clearPostProcesses(!0), this._blurKernelX && this._blurKernelY) {
-      const e = this.getScene().getEngine(), t = e.getCaps().textureFloatRender && e.getCaps().textureFloatLinearFiltering ? 1 : 2;
-      this._blurX = new h("horizontal blur", new u(1, 0), this._blurKernelX, this._blurRatio, null, n.BILINEAR_SAMPLINGMODE, e, !1, t), this._blurX.autoClear = !1, this._blurRatio === 1 && this.samples < 2 && this._texture ? this._blurX.inputTexture = this._renderTarget : this._blurX.alwaysForcePOT = !0, this._blurY = new h("vertical blur", new u(0, 1), this._blurKernelY, this._blurRatio, null, n.BILINEAR_SAMPLINGMODE, e, !1, t), this._blurY.autoClear = !1, this._blurY.alwaysForcePOT = this._blurRatio !== 1, this.addPostProcess(this._blurX), this.addPostProcess(this._blurY);
-    } else
-      this._blurY && (this.removePostProcess(this._blurY), this._blurY.dispose(), this._blurY = null), this._blurX && (this.removePostProcess(this._blurX), this._blurX.dispose(), this._blurX = null);
-  }
-  /**
-   * Clone the mirror texture.
-   * @returns the cloned texture
-   */
-  clone() {
-    const e = this.getScene();
-    if (!e)
-      return this;
-    const t = this.getSize(), r = new o(this.name, t.width, e, this._renderTargetOptions.generateMipMaps, this._renderTargetOptions.type, this._renderTargetOptions.samplingMode, this._renderTargetOptions.generateDepthBuffer);
-    return r.hasAlpha = this.hasAlpha, r.level = this.level, r.mirrorPlane = this.mirrorPlane.clone(), this.renderList && (r.renderList = this.renderList.slice(0)), r;
-  }
-  /**
-   * Serialize the texture to a JSON representation you could use in Parse later on
-   * @returns the serialized JSON representation
-   */
-  serialize() {
-    if (!this.name)
-      return null;
-    const e = super.serialize();
-    return e.mirrorPlane = this.mirrorPlane.asArray(), e;
-  }
-  /**
-   * Dispose the texture and release its associated resources.
-   */
-  dispose() {
-    var e;
-    super.dispose();
-    const t = this.getScene();
-    t && t.imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingConfigChangeObserver), (e = this._sceneUBO) === null || e === void 0 || e.dispose();
-  }
-}
-n._CreateMirror = (_, e, t, r) => new o(_, e, t, r);
-export {
-  o as MirrorTexture
-};

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

@@ -1,223 +0,0 @@
-import { Texture as f } from "./texture.esm.js";
-import { RenderTargetTexture as I } from "./renderTargetTexture.esm.js";
-import "../../Engines/Extensions/engine.multiRender.esm.js";
-class A extends I {
-  /**
-   * Get if draw buffers are currently supported by the used hardware and browser.
-   */
-  get isSupported() {
-    var e, t;
-    return (t = (e = this._engine) === null || e === void 0 ? void 0 : e.getCaps().drawBuffersExtension) !== null && t !== void 0 ? t : !1;
-  }
-  /**
-   * Get the list of textures generated by the multi render target.
-   */
-  get textures() {
-    return this._textures;
-  }
-  /**
-   * Gets the number of textures in this MRT. This number can be different from `_textures.length` in case a depth texture is generated.
-   */
-  get count() {
-    return this._count;
-  }
-  /**
-   * Get the depth texture generated by the multi render target if options.generateDepthTexture has been set
-   */
-  get depthTexture() {
-    return this._textures[this._textures.length - 1];
-  }
-  /**
-   * Set the wrapping mode on U of all the textures we are rendering to.
-   * Can be any of the Texture. (CLAMP_ADDRESSMODE, MIRROR_ADDRESSMODE or WRAP_ADDRESSMODE)
-   */
-  set wrapU(e) {
-    if (this._textures)
-      for (let t = 0; t < this._textures.length; t++)
-        this._textures[t].wrapU = e;
-  }
-  /**
-   * Set the wrapping mode on V of all the textures we are rendering to.
-   * Can be any of the Texture. (CLAMP_ADDRESSMODE, MIRROR_ADDRESSMODE or WRAP_ADDRESSMODE)
-   */
-  set wrapV(e) {
-    if (this._textures)
-      for (let t = 0; t < this._textures.length; t++)
-        this._textures[t].wrapV = e;
-  }
-  /**
-   * Instantiate a new multi render target texture.
-   * A multi render target, like a render target provides the ability to render to a texture.
-   * Unlike the render target, it can render to several draw buffers in one draw.
-   * This is specially interesting in deferred rendering or for any effects requiring more than
-   * just one color from a single pass.
-   * @param name Define the name of the texture
-   * @param size Define the size of the buffers to render to
-   * @param count Define the number of target we are rendering into
-   * @param scene Define the scene the texture belongs to
-   * @param options Define the options used to create the multi render target
-   * @param textureNames Define the names to set to the textures (if count > 0 - optional)
-   */
-  constructor(e, t, i, n, r, u) {
-    const l = r && r.generateMipMaps ? r.generateMipMaps : !1, h = r && r.generateDepthTexture ? r.generateDepthTexture : !1, d = r && r.depthTextureFormat ? r.depthTextureFormat : 15, s = !r || r.doNotChangeAspectRatio === void 0 ? !0 : r.doNotChangeAspectRatio, a = r && r.drawOnlyOnFirstAttachmentByDefault ? r.drawOnlyOnFirstAttachmentByDefault : !1;
-    if (super(e, t, n, l, s, void 0, void 0, void 0, void 0, void 0, void 0, void 0, !0), !this.isSupported) {
-      this.dispose();
-      return;
-    }
-    this._textureNames = u;
-    const _ = [], g = [], T = [], p = [], x = [], m = [], c = [], y = [];
-    this._initTypes(i, _, g, T, p, x, m, c, y, r);
-    const R = !r || r.generateDepthBuffer === void 0 ? !0 : r.generateDepthBuffer, B = !r || r.generateStencilBuffer === void 0 ? !1 : r.generateStencilBuffer;
-    this._multiRenderTargetOptions = {
-      samplingModes: g,
-      generateMipMaps: l,
-      generateDepthBuffer: R,
-      generateStencilBuffer: B,
-      generateDepthTexture: h,
-      depthTextureFormat: d,
-      types: _,
-      textureCount: i,
-      useSRGBBuffers: T,
-      formats: p,
-      targetTypes: x,
-      faceIndex: m,
-      layerIndex: c,
-      layerCounts: y
-    }, this._count = i, this._drawOnlyOnFirstAttachmentByDefault = a, i > 0 && (this._createInternalTextures(), this._createTextures(u));
-  }
-  _initTypes(e, t, i, n, r, u, l, h, d, s) {
-    for (let a = 0; a < e; a++)
-      s && s.types && s.types[a] !== void 0 ? t.push(s.types[a]) : t.push(s && s.defaultType ? s.defaultType : 0), s && s.samplingModes && s.samplingModes[a] !== void 0 ? i.push(s.samplingModes[a]) : i.push(f.BILINEAR_SAMPLINGMODE), s && s.useSRGBBuffers && s.useSRGBBuffers[a] !== void 0 ? n.push(s.useSRGBBuffers[a]) : n.push(!1), s && s.formats && s.formats[a] !== void 0 ? r.push(s.formats[a]) : r.push(5), s && s.targetTypes && s.targetTypes[a] !== void 0 ? u.push(s.targetTypes[a]) : u.push(3553), s && s.faceIndex && s.faceIndex[a] !== void 0 ? l.push(s.faceIndex[a]) : l.push(0), s && s.layerIndex && s.layerIndex[a] !== void 0 ? h.push(s.layerIndex[a]) : h.push(0), s && s.layerCounts && s.layerCounts[a] !== void 0 ? d.push(s.layerCounts[a]) : d.push(1);
-  }
-  _createInternaTextureIndexMapping() {
-    const e = {}, t = [];
-    if (!this._renderTarget)
-      return t;
-    const i = this._renderTarget.textures;
-    for (let n = 0; n < i.length; n++) {
-      const r = i[n];
-      if (!r)
-        continue;
-      const u = e[r.uniqueId];
-      u !== void 0 ? t[n] = u : e[r.uniqueId] = n;
-    }
-    return t;
-  }
-  /**
-   * @internal
-   */
-  _rebuild(e = !1, t) {
-    if (this._count < 1)
-      return;
-    const i = this._createInternaTextureIndexMapping();
-    this.releaseInternalTextures(), this._createInternalTextures(), e && (this._releaseTextures(), this._createTextures(t));
-    const n = this._renderTarget.textures;
-    for (let r = 0; r < n.length; r++) {
-      const u = this._textures[r];
-      i[r] !== void 0 && this._renderTarget.setTexture(n[i[r]], r), u._texture = n[r], u._texture && (u._noMipmap = !u._texture.useMipMaps, u._useSRGBBuffer = u._texture._useSRGBBuffer);
-    }
-    this.samples !== 1 && this._renderTarget.setSamples(this.samples, !this._drawOnlyOnFirstAttachmentByDefault, !0);
-  }
-  _createInternalTextures() {
-    this._renderTarget = this._getEngine().createMultipleRenderTarget(this._size, this._multiRenderTargetOptions, !this._drawOnlyOnFirstAttachmentByDefault), this._texture = this._renderTarget.texture;
-  }
-  _releaseTextures() {
-    if (this._textures)
-      for (let e = 0; e < this._textures.length; e++)
-        this._textures[e]._texture = null, this._textures[e].dispose();
-  }
-  _createTextures(e) {
-    const t = this._renderTarget.textures;
-    this._textures = [];
-    for (let i = 0; i < t.length; i++) {
-      const n = new f(null, this.getScene());
-      e != null && e[i] && (n.name = e[i]), n._texture = t[i], n._texture && (n._noMipmap = !n._texture.useMipMaps, n._useSRGBBuffer = n._texture._useSRGBBuffer), this._textures.push(n);
-    }
-  }
-  /**
-   * Replaces an internal texture within the MRT. Useful to share textures between MultiRenderTarget.
-   * @param texture The new texture to set in the MRT
-   * @param index The index of the texture to replace
-   * @param disposePrevious Set to true if the previous internal texture should be disposed
-   */
-  setInternalTexture(e, t, i = !0) {
-    var n, r;
-    if (this.renderTarget && (t === 0 && (this._texture = e), this.renderTarget.setTexture(e, t, i), this.textures[t] || (this.textures[t] = new f(null, this.getScene()), this.textures[t].name = (r = (n = this._textureNames) === null || n === void 0 ? void 0 : n[t]) !== null && r !== void 0 ? r : this.textures[t].name), this.textures[t]._texture = e, this.textures[t]._noMipmap = !e.useMipMaps, this.textures[t]._useSRGBBuffer = e._useSRGBBuffer, this._count = this.renderTarget.textures ? this.renderTarget.textures.length : 0, this._multiRenderTargetOptions.types && (this._multiRenderTargetOptions.types[t] = e.type), this._multiRenderTargetOptions.samplingModes && (this._multiRenderTargetOptions.samplingModes[t] = e.samplingMode), this._multiRenderTargetOptions.useSRGBBuffers && (this._multiRenderTargetOptions.useSRGBBuffers[t] = e._useSRGBBuffer), this._multiRenderTargetOptions.targetTypes && this._multiRenderTargetOptions.targetTypes[t] !== -1)) {
-      let u = 0;
-      e.is2DArray ? u = 35866 : e.isCube ? u = 34067 : e.is3D ? u = 32879 : u = 3553, this._multiRenderTargetOptions.targetTypes[t] = u;
-    }
-  }
-  /**
-   * Changes an attached texture's face index or layer.
-   * @param index The index of the texture to modify the attachment of
-   * @param layerIndex The layer index of the texture to be attached to the framebuffer
-   * @param faceIndex The face index of the texture to be attached to the framebuffer
-   */
-  setLayerAndFaceIndex(e, t = -1, i = -1) {
-    !this.textures[e] || !this.renderTarget || (this._multiRenderTargetOptions.layerIndex && (this._multiRenderTargetOptions.layerIndex[e] = t), this._multiRenderTargetOptions.faceIndex && (this._multiRenderTargetOptions.faceIndex[e] = i), this.renderTarget.setLayerAndFaceIndex(e, t, i));
-  }
-  /**
-   * Changes every attached texture's face index or layer.
-   * @param layerIndices The layer indices of the texture to be attached to the framebuffer
-   * @param faceIndices The face indices of the texture to be attached to the framebuffer
-   */
-  setLayerAndFaceIndices(e, t) {
-    this.renderTarget && (this._multiRenderTargetOptions.layerIndex = e, this._multiRenderTargetOptions.faceIndex = t, this.renderTarget.setLayerAndFaceIndices(e, t));
-  }
-  /**
-   * Define the number of samples used if MSAA is enabled.
-   */
-  get samples() {
-    return this._samples;
-  }
-  set samples(e) {
-    this._renderTarget ? this._samples = this._renderTarget.setSamples(e) : this._samples = e;
-  }
-  /**
-   * Resize all the textures in the multi render target.
-   * Be careful as it will recreate all the data in the new texture.
-   * @param size Define the new size
-   */
-  resize(e) {
-    this._processSizeParameter(e, !1), this._rebuild(void 0, this._textureNames);
-  }
-  /**
-   * Changes the number of render targets in this MRT
-   * Be careful as it will recreate all the data in the new texture.
-   * @param count new texture count
-   * @param options Specifies texture types and sampling modes for new textures
-   * @param textureNames Specifies the names of the textures (optional)
-   */
-  updateCount(e, t, i) {
-    this._multiRenderTargetOptions.textureCount = e, this._count = e;
-    const n = [], r = [], u = [], l = [], h = [], d = [], s = [], a = [];
-    this._textureNames = i, this._initTypes(e, n, r, u, l, h, d, s, a, t), this._multiRenderTargetOptions.types = n, this._multiRenderTargetOptions.samplingModes = r, this._multiRenderTargetOptions.useSRGBBuffers = u, this._multiRenderTargetOptions.formats = l, this._multiRenderTargetOptions.targetTypes = h, this._multiRenderTargetOptions.faceIndex = d, this._multiRenderTargetOptions.layerIndex = s, this._multiRenderTargetOptions.layerCounts = a, this._rebuild(!0, i);
-  }
-  _unbindFrameBuffer(e, t) {
-    this._renderTarget && e.unBindMultiColorAttachmentFramebuffer(this._renderTarget, this.isCube, () => {
-      this.onAfterRenderObservable.notifyObservers(t);
-    });
-  }
-  /**
-   * Dispose the render targets and their associated resources
-   * @param doNotDisposeInternalTextures
-   */
-  dispose(e = !1) {
-    this._releaseTextures(), e ? this._texture = null : this.releaseInternalTextures(), super.dispose();
-  }
-  /**
-   * Release all the underlying texture used as draw buffers.
-   */
-  releaseInternalTextures() {
-    var e, t;
-    const i = (e = this._renderTarget) === null || e === void 0 ? void 0 : e.textures;
-    if (i) {
-      for (let n = i.length - 1; n >= 0; n--)
-        this._textures[n]._texture = null;
-      (t = this._renderTarget) === null || t === void 0 || t.dispose(), this._renderTarget = null;
-    }
-  }
-}
-export {
-  A as MultiRenderTarget
-};

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

@@ -1,58 +0,0 @@
-import { SerializationHelper as p } from "../../Misc/decorators.esm.js";
-import { _UpdateRGBDAsync as c } from "../../Misc/environmentTextureTools.esm.js";
-import { InternalTextureSource as f } from "./internalTexture.esm.js";
-import { CubeTexture as m } from "./cubeTexture.esm.js";
-import "../../Engines/Extensions/engine.rawTexture.esm.js";
-class i extends m {
-  /**
-   * Creates a cube texture where the raw buffers are passed in.
-   * @param scene defines the scene the texture is attached to
-   * @param data defines the array of data to use to create each face
-   * @param size defines the size of the textures
-   * @param format defines the format of the data
-   * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT)
-   * @param generateMipMaps  defines if the engine should generate the mip levels
-   * @param invertY defines if data must be stored with Y axis inverted
-   * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
-   * @param compression defines the compression used (null by default)
-   */
-  constructor(t, e, r, n = 5, u = 0, o = !1, a = !1, s = 3, l = null) {
-    super("", t), this._texture = t.getEngine().createRawCubeTexture(e, r, n, u, o, a, s, l);
-  }
-  /**
-   * Updates the raw cube texture.
-   * @param data defines the data to store
-   * @param format defines the data format
-   * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
-   * @param invertY defines if data must be stored with Y axis inverted
-   * @param compression defines the compression used (null by default)
-   */
-  update(t, e, r, n, u = null) {
-    this._texture.getEngine().updateRawCubeTexture(this._texture, t, e, r, n, u);
-  }
-  /**
-   * Updates a raw cube texture with RGBD encoded data.
-   * @param data defines the array of data [mipmap][face] to use to create each face
-   * @param sphericalPolynomial defines the spherical polynomial for irradiance
-   * @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
-   * @returns a promise that resolves when the operation is complete
-   */
-  updateRGBDAsync(t, e = null, r = 0.8, n = 0) {
-    return c(this._texture, t, e, r, n).then(() => {
-    });
-  }
-  /**
-   * Clones the raw cube texture.
-   * @returns a new cube texture
-   */
-  clone() {
-    return p.Clone(() => {
-      const t = this.getScene(), e = this._texture, r = new i(t, e._bufferViewArray, e.width, e.format, e.type, e.generateMipMaps, e.invertY, e.samplingMode, e._compression);
-      return e.source === f.CubeRawRGBD && r.updateRGBDAsync(e._bufferViewArrayArray, e._sphericalPolynomial, e._lodGenerationScale, e._lodGenerationOffset), r;
-    }, this);
-  }
-}
-export {
-  i as RawCubeTexture
-};