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

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

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

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

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

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

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