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

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.alpha.esm.js

@@ -0,0 +1,101 @@
+import { ThinEngine as a } from "../thinEngine.esm.js";
+a.prototype.setAlphaConstants = function(t, e, h, l) {
+  this._alphaState.setAlphaBlendConstants(t, e, h, l);
+};
+a.prototype.setAlphaMode = function(t, e = !1) {
+  if (this._alphaMode === t) {
+    if (!e) {
+      const h = t === 0;
+      this.depthCullingState.depthMask !== h && (this.depthCullingState.depthMask = h);
+    }
+    return;
+  }
+  switch (t) {
+    case 0:
+      this._alphaState.alphaBlend = !1;
+      break;
+    case 7:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 8:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA), this._alphaState.alphaBlend = !0;
+      break;
+    case 2:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 6:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ZERO, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 1:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE, this._gl.ZERO, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 3:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ZERO, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 4:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.DST_COLOR, this._gl.ZERO, this._gl.ONE, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 5:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 9:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.CONSTANT_COLOR, this._gl.ONE_MINUS_CONSTANT_COLOR, this._gl.CONSTANT_ALPHA, this._gl.ONE_MINUS_CONSTANT_ALPHA), this._alphaState.alphaBlend = !0;
+      break;
+    case 10:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA), this._alphaState.alphaBlend = !0;
+      break;
+    case 11:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ONE, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 12:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.DST_ALPHA, this._gl.ONE, this._gl.ZERO, this._gl.ZERO), this._alphaState.alphaBlend = !0;
+      break;
+    case 13:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE_MINUS_DST_COLOR, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE_MINUS_DST_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA), this._alphaState.alphaBlend = !0;
+      break;
+    case 14:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA), this._alphaState.alphaBlend = !0;
+      break;
+    case 15:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ONE, this._gl.ZERO), this._alphaState.alphaBlend = !0;
+      break;
+    case 16:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE_MINUS_DST_COLOR, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ZERO, this._gl.ONE), this._alphaState.alphaBlend = !0;
+      break;
+    case 17:
+      this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA), this._alphaState.alphaBlend = !0;
+      break;
+  }
+  e || (this.depthCullingState.depthMask = t === 0), this._alphaMode = t;
+};
+a.prototype.getAlphaMode = function() {
+  return this._alphaMode;
+};
+a.prototype.setAlphaEquation = function(t) {
+  if (this._alphaEquation !== t) {
+    switch (t) {
+      case 0:
+        this._alphaState.setAlphaEquationParameters(32774, 32774);
+        break;
+      case 1:
+        this._alphaState.setAlphaEquationParameters(32778, 32778);
+        break;
+      case 2:
+        this._alphaState.setAlphaEquationParameters(32779, 32779);
+        break;
+      case 3:
+        this._alphaState.setAlphaEquationParameters(32776, 32776);
+        break;
+      case 4:
+        this._alphaState.setAlphaEquationParameters(32775, 32775);
+        break;
+      case 5:
+        this._alphaState.setAlphaEquationParameters(32775, 32774);
+        break;
+    }
+    this._alphaEquation = t;
+  }
+};
+a.prototype.getAlphaEquation = function() {
+  return this._alphaEquation;
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.cubeTexture.esm.js

@@ -0,0 +1,103 @@
+import { ThinEngine as d } from "../thinEngine.esm.js";
+import { InternalTexture as B, InternalTextureSource as b } from "../../Materials/Textures/internalTexture.esm.js";
+import { Logger as A } from "../../Misc/logger.esm.js";
+import { LoadImage as L } from "../../Misc/fileTools.esm.js";
+import { RandomGUID as M } from "../../Misc/guid.esm.js";
+d.prototype._createDepthStencilCubeTexture = function(a, o, n) {
+  const e = new B(this, b.DepthStencil);
+  if (e.isCube = !0, this.webGLVersion === 1)
+    return A.Error("Depth cube texture is not supported by WebGL 1."), e;
+  const s = Object.assign({ bilinearFiltering: !1, comparisonFunction: 0, generateStencil: !1 }, o), t = this._gl;
+  this._bindTextureDirectly(t.TEXTURE_CUBE_MAP, e, !0), this._setupDepthStencilTexture(e, a, s.generateStencil, s.bilinearFiltering, s.comparisonFunction), n._depthStencilTexture = e, n._depthStencilTextureWithStencil = s.generateStencil;
+  for (let r = 0; r < 6; r++)
+    s.generateStencil ? t.texImage2D(t.TEXTURE_CUBE_MAP_POSITIVE_X + r, 0, t.DEPTH24_STENCIL8, a, a, 0, t.DEPTH_STENCIL, t.UNSIGNED_INT_24_8, null) : t.texImage2D(t.TEXTURE_CUBE_MAP_POSITIVE_X + r, 0, t.DEPTH_COMPONENT24, a, a, 0, t.DEPTH_COMPONENT, t.UNSIGNED_INT, null);
+  return this._bindTextureDirectly(t.TEXTURE_CUBE_MAP, null), this._internalTexturesCache.push(e), e;
+};
+d.prototype._partialLoadFile = function(a, o, n, e, s = null) {
+  const t = (l) => {
+    n[o] = l, n._internalCount++, n._internalCount === 6 && e(n);
+  }, r = (l, E) => {
+    s && l && s(l.status + " " + l.statusText, E);
+  };
+  this._loadFile(a, t, void 0, void 0, !0, r);
+};
+d.prototype._cascadeLoadFiles = function(a, o, n, e = null) {
+  const s = [];
+  s._internalCount = 0;
+  for (let t = 0; t < 6; t++)
+    this._partialLoadFile(n[t], t, s, o, e);
+};
+d.prototype._cascadeLoadImgs = function(a, o, n, e, s = null, t) {
+  const r = [];
+  r._internalCount = 0;
+  for (let l = 0; l < 6; l++)
+    this._partialLoadImg(e[l], l, r, a, o, n, s, t);
+};
+d.prototype._partialLoadImg = function(a, o, n, e, s, t, r = null, l) {
+  const E = M();
+  L(a, (h) => {
+    n[o] = h, n._internalCount++, e && e.removePendingData(E), n._internalCount === 6 && t && t(s, n);
+  }, (h, P) => {
+    e && e.removePendingData(E), r && r(h, P);
+  }, e ? e.offlineProvider : null, l), e && e.addPendingData(E);
+};
+d.prototype._setCubeMapTextureParams = function(a, o, n) {
+  const e = this._gl;
+  e.texParameteri(e.TEXTURE_CUBE_MAP, e.TEXTURE_MAG_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_CUBE_MAP, e.TEXTURE_MIN_FILTER, o ? e.LINEAR_MIPMAP_LINEAR : e.LINEAR), e.texParameteri(e.TEXTURE_CUBE_MAP, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_CUBE_MAP, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), a.samplingMode = o ? 3 : 2, o && this.getCaps().textureMaxLevel && n !== void 0 && n > 0 && (e.texParameteri(e.TEXTURE_CUBE_MAP, e.TEXTURE_MAX_LEVEL, n), a._maxLodLevel = n), this._bindTextureDirectly(e.TEXTURE_CUBE_MAP, null);
+};
+d.prototype.createCubeTextureBase = function(a, o, n, e, s = null, t = null, r, l = null, E = !1, U = 0, g = 0, h = null, P = null, I = null, u = !1) {
+  const i = h || new B(this, b.Cube);
+  i.isCube = !0, i.url = a, i.generateMipMaps = !e, i._lodGenerationScale = U, i._lodGenerationOffset = g, i._useSRGBBuffer = !!u && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU || !!e), i !== h && (i.label = a.substring(0, 60)), this._doNotHandleContextLost || (i._extension = l, i._files = n);
+  const T = a;
+  this._transformTextureUrl && !h && (a = this._transformTextureUrl(a));
+  const f = a.split("?")[0], C = f.lastIndexOf("."), R = l || (C > -1 ? f.substring(C).toLowerCase() : "");
+  let p = null;
+  for (const _ of d._TextureLoaders)
+    if (_.canLoad(R)) {
+      p = _;
+      break;
+    }
+  const x = (_, c) => {
+    a === T ? t && _ && t(_.status + " " + _.statusText, c) : (A.Warn(`Failed to load ${a}, falling back to the ${T}`), this.createCubeTextureBase(T, o, n, !!e, s, t, r, l, E, U, g, i, P, I, u));
+  };
+  if (p) {
+    const _ = (c) => {
+      P && P(i, c), p.loadCubeData(c, i, E, s, t);
+    };
+    n && n.length === 6 ? p.supportCascades ? this._cascadeLoadFiles(o, (c) => _(c.map((S) => new Uint8Array(S))), n, t) : t ? t("Textures type does not support cascades.") : A.Warn("Texture loader does not support cascades.") : this._loadFile(a, (c) => _(new Uint8Array(c)), void 0, void 0, !0, x);
+  } else {
+    if (!n)
+      throw new Error("Cannot load cubemap because files were not defined");
+    this._cascadeLoadImgs(o, i, (_, c) => {
+      I && I(_, c);
+    }, n, t);
+  }
+  return this._internalTexturesCache.push(i), i;
+};
+d.prototype.createCubeTexture = function(a, o, n, e, s = null, t = null, r, l = null, E = !1, U = 0, g = 0, h = null, P, I = !1) {
+  const u = this._gl;
+  return this.createCubeTextureBase(a, o, n, !!e, s, t, r, l, E, U, g, h, (i) => this._bindTextureDirectly(u.TEXTURE_CUBE_MAP, i, !0), (i, T) => {
+    const f = this.needPOTTextures ? d.GetExponentOfTwo(T[0].width, this._caps.maxCubemapTextureSize) : T[0].width, C = f, R = [
+      u.TEXTURE_CUBE_MAP_POSITIVE_X,
+      u.TEXTURE_CUBE_MAP_POSITIVE_Y,
+      u.TEXTURE_CUBE_MAP_POSITIVE_Z,
+      u.TEXTURE_CUBE_MAP_NEGATIVE_X,
+      u.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+      u.TEXTURE_CUBE_MAP_NEGATIVE_Z
+    ];
+    this._bindTextureDirectly(u.TEXTURE_CUBE_MAP, i, !0), this._unpackFlipY(!1);
+    const p = r ? this._getInternalFormat(r, i._useSRGBBuffer) : i._useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : u.RGBA;
+    let x = r ? this._getInternalFormat(r) : u.RGBA;
+    i._useSRGBBuffer && this.webGLVersion === 1 && (x = p);
+    for (let _ = 0; _ < R.length; _++)
+      if (T[_].width !== f || T[_].height !== C) {
+        if (this._prepareWorkingCanvas(), !this._workingCanvas || !this._workingContext) {
+          A.Warn("Cannot create canvas to resize texture.");
+          return;
+        }
+        this._workingCanvas.width = f, this._workingCanvas.height = C, this._workingContext.drawImage(T[_], 0, 0, T[_].width, T[_].height, 0, 0, f, C), u.texImage2D(R[_], 0, p, x, u.UNSIGNED_BYTE, this._workingCanvas);
+      } else
+        u.texImage2D(R[_], 0, p, x, u.UNSIGNED_BYTE, T[_]);
+    e || u.generateMipmap(u.TEXTURE_CUBE_MAP), this._setCubeMapTextureParams(i, !e), i.width = f, i.height = C, i.isReady = !0, r && (i.format = r), i.onLoadedObservable.notifyObservers(i), i.onLoadedObservable.clear(), s && s();
+  }, !!I);
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.dynamicBuffer.esm.js

@@ -0,0 +1,11 @@
+import { ThinEngine as f } from "../thinEngine.esm.js";
+f.prototype.updateDynamicIndexBuffer = function(e, r, i = 0) {
+  this._currentBoundBuffer[this._gl.ELEMENT_ARRAY_BUFFER] = null, this.bindIndexBuffer(e);
+  let n;
+  e.is32Bits ? n = r instanceof Uint32Array ? r : new Uint32Array(r) : n = r instanceof Uint16Array ? r : new Uint16Array(r), this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, n, this._gl.DYNAMIC_DRAW), this._resetIndexBufferBinding();
+};
+f.prototype.updateDynamicVertexBuffer = function(e, r, i, n) {
+  this.bindArrayBuffer(e), i === void 0 && (i = 0);
+  const u = r.byteLength || r.length;
+  n === void 0 || n >= u && i === 0 ? r instanceof Array ? this._gl.bufferSubData(this._gl.ARRAY_BUFFER, i, new Float32Array(r)) : this._gl.bufferSubData(this._gl.ARRAY_BUFFER, i, r) : r instanceof Array ? this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, new Float32Array(r).subarray(i, i + n)) : (r instanceof ArrayBuffer ? r = new Uint8Array(r, i, n) : r = new Uint8Array(r.buffer, r.byteOffset + i, n), this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, r)), this._resetVertexBufferBinding();
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.dynamicTexture.esm.js

@@ -0,0 +1,14 @@
+import { ThinEngine as o } from "../thinEngine.esm.js";
+import { InternalTexture as f, InternalTextureSource as _ } from "../../Materials/Textures/internalTexture.esm.js";
+o.prototype.createDynamicTexture = function(e, i, r, a) {
+  const t = new f(this, _.Dynamic);
+  return t.baseWidth = e, t.baseHeight = i, r && (e = this.needPOTTextures ? o.GetExponentOfTwo(e, this._caps.maxTextureSize) : e, i = this.needPOTTextures ? o.GetExponentOfTwo(i, this._caps.maxTextureSize) : i), t.width = e, t.height = i, t.isReady = !1, t.generateMipMaps = r, t.samplingMode = a, this.updateTextureSamplingMode(a, t), this._internalTexturesCache.push(t), t;
+};
+o.prototype.updateDynamicTexture = function(e, i, r, a = !1, t, T = !1, m = !1) {
+  if (!e)
+    return;
+  const n = this._gl, s = n.TEXTURE_2D, u = this._bindTextureDirectly(s, e, !0, T);
+  this._unpackFlipY(r === void 0 ? e.invertY : r), a && n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 1);
+  const l = this._getWebGLTextureType(e.type), p = this._getInternalFormat(t || e.format), c = this._getRGBABufferInternalSizedFormat(e.type, p);
+  n.texImage2D(s, 0, c, p, l, i), e.generateMipMaps && n.generateMipmap(s), u || this._bindTextureDirectly(s, null), a && n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0), e.isReady = !0;
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.multiRender.esm.js

@@ -0,0 +1,111 @@
+import { InternalTexture as j, InternalTextureSource as K } from "../../Materials/Textures/internalTexture.esm.js";
+import { Logger as Z } from "../../Misc/logger.esm.js";
+import { ThinEngine as b } from "../thinEngine.esm.js";
+b.prototype.restoreSingleAttachment = function() {
+  const r = this._gl;
+  this.bindAttachments([r.BACK]);
+};
+b.prototype.restoreSingleAttachmentForRenderTarget = function() {
+  const r = this._gl;
+  this.bindAttachments([r.COLOR_ATTACHMENT0]);
+};
+b.prototype.buildTextureLayout = function(r) {
+  const t = this._gl, E = [];
+  for (let a = 0; a < r.length; a++)
+    r[a] ? E.push(t["COLOR_ATTACHMENT" + a]) : E.push(t.NONE);
+  return E;
+};
+b.prototype.bindAttachments = function(r) {
+  this._gl.drawBuffers(r);
+};
+b.prototype.unBindMultiColorAttachmentFramebuffer = function(r, t = !1, E) {
+  this._currentRenderTarget = null;
+  const a = this._gl, i = r._attachments, _ = i.length;
+  if (r._MSAAFramebuffer) {
+    a.bindFramebuffer(a.READ_FRAMEBUFFER, r._MSAAFramebuffer), a.bindFramebuffer(a.DRAW_FRAMEBUFFER, r._framebuffer);
+    for (let f = 0; f < _; f++) {
+      const T = r.textures[f];
+      for (let u = 0; u < _; u++)
+        i[u] = a.NONE;
+      i[f] = a[this.webGLVersion > 1 ? "COLOR_ATTACHMENT" + f : "COLOR_ATTACHMENT" + f + "_WEBGL"], a.readBuffer(i[f]), a.drawBuffers(i), a.blitFramebuffer(0, 0, T.width, T.height, 0, 0, T.width, T.height, a.COLOR_BUFFER_BIT, a.NEAREST);
+    }
+    for (let f = 0; f < _; f++)
+      i[f] = a[this.webGLVersion > 1 ? "COLOR_ATTACHMENT" + f : "COLOR_ATTACHMENT" + f + "_WEBGL"];
+    a.drawBuffers(i);
+  }
+  for (let f = 0; f < _; f++) {
+    const T = r.textures[f];
+    T != null && T.generateMipMaps && !t && !T.isCube && (this._bindTextureDirectly(a.TEXTURE_2D, T, !0), a.generateMipmap(a.TEXTURE_2D), this._bindTextureDirectly(a.TEXTURE_2D, null));
+  }
+  E && (r._MSAAFramebuffer && this._bindUnboundFramebuffer(r._framebuffer), E()), this._bindUnboundFramebuffer(null);
+};
+b.prototype.createMultipleRenderTarget = function(r, t, E = !0) {
+  var a;
+  let i = !1, _ = !0, f = !1, T = !1, u = 15, d = 1;
+  const R = 0, M = 3, F = !1, k = 5, q = 3553;
+  let L = new Array(), w = new Array(), U = new Array(), O = new Array(), I = new Array(), P = new Array(), p = new Array(), G = new Array();
+  const A = this._createHardwareRenderTargetWrapper(!0, !1, r);
+  t !== void 0 && (i = t.generateMipMaps === void 0 ? !1 : t.generateMipMaps, _ = t.generateDepthBuffer === void 0 ? !0 : t.generateDepthBuffer, f = t.generateStencilBuffer === void 0 ? !1 : t.generateStencilBuffer, T = t.generateDepthTexture === void 0 ? !1 : t.generateDepthTexture, d = t.textureCount || 1, t.types && (L = t.types), t.samplingModes && (w = t.samplingModes), t.useSRGBBuffers && (U = t.useSRGBBuffers), t.formats && (O = t.formats), t.targetTypes && (I = t.targetTypes), t.faceIndex && (P = t.faceIndex), t.layerIndex && (p = t.layerIndex), t.layerCounts && (G = t.layerCounts), this.webGLVersion > 1 && (t.depthTextureFormat === 13 || t.depthTextureFormat === 17 || t.depthTextureFormat === 16 || t.depthTextureFormat === 14 || t.depthTextureFormat === 18) && (u = t.depthTextureFormat));
+  const e = this._gl, H = e.createFramebuffer();
+  this._bindUnboundFramebuffer(H);
+  const m = r.width || r, o = r.height || r, D = [], S = [], X = this.webGLVersion > 1 && T && (t.depthTextureFormat === 13 || t.depthTextureFormat === 17 || t.depthTextureFormat === 18), J = this._setupFramebufferDepthAttachments(!X && f, !T && _, m, o);
+  A._framebuffer = H, A._depthStencilBuffer = J, A._generateDepthBuffer = !T && _, A._generateStencilBuffer = !X && f, A._attachments = S;
+  for (let n = 0; n < d; n++) {
+    let c = w[n] || M, h = L[n] || R, x = U[n] || F;
+    const g = O[n] || k, l = I[n] || q, V = (a = G[n]) !== null && a !== void 0 ? a : 1;
+    (h === 1 && !this._caps.textureFloatLinearFiltering || h === 2 && !this._caps.textureHalfFloatLinearFiltering) && (c = 1);
+    const v = this._getSamplingParameters(c, i);
+    h === 1 && !this._caps.textureFloat && (h = 0, Z.Warn("Float textures are not supported. Render target forced to TEXTURETYPE_UNSIGNED_BYTE type")), x = x && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU);
+    const Y = this.webGLVersion > 1, Q = e[Y ? "COLOR_ATTACHMENT" + n : "COLOR_ATTACHMENT" + n + "_WEBGL"];
+    if (S.push(Q), l === -1)
+      continue;
+    const s = new j(this, K.MultiRenderTarget);
+    D[n] = s, e.activeTexture(e["TEXTURE" + n]), e.bindTexture(l, s._hardwareTexture.underlyingResource), e.texParameteri(l, e.TEXTURE_MAG_FILTER, v.mag), e.texParameteri(l, e.TEXTURE_MIN_FILTER, v.min), e.texParameteri(l, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(l, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE);
+    const B = this._getRGBABufferInternalSizedFormat(h, g, x), C = this._getInternalFormat(g), N = this._getWebGLTextureType(h);
+    if (Y && (l === 35866 || l === 32879))
+      l === 35866 ? s.is2DArray = !0 : s.is3D = !0, s.baseDepth = s.depth = V, e.texImage3D(l, 0, B, m, o, V, 0, C, N, null);
+    else if (l === 34067) {
+      for (let y = 0; y < 6; y++)
+        e.texImage2D(e.TEXTURE_CUBE_MAP_POSITIVE_X + y, 0, B, m, o, 0, C, N, null);
+      s.isCube = !0;
+    } else
+      e.texImage2D(e.TEXTURE_2D, 0, B, m, o, 0, C, N, null);
+    i && e.generateMipmap(l), this._bindTextureDirectly(l, null), s.baseWidth = m, s.baseHeight = o, s.width = m, s.height = o, s.isReady = !0, s.samples = 1, s.generateMipMaps = i, s.samplingMode = c, s.type = h, s._useSRGBBuffer = x, s.format = g, this._internalTexturesCache.push(s);
+  }
+  if (T && this._caps.depthTextureExtension) {
+    const n = new j(this, K.Depth);
+    let c = 5, h = e.DEPTH_COMPONENT16, x = e.DEPTH_COMPONENT, g = e.UNSIGNED_SHORT, l = e.DEPTH_ATTACHMENT;
+    this.webGLVersion < 2 ? h = e.DEPTH_COMPONENT : u === 14 ? (c = 1, g = e.FLOAT, h = e.DEPTH_COMPONENT32F) : u === 18 ? (c = 0, g = e.FLOAT_32_UNSIGNED_INT_24_8_REV, h = e.DEPTH32F_STENCIL8, x = e.DEPTH_STENCIL, l = e.DEPTH_STENCIL_ATTACHMENT) : u === 16 ? (c = 0, g = e.UNSIGNED_INT, h = e.DEPTH_COMPONENT24, l = e.DEPTH_ATTACHMENT) : (u === 13 || u === 17) && (c = 12, g = e.UNSIGNED_INT_24_8, h = e.DEPTH24_STENCIL8, x = e.DEPTH_STENCIL, l = e.DEPTH_STENCIL_ATTACHMENT), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, n._hardwareTexture.underlyingResource), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texImage2D(e.TEXTURE_2D, 0, h, m, o, 0, x, g, null), e.framebufferTexture2D(e.FRAMEBUFFER, l, e.TEXTURE_2D, n._hardwareTexture.underlyingResource, 0), n.baseWidth = m, n.baseHeight = o, n.width = m, n.height = o, n.isReady = !0, n.samples = 1, n.generateMipMaps = i, n.samplingMode = 1, n.format = u, n.type = c, D[d] = n, this._internalTexturesCache.push(n);
+  }
+  return A.setTextures(D), E && e.drawBuffers(S), this._bindUnboundFramebuffer(null), A.setLayerAndFaceIndices(p, P), this.resetTextureCache(), A;
+};
+b.prototype.updateMultipleRenderTargetTextureSampleCount = function(r, t, E = !0) {
+  if (this.webGLVersion < 2 || !r || !r.texture)
+    return 1;
+  if (r.samples === t)
+    return t;
+  const a = r._attachments.length;
+  if (a === 0)
+    return 1;
+  const i = this._gl;
+  t = Math.min(t, this.getCaps().maxMSAASamples);
+  const _ = !!r._depthStencilBuffer;
+  if (_ && (i.deleteRenderbuffer(r._depthStencilBuffer), r._depthStencilBuffer = null), r._MSAAFramebuffer && (i.deleteFramebuffer(r._MSAAFramebuffer), r._MSAAFramebuffer = null), t > 1 && typeof i.renderbufferStorageMultisample == "function") {
+    const f = i.createFramebuffer();
+    if (!f)
+      throw new Error("Unable to create multi sampled framebuffer");
+    r._MSAAFramebuffer = f, this._bindUnboundFramebuffer(f);
+    const T = [];
+    for (let u = 0; u < a; u++)
+      r.textures[u]._hardwareTexture.releaseMSAARenderBuffers();
+    for (let u = 0; u < a; u++) {
+      const d = r.textures[u], R = d._hardwareTexture, M = i[this.webGLVersion > 1 ? "COLOR_ATTACHMENT" + u : "COLOR_ATTACHMENT" + u + "_WEBGL"], F = this._createRenderBuffer(d.width, d.height, t, -1, this._getRGBAMultiSampleBufferFormat(d.type, d.format), M);
+      if (!F)
+        throw new Error("Unable to create multi sampled framebuffer");
+      R.addMSAARenderBuffer(F), d.samples = t, T.push(M);
+    }
+    E && i.drawBuffers(T);
+  } else
+    this._bindUnboundFramebuffer(r._framebuffer);
+  return _ && (r._depthStencilBuffer = this._setupFramebufferDepthAttachments(r._generateStencilBuffer, r._generateDepthBuffer, r.texture.width, r.texture.height, t)), this._bindUnboundFramebuffer(null), t;
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.rawTexture.esm.js

@@ -0,0 +1,109 @@
+import { InternalTexture as F, InternalTextureSource as P } from "../../Materials/Textures/internalTexture.esm.js";
+import { Logger as D } from "../../Misc/logger.esm.js";
+import { Tools as w } from "../../Misc/tools.esm.js";
+import { ThinEngine as d } from "../thinEngine.esm.js";
+d.prototype.updateRawTexture = function(e, t, o, _, i = null, h = 0, T = !1) {
+  if (!e)
+    return;
+  const l = this._getRGBABufferInternalSizedFormat(h, o, T), n = this._getInternalFormat(o), r = this._getWebGLTextureType(h);
+  this._bindTextureDirectly(this._gl.TEXTURE_2D, e, !0), this._unpackFlipY(_ === void 0 ? !0 : !!_), this._doNotHandleContextLost || (e._bufferView = t, e.format = o, e.type = h, e.invertY = _, e._compression = i), e.width % 4 !== 0 && this._gl.pixelStorei(this._gl.UNPACK_ALIGNMENT, 1), i && t ? this._gl.compressedTexImage2D(this._gl.TEXTURE_2D, 0, this.getCaps().s3tc[i], e.width, e.height, 0, t) : this._gl.texImage2D(this._gl.TEXTURE_2D, 0, l, e.width, e.height, 0, n, r, t), e.generateMipMaps && this._gl.generateMipmap(this._gl.TEXTURE_2D), this._bindTextureDirectly(this._gl.TEXTURE_2D, null), e.isReady = !0;
+};
+d.prototype.createRawTexture = function(e, t, o, _, i, h, T, l = null, n = 0, r = 0, u = !1) {
+  const a = new F(this, P.Raw);
+  a.baseWidth = t, a.baseHeight = o, a.width = t, a.height = o, a.format = _, a.generateMipMaps = i, a.samplingMode = T, a.invertY = h, a._compression = l, a.type = n, a._useSRGBBuffer = this._getUseSRGBBuffer(u, !i), this._doNotHandleContextLost || (a._bufferView = e), this.updateRawTexture(a, e, _, h, l, n, a._useSRGBBuffer), this._bindTextureDirectly(this._gl.TEXTURE_2D, a, !0);
+  const f = this._getSamplingParameters(T, i);
+  return this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MAG_FILTER, f.mag), this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MIN_FILTER, f.min), i && this._gl.generateMipmap(this._gl.TEXTURE_2D), this._bindTextureDirectly(this._gl.TEXTURE_2D, null), this._internalTexturesCache.push(a), a;
+};
+d.prototype.createRawCubeTexture = function(e, t, o, _, i, h, T, l = null) {
+  const n = this._gl, r = new F(this, P.CubeRaw);
+  r.isCube = !0, r.format = o, r.type = _, this._doNotHandleContextLost || (r._bufferViewArray = e);
+  const u = this._getWebGLTextureType(_);
+  let a = this._getInternalFormat(o);
+  a === n.RGB && (a = n.RGBA), u === n.FLOAT && !this._caps.textureFloatLinearFiltering ? (i = !1, T = 1, D.Warn("Float texture filtering is not supported. Mipmap generation and sampling mode are forced to false and TEXTURE_NEAREST_SAMPLINGMODE, respectively.")) : u === this._gl.HALF_FLOAT_OES && !this._caps.textureHalfFloatLinearFiltering ? (i = !1, T = 1, D.Warn("Half float texture filtering is not supported. Mipmap generation and sampling mode are forced to false and TEXTURE_NEAREST_SAMPLINGMODE, respectively.")) : u === n.FLOAT && !this._caps.textureFloatRender ? (i = !1, D.Warn("Render to float textures is not supported. Mipmap generation forced to false.")) : u === n.HALF_FLOAT && !this._caps.colorBufferFloat && (i = !1, D.Warn("Render to half float textures is not supported. Mipmap generation forced to false."));
+  const f = t, s = f;
+  if (r.width = f, r.height = s, r.invertY = h, r._compression = l, !this.needPOTTextures || w.IsExponentOfTwo(r.width) && w.IsExponentOfTwo(r.height) || (i = !1), e)
+    this.updateRawCubeTexture(r, e, o, _, h, l);
+  else {
+    const g = this._getRGBABufferInternalSizedFormat(_), c = 0;
+    this._bindTextureDirectly(n.TEXTURE_CUBE_MAP, r, !0);
+    for (let R = 0; R < 6; R++)
+      l ? n.compressedTexImage2D(n.TEXTURE_CUBE_MAP_POSITIVE_X + R, c, this.getCaps().s3tc[l], r.width, r.height, 0, void 0) : n.texImage2D(n.TEXTURE_CUBE_MAP_POSITIVE_X + R, c, g, r.width, r.height, 0, a, u, null);
+    this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);
+  }
+  this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, r, !0), e && i && this._gl.generateMipmap(this._gl.TEXTURE_CUBE_MAP);
+  const U = this._getSamplingParameters(T, i);
+  return n.texParameteri(n.TEXTURE_CUBE_MAP, n.TEXTURE_MAG_FILTER, U.mag), n.texParameteri(n.TEXTURE_CUBE_MAP, n.TEXTURE_MIN_FILTER, U.min), n.texParameteri(n.TEXTURE_CUBE_MAP, n.TEXTURE_WRAP_S, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_CUBE_MAP, n.TEXTURE_WRAP_T, n.CLAMP_TO_EDGE), this._bindTextureDirectly(n.TEXTURE_CUBE_MAP, null), r.generateMipMaps = i, r.samplingMode = T, r.isReady = !0, r;
+};
+d.prototype.updateRawCubeTexture = function(e, t, o, _, i, h = null, T = 0) {
+  e._bufferViewArray = t, e.format = o, e.type = _, e.invertY = i, e._compression = h;
+  const l = this._gl, n = this._getWebGLTextureType(_);
+  let r = this._getInternalFormat(o);
+  const u = this._getRGBABufferInternalSizedFormat(_);
+  let a = !1;
+  r === l.RGB && (r = l.RGBA, a = !0), this._bindTextureDirectly(l.TEXTURE_CUBE_MAP, e, !0), this._unpackFlipY(i === void 0 ? !0 : !!i), e.width % 4 !== 0 && l.pixelStorei(l.UNPACK_ALIGNMENT, 1);
+  for (let s = 0; s < 6; s++) {
+    let E = t[s];
+    h ? l.compressedTexImage2D(l.TEXTURE_CUBE_MAP_POSITIVE_X + s, T, this.getCaps().s3tc[h], e.width, e.height, 0, E) : (a && (E = b(E, e.width, e.height, _)), l.texImage2D(l.TEXTURE_CUBE_MAP_POSITIVE_X + s, T, u, e.width, e.height, 0, r, n, E));
+  }
+  (!this.needPOTTextures || w.IsExponentOfTwo(e.width) && w.IsExponentOfTwo(e.height)) && e.generateMipMaps && T === 0 && this._gl.generateMipmap(this._gl.TEXTURE_CUBE_MAP), this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null), e.isReady = !0;
+};
+d.prototype.createRawCubeTextureFromUrl = function(e, t, o, _, i, h, T, l, n = null, r = null, u = 3, a = !1) {
+  const f = this._gl, s = this.createRawCubeTexture(null, o, _, i, !h, a, u, null);
+  t == null || t.addPendingData(s), s.url = e, s.isReady = !1, this._internalTexturesCache.push(s);
+  const E = (g, c) => {
+    t == null || t.removePendingData(s), r && g && r(g.status + " " + g.statusText, c);
+  }, U = (g) => {
+    const c = s.width, R = T(g);
+    if (R) {
+      if (l) {
+        const L = this._getWebGLTextureType(i);
+        let I = this._getInternalFormat(_);
+        const S = this._getRGBABufferInternalSizedFormat(i);
+        let C = !1;
+        I === f.RGB && (I = f.RGBA, C = !0), this._bindTextureDirectly(f.TEXTURE_CUBE_MAP, s, !0), this._unpackFlipY(!1);
+        const X = l(R);
+        for (let p = 0; p < X.length; p++) {
+          const m = c >> p;
+          for (let A = 0; A < 6; A++) {
+            let x = X[p][A];
+            C && (x = b(x, m, m, i)), f.texImage2D(A, p, S, m, m, 0, I, L, x);
+          }
+        }
+        this._bindTextureDirectly(f.TEXTURE_CUBE_MAP, null);
+      } else
+        this.updateRawCubeTexture(s, R, _, i, a);
+      s.isReady = !0, t == null || t.removePendingData(s), s.onLoadedObservable.notifyObservers(s), s.onLoadedObservable.clear(), n && n();
+    }
+  };
+  return this._loadFile(e, (g) => {
+    U(g);
+  }, void 0, t == null ? void 0 : t.offlineProvider, !0, E), s;
+};
+function b(e, t, o, _) {
+  let i, h = 1;
+  _ === 1 ? i = new Float32Array(t * o * 4) : _ === 2 ? (i = new Uint16Array(t * o * 4), h = 15360) : _ === 7 ? i = new Uint32Array(t * o * 4) : i = new Uint8Array(t * o * 4);
+  for (let T = 0; T < t; T++)
+    for (let l = 0; l < o; l++) {
+      const n = (l * t + T) * 3, r = (l * t + T) * 4;
+      i[r + 0] = e[n + 0], i[r + 1] = e[n + 1], i[r + 2] = e[n + 2], i[r + 3] = h;
+    }
+  return i;
+}
+function y(e) {
+  return function(t, o, _, i, h, T, l, n, r = null, u = 0) {
+    const a = e ? this._gl.TEXTURE_3D : this._gl.TEXTURE_2D_ARRAY, f = e ? P.Raw3D : P.Raw2DArray, s = new F(this, f);
+    s.baseWidth = o, s.baseHeight = _, s.baseDepth = i, s.width = o, s.height = _, s.depth = i, s.format = h, s.type = u, s.generateMipMaps = T, s.samplingMode = n, e ? s.is3D = !0 : s.is2DArray = !0, this._doNotHandleContextLost || (s._bufferView = t), e ? this.updateRawTexture3D(s, t, h, l, r, u) : this.updateRawTexture2DArray(s, t, h, l, r, u), this._bindTextureDirectly(a, s, !0);
+    const E = this._getSamplingParameters(n, T);
+    return this._gl.texParameteri(a, this._gl.TEXTURE_MAG_FILTER, E.mag), this._gl.texParameteri(a, this._gl.TEXTURE_MIN_FILTER, E.min), T && this._gl.generateMipmap(a), this._bindTextureDirectly(a, null), this._internalTexturesCache.push(s), s;
+  };
+}
+d.prototype.createRawTexture2DArray = y(!1);
+d.prototype.createRawTexture3D = y(!0);
+function B(e) {
+  return function(t, o, _, i, h = null, T = 0) {
+    const l = e ? this._gl.TEXTURE_3D : this._gl.TEXTURE_2D_ARRAY, n = this._getWebGLTextureType(T), r = this._getInternalFormat(_), u = this._getRGBABufferInternalSizedFormat(T, _);
+    this._bindTextureDirectly(l, t, !0), this._unpackFlipY(i === void 0 ? !0 : !!i), this._doNotHandleContextLost || (t._bufferView = o, t.format = _, t.invertY = i, t._compression = h), t.width % 4 !== 0 && this._gl.pixelStorei(this._gl.UNPACK_ALIGNMENT, 1), h && o ? this._gl.compressedTexImage3D(l, 0, this.getCaps().s3tc[h], t.width, t.height, t.depth, 0, o) : this._gl.texImage3D(l, 0, u, t.width, t.height, t.depth, 0, r, n, o), t.generateMipMaps && this._gl.generateMipmap(l), this._bindTextureDirectly(l, null), t.isReady = !0;
+  };
+}
+d.prototype.updateRawTexture2DArray = B(!1);
+d.prototype.updateRawTexture3D = B(!0);

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.readTexture.esm.js

@@ -0,0 +1,76 @@
+import { ThinEngine as m } from "../thinEngine.esm.js";
+function U(A, n, t = !1, r) {
+  switch (A) {
+    case 3: {
+      const a = n instanceof ArrayBuffer ? new Int8Array(n) : new Int8Array(n);
+      return r && a.set(new Int8Array(r)), a;
+    }
+    case 0: {
+      const a = n instanceof ArrayBuffer ? new Uint8Array(n) : new Uint8Array(n);
+      return r && a.set(new Uint8Array(r)), a;
+    }
+    case 4: {
+      const a = n instanceof ArrayBuffer ? new Int16Array(n) : new Int16Array(t ? n / 2 : n);
+      return r && a.set(new Int16Array(r)), a;
+    }
+    case 5:
+    case 8:
+    case 9:
+    case 10:
+    case 2: {
+      const a = n instanceof ArrayBuffer ? new Uint16Array(n) : new Uint16Array(t ? n / 2 : n);
+      return r && a.set(new Uint16Array(r)), a;
+    }
+    case 6: {
+      const a = n instanceof ArrayBuffer ? new Int32Array(n) : new Int32Array(t ? n / 4 : n);
+      return r && a.set(new Int32Array(r)), a;
+    }
+    case 7:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15: {
+      const a = n instanceof ArrayBuffer ? new Uint32Array(n) : new Uint32Array(t ? n / 4 : n);
+      return r && a.set(new Uint32Array(r)), a;
+    }
+    case 1: {
+      const a = n instanceof ArrayBuffer ? new Float32Array(n) : new Float32Array(t ? n / 4 : n);
+      return r && a.set(new Float32Array(r)), a;
+    }
+  }
+  const o = n instanceof ArrayBuffer ? new Uint8Array(n) : new Uint8Array(n);
+  return r && o.set(new Uint8Array(r)), o;
+}
+m.prototype._readTexturePixelsSync = function(A, n, t, r = -1, o = 0, a = null, y = !0, i = !1, l = 0, w = 0) {
+  var T, E;
+  const e = this._gl;
+  if (!e)
+    throw new Error("Engine does not have gl rendering context.");
+  if (!this._dummyFramebuffer) {
+    const F = e.createFramebuffer();
+    if (!F)
+      throw new Error("Unable to create dummy framebuffer");
+    this._dummyFramebuffer = F;
+  }
+  e.bindFramebuffer(e.FRAMEBUFFER, this._dummyFramebuffer), r > -1 ? e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_CUBE_MAP_POSITIVE_X + r, (T = A._hardwareTexture) === null || T === void 0 ? void 0 : T.underlyingResource, o) : e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, (E = A._hardwareTexture) === null || E === void 0 ? void 0 : E.underlyingResource, o);
+  let c = A.type !== void 0 ? this._getWebGLTextureType(A.type) : e.UNSIGNED_BYTE;
+  if (i)
+    a || (a = U(A.type, 4 * n * t));
+  else
+    switch (c) {
+      case e.UNSIGNED_BYTE:
+        a || (a = new Uint8Array(4 * n * t)), c = e.UNSIGNED_BYTE;
+        break;
+      default:
+        a || (a = new Float32Array(4 * n * t)), c = e.FLOAT;
+        break;
+    }
+  return y && this.flushFramebuffer(), e.readPixels(l, w, n, t, e.RGBA, c, a), e.bindFramebuffer(e.FRAMEBUFFER, this._currentFramebuffer), a;
+};
+m.prototype._readTexturePixels = function(A, n, t, r = -1, o = 0, a = null, y = !0, i = !1, l = 0, w = 0) {
+  return Promise.resolve(this._readTexturePixelsSync(A, n, t, r, o, a, y, i, l, w));
+};
+export {
+  U as allocateAndCopyTypedBuffer
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.renderTarget.esm.js

@@ -0,0 +1,69 @@
+import { InternalTextureSource as F, InternalTexture as E } from "../../Materials/Textures/internalTexture.esm.js";
+import { Logger as b } from "../../Misc/logger.esm.js";
+import { ThinEngine as m } from "../thinEngine.esm.js";
+import { WebGLRenderTargetWrapper as S } from "../WebGL/webGLRenderTargetWrapper.esm.js";
+m.prototype._createHardwareRenderTargetWrapper = function(t, f, n) {
+  const e = new S(t, f, n, this, this._gl);
+  return this._renderTargetWrapperCache.push(e), e;
+};
+m.prototype.createRenderTargetTexture = function(t, f) {
+  var n, e;
+  const i = this._createHardwareRenderTargetWrapper(!1, !1, t);
+  let a = !0, r = !1, u = !1, s, l = 1;
+  f !== void 0 && typeof f == "object" && (a = (n = f.generateDepthBuffer) !== null && n !== void 0 ? n : !0, r = !!f.generateStencilBuffer, u = !!f.noColorAttachment, s = f.colorAttachment, l = (e = f.samples) !== null && e !== void 0 ? e : 1);
+  const h = s || (u ? null : this._createInternalTexture(t, f, !0, F.RenderTarget)), o = t.width || t, c = t.height || t, T = this._currentFramebuffer, d = this._gl, _ = d.createFramebuffer();
+  return this._bindUnboundFramebuffer(_), i._depthStencilBuffer = this._setupFramebufferDepthAttachments(r, a, o, c), h && !h.is2DArray && d.framebufferTexture2D(d.FRAMEBUFFER, d.COLOR_ATTACHMENT0, d.TEXTURE_2D, h._hardwareTexture.underlyingResource, 0), this._bindUnboundFramebuffer(T), i._framebuffer = _, i._generateDepthBuffer = a, i._generateStencilBuffer = r, i.setTextures(h), this.updateRenderTargetTextureSampleCount(i, l), i;
+};
+m.prototype.createDepthStencilTexture = function(t, f, n) {
+  if (f.isCube) {
+    const e = t.width || t;
+    return this._createDepthStencilCubeTexture(e, f, n);
+  } else
+    return this._createDepthStencilTexture(t, f, n);
+};
+m.prototype._createDepthStencilTexture = function(t, f, n) {
+  const e = this._gl, i = t.layers || 0, a = i !== 0 ? e.TEXTURE_2D_ARRAY : e.TEXTURE_2D, r = new E(this, F.DepthStencil);
+  if (!this._caps.depthTextureExtension)
+    return b.Error("Depth texture is not supported by your browser or hardware."), r;
+  const u = Object.assign({ bilinearFiltering: !1, comparisonFunction: 0, generateStencil: !1 }, f);
+  if (this._bindTextureDirectly(a, r, !0), this._setupDepthStencilTexture(r, t, u.generateStencil, u.comparisonFunction === 0 ? !1 : u.bilinearFiltering, u.comparisonFunction, u.samples), u.depthTextureFormat !== void 0) {
+    if (u.depthTextureFormat !== 15 && u.depthTextureFormat !== 16 && u.depthTextureFormat !== 17 && u.depthTextureFormat !== 13 && u.depthTextureFormat !== 14 && u.depthTextureFormat !== 18)
+      return b.Error("Depth texture format is not supported."), r;
+    r.format = u.depthTextureFormat;
+  } else
+    r.format = u.generateStencil ? 13 : 16;
+  const s = r.format === 17 || r.format === 13 || r.format === 18;
+  n._depthStencilTexture = r, n._depthStencilTextureWithStencil = s;
+  let l = e.UNSIGNED_INT;
+  r.format === 15 ? l = e.UNSIGNED_SHORT : r.format === 17 || r.format === 13 ? l = e.UNSIGNED_INT_24_8 : r.format === 14 ? l = e.FLOAT : r.format === 18 && (l = e.FLOAT_32_UNSIGNED_INT_24_8_REV);
+  const h = s ? e.DEPTH_STENCIL : e.DEPTH_COMPONENT;
+  let o = h;
+  this.webGLVersion > 1 && (r.format === 15 ? o = e.DEPTH_COMPONENT16 : r.format === 16 ? o = e.DEPTH_COMPONENT24 : r.format === 17 || r.format === 13 ? o = e.DEPTH24_STENCIL8 : r.format === 14 ? o = e.DEPTH_COMPONENT32F : r.format === 18 && (o = e.DEPTH32F_STENCIL8)), r.is2DArray ? e.texImage3D(a, 0, o, r.width, r.height, i, 0, h, l, null) : e.texImage2D(a, 0, o, r.width, r.height, 0, h, l, null), this._bindTextureDirectly(a, null), this._internalTexturesCache.push(r);
+  const c = n;
+  if (c._depthStencilBuffer) {
+    const T = this._currentFramebuffer;
+    this._bindUnboundFramebuffer(c._framebuffer), e.framebufferRenderbuffer(e.FRAMEBUFFER, e.DEPTH_STENCIL_ATTACHMENT, e.RENDERBUFFER, null), e.framebufferRenderbuffer(e.FRAMEBUFFER, e.DEPTH_ATTACHMENT, e.RENDERBUFFER, null), e.framebufferRenderbuffer(e.FRAMEBUFFER, e.STENCIL_ATTACHMENT, e.RENDERBUFFER, null), this._bindUnboundFramebuffer(T), e.deleteRenderbuffer(c._depthStencilBuffer), c._depthStencilBuffer = null;
+  }
+  return r;
+};
+m.prototype.updateRenderTargetTextureSampleCount = function(t, f) {
+  if (this.webGLVersion < 2 || !t || !t.texture)
+    return 1;
+  if (t.samples === f)
+    return f;
+  const n = this._gl;
+  f = Math.min(f, this.getCaps().maxMSAASamples), t._depthStencilBuffer && (n.deleteRenderbuffer(t._depthStencilBuffer), t._depthStencilBuffer = null), t._MSAAFramebuffer && (n.deleteFramebuffer(t._MSAAFramebuffer), t._MSAAFramebuffer = null);
+  const e = t.texture._hardwareTexture;
+  if (e.releaseMSAARenderBuffers(), f > 1 && typeof n.renderbufferStorageMultisample == "function") {
+    const i = n.createFramebuffer();
+    if (!i)
+      throw new Error("Unable to create multi sampled framebuffer");
+    t._MSAAFramebuffer = i, this._bindUnboundFramebuffer(t._MSAAFramebuffer);
+    const a = this._createRenderBuffer(t.texture.width, t.texture.height, f, -1, this._getRGBAMultiSampleBufferFormat(t.texture.type), n.COLOR_ATTACHMENT0, !1);
+    if (!a)
+      throw new Error("Unable to create multi sampled framebuffer");
+    e.addMSAARenderBuffer(a);
+  } else
+    this._bindUnboundFramebuffer(t._framebuffer);
+  return t.texture.samples = f, t._samples = f, t._depthStencilBuffer = this._setupFramebufferDepthAttachments(t._generateStencilBuffer, t._generateDepthBuffer, t.texture.width, t.texture.height, f), this._bindUnboundFramebuffer(null), f;
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.renderTargetCube.esm.js

@@ -0,0 +1,15 @@
+import { InternalTexture as _, InternalTextureSource as s } from "../../Materials/Textures/internalTexture.esm.js";
+import { Logger as T } from "../../Misc/logger.esm.js";
+import { ThinEngine as E } from "../thinEngine.esm.js";
+E.prototype.createRenderTargetCubeTexture = function(a, u) {
+  const n = this._createHardwareRenderTargetWrapper(!1, !0, a), e = Object.assign({ generateMipMaps: !0, generateDepthBuffer: !0, generateStencilBuffer: !1, type: 0, samplingMode: 3, format: 5 }, u);
+  e.generateStencilBuffer = e.generateDepthBuffer && e.generateStencilBuffer, (e.type === 1 && !this._caps.textureFloatLinearFiltering || e.type === 2 && !this._caps.textureHalfFloatLinearFiltering) && (e.samplingMode = 1);
+  const t = this._gl, r = new _(this, s.RenderTarget);
+  this._bindTextureDirectly(t.TEXTURE_CUBE_MAP, r, !0);
+  const f = this._getSamplingParameters(e.samplingMode, e.generateMipMaps);
+  e.type === 1 && !this._caps.textureFloat && (e.type = 0, T.Warn("Float textures are not supported. Cube render target forced to TEXTURETYPE_UNESIGNED_BYTE type")), t.texParameteri(t.TEXTURE_CUBE_MAP, t.TEXTURE_MAG_FILTER, f.mag), t.texParameteri(t.TEXTURE_CUBE_MAP, t.TEXTURE_MIN_FILTER, f.min), t.texParameteri(t.TEXTURE_CUBE_MAP, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_CUBE_MAP, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE);
+  for (let i = 0; i < 6; i++)
+    t.texImage2D(t.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, this._getRGBABufferInternalSizedFormat(e.type, e.format), a, a, 0, this._getInternalFormat(e.format), this._getWebGLTextureType(e.type), null);
+  const p = t.createFramebuffer();
+  return this._bindUnboundFramebuffer(p), n._depthStencilBuffer = this._setupFramebufferDepthAttachments(e.generateStencilBuffer, e.generateDepthBuffer, a, a), e.generateMipMaps && t.generateMipmap(t.TEXTURE_CUBE_MAP), this._bindTextureDirectly(t.TEXTURE_CUBE_MAP, null), this._bindUnboundFramebuffer(null), n._framebuffer = p, n._generateDepthBuffer = e.generateDepthBuffer, n._generateStencilBuffer = e.generateStencilBuffer, r.width = a, r.height = a, r.isReady = !0, r.isCube = !0, r.samples = 1, r.generateMipMaps = e.generateMipMaps, r.samplingMode = e.samplingMode, r.type = e.type, r.format = e.format, this._internalTexturesCache.push(r), n.setTextures(r), n;
+};