@vived/component-abb-6700 1.0.0

package/dist/openpbrMaterial-HCU0aOca.js

@@ -0,0 +1,2880 @@
+import { a7 as se, a1 as Re, aL as ke, b4 as re, b0 as B, z as ge, bh as G, aa as H, au as De, ar as ze, aH as Xe, aB as Ye, ad as Ze, t as Ke, m as Pe, s as Ue, a8 as k, aD as Be, g as Ve, bz as $e, be as ae, y as K, bg as je, b1 as Qe, b9 as qe, al as Se, aZ as Ae, j as Je, aC as et, b8 as X, ab as ce, l as tt, v as it, u as st, o as rt, p as nt, q as at, n as ot, r as lt, J as ut, Z as ft, ao as ct, ap as ht, aq as dt, an as _t, aF as Tt, _ as he, aE as mt, av as pt, ay as Et, aA as Rt, az as gt, aw as St, ax as At, at as It, as as xt, a0 as vt, aI as Lt, $ as Ct, aG as Mt, ba as bt, a9 as Ot, bC as o, bK as d, c6 as D, bS as P, aK as Nt } from "./index-CS3Icp_r.js";
+import { b as Ft, a as Ie } from "./brdfTextureTools-DUyKBAXf.js";
+import { ThinEngine as J } from "./thinEngine-Bt9FW4dD.js";
+import "./bumpFragment-KE1_PuMl.js";
+import "./helperFunctions-CPmRxd37.js";
+import "./pbrIBLFunctions-C06z-ouZ.js";
+import "./sceneUboDeclaration-B6oxsfcj.js";
+import "./harmonicsFunctions-CtNrRfir.js";
+import "./clipPlaneVertex-eQ147Tn2.js";
+function yt(p) {
+  return class extends p {
+    constructor() {
+      super(...arguments), this.REFLECTION = !1, this.REFLECTIONMAP_3D = !1, this.REFLECTIONMAP_SPHERICAL = !1, this.REFLECTIONMAP_PLANAR = !1, this.REFLECTIONMAP_CUBIC = !1, this.USE_LOCAL_REFLECTIONMAP_CUBIC = !1, this.REFLECTIONMAP_PROJECTION = !1, this.REFLECTIONMAP_SKYBOX = !1, this.REFLECTIONMAP_EXPLICIT = !1, this.REFLECTIONMAP_EQUIRECTANGULAR = !1, this.REFLECTIONMAP_EQUIRECTANGULAR_FIXED = !1, this.REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED = !1, this.INVERTCUBICMAP = !1, this.USESPHERICALFROMREFLECTIONMAP = !1, this.USEIRRADIANCEMAP = !1, this.USE_IRRADIANCE_DOMINANT_DIRECTION = !1, this.USESPHERICALINVERTEX = !1, this.REFLECTIONMAP_OPPOSITEZ = !1, this.LODINREFLECTIONALPHA = !1, this.GAMMAREFLECTION = !1, this.RGBDREFLECTION = !1;
+    }
+  };
+}
+J.prototype.restoreSingleAttachment = function() {
+  const p = this._gl;
+  this.bindAttachments([p.BACK]);
+};
+J.prototype.restoreSingleAttachmentForRenderTarget = function() {
+  const p = this._gl;
+  this.bindAttachments([p.COLOR_ATTACHMENT0]);
+};
+J.prototype.buildTextureLayout = function(p, t = !1) {
+  const s = this._gl, e = [];
+  if (t)
+    e.push(s.BACK);
+  else
+    for (let i = 0; i < p.length; i++)
+      p[i] ? e.push(s["COLOR_ATTACHMENT" + i]) : e.push(s.NONE);
+  return e;
+};
+J.prototype.bindAttachments = function(p) {
+  this._gl.drawBuffers(p);
+};
+J.prototype.unBindMultiColorAttachmentFramebuffer = function(p, t = !1, s) {
+  this._currentRenderTarget = null, p.disableAutomaticMSAAResolve || this.resolveMultiFramebuffer(p), t || this.generateMipMapsMultiFramebuffer(p), s && (p._MSAAFramebuffer && this._bindUnboundFramebuffer(p._framebuffer), s()), this._bindUnboundFramebuffer(null);
+};
+J.prototype.createMultipleRenderTarget = function(p, t, s = !0) {
+  let e = !1, i = !0, n = !1, a = !1, f, I = 1, L = 1;
+  const h = 0, u = 3, A = !1, N = 5, x = 3553;
+  let M = [], R = [], T = [], m = [], F = [], y = [], S = [], c = [], Y = [], Z = !1;
+  const U = this._createHardwareRenderTargetWrapper(!0, !1, p);
+  t !== void 0 && (e = t.generateMipMaps === void 0 ? !1 : t.generateMipMaps, i = t.generateDepthBuffer === void 0 ? !0 : t.generateDepthBuffer, n = t.generateStencilBuffer === void 0 ? !1 : t.generateStencilBuffer, a = t.generateDepthTexture === void 0 ? !1 : t.generateDepthTexture, I = t.textureCount ?? 1, L = t.samples ?? L, M = t.types || M, R = t.samplingModes || R, T = t.useSRGBBuffers || T, m = t.formats || m, F = t.targetTypes || F, y = t.faceIndex || y, S = t.layerIndex || S, c = t.layerCounts || c, Y = t.labels || Y, Z = t.dontCreateTextures ?? !1, this.webGLVersion > 1 && (t.depthTextureFormat === 13 || t.depthTextureFormat === 17 || t.depthTextureFormat === 16 || t.depthTextureFormat === 14 || t.depthTextureFormat === 18) && (f = t.depthTextureFormat)), f === void 0 && (f = n ? 13 : 14);
+  const _ = this._gl, l = this._currentFramebuffer, ee = _.createFramebuffer();
+  this._bindUnboundFramebuffer(ee);
+  const $ = p.width ?? p, E = p.height ?? p, j = [], g = [], w = this.webGLVersion > 1 && (f === 13 || f === 17 || f === 18);
+  U.label = t?.label ?? "MultiRenderTargetWrapper", U._framebuffer = ee, U._generateDepthBuffer = a || i, U._generateStencilBuffer = a ? w : n, U._depthStencilBuffer = this._setupFramebufferDepthAttachments(U._generateStencilBuffer, U._generateDepthBuffer, $, E, 1, f), U._attachments = g;
+  for (let b = 0; b < I; b++) {
+    let Q = R[b] || u, z = M[b] || h, te = T[b] || A;
+    const q = m[b] || N, W = F[b] || x, me = c[b] ?? 1;
+    (z === 1 && !this._caps.textureFloatLinearFiltering || z === 2 && !this._caps.textureHalfFloatLinearFiltering) && (Q = 1);
+    const pe = this._getSamplingParameters(Q, e);
+    z === 1 && !this._caps.textureFloat && (z = 0, se.Warn("Float textures are not supported. Render target forced to TEXTURETYPE_UNSIGNED_BYTE type")), te = te && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU);
+    const Ee = this.webGLVersion > 1, He = _[Ee ? "COLOR_ATTACHMENT" + b : "COLOR_ATTACHMENT" + b + "_WEBGL"];
+    if (g.push(He), W === -1 || Z)
+      continue;
+    const V = new Re(
+      this,
+      6
+      /* InternalTextureSource.MultiRenderTarget */
+    );
+    j[b] = V, _.activeTexture(_["TEXTURE" + b]), _.bindTexture(W, V._hardwareTexture.underlyingResource), _.texParameteri(W, _.TEXTURE_MAG_FILTER, pe.mag), _.texParameteri(W, _.TEXTURE_MIN_FILTER, pe.min), _.texParameteri(W, _.TEXTURE_WRAP_S, _.CLAMP_TO_EDGE), _.texParameteri(W, _.TEXTURE_WRAP_T, _.CLAMP_TO_EDGE);
+    const oe = this._getRGBABufferInternalSizedFormat(z, q, te), le = this._getInternalFormat(q), ue = this._getWebGLTextureType(z);
+    if (Ee && (W === 35866 || W === 32879))
+      W === 35866 ? V.is2DArray = !0 : V.is3D = !0, V.baseDepth = V.depth = me, _.texImage3D(W, 0, oe, $, E, me, 0, le, ue, null);
+    else if (W === 34067) {
+      for (let fe = 0; fe < 6; fe++)
+        _.texImage2D(_.TEXTURE_CUBE_MAP_POSITIVE_X + fe, 0, oe, $, E, 0, le, ue, null);
+      V.isCube = !0;
+    } else
+      _.texImage2D(_.TEXTURE_2D, 0, oe, $, E, 0, le, ue, null);
+    e && _.generateMipmap(W), this._bindTextureDirectly(W, null), V.baseWidth = $, V.baseHeight = E, V.width = $, V.height = E, V.isReady = !0, V.samples = 1, V.generateMipMaps = e, V.samplingMode = Q, V.type = z, V._useSRGBBuffer = te, V.format = q, V.label = Y[b] ?? U.label + "-Texture" + b, this._internalTexturesCache.push(V);
+  }
+  if (a && this._caps.depthTextureExtension && !Z) {
+    const b = new Re(
+      this,
+      14
+      /* InternalTextureSource.Depth */
+    );
+    let Q = 5, z = _.DEPTH_COMPONENT16, te = _.DEPTH_COMPONENT, q = _.UNSIGNED_SHORT, W = _.DEPTH_ATTACHMENT;
+    this.webGLVersion < 2 ? z = _.DEPTH_COMPONENT : f === 14 ? (Q = 1, q = _.FLOAT, z = _.DEPTH_COMPONENT32F) : f === 18 ? (Q = 0, q = _.FLOAT_32_UNSIGNED_INT_24_8_REV, z = _.DEPTH32F_STENCIL8, te = _.DEPTH_STENCIL, W = _.DEPTH_STENCIL_ATTACHMENT) : f === 16 ? (Q = 0, q = _.UNSIGNED_INT, z = _.DEPTH_COMPONENT24, W = _.DEPTH_ATTACHMENT) : (f === 13 || f === 17) && (Q = 12, q = _.UNSIGNED_INT_24_8, z = _.DEPTH24_STENCIL8, te = _.DEPTH_STENCIL, W = _.DEPTH_STENCIL_ATTACHMENT), this._bindTextureDirectly(_.TEXTURE_2D, b, !0), _.texParameteri(_.TEXTURE_2D, _.TEXTURE_MAG_FILTER, _.NEAREST), _.texParameteri(_.TEXTURE_2D, _.TEXTURE_MIN_FILTER, _.NEAREST), _.texParameteri(_.TEXTURE_2D, _.TEXTURE_WRAP_S, _.CLAMP_TO_EDGE), _.texParameteri(_.TEXTURE_2D, _.TEXTURE_WRAP_T, _.CLAMP_TO_EDGE), _.texImage2D(_.TEXTURE_2D, 0, z, $, E, 0, te, q, null), _.framebufferTexture2D(_.FRAMEBUFFER, W, _.TEXTURE_2D, b._hardwareTexture.underlyingResource, 0), this._bindTextureDirectly(_.TEXTURE_2D, null), U._depthStencilTexture = b, U._depthStencilTextureWithStencil = w, b.baseWidth = $, b.baseHeight = E, b.width = $, b.height = E, b.isReady = !0, b.samples = 1, b.generateMipMaps = e, b.samplingMode = 1, b.format = f, b.type = Q, b.label = U.label + "-DepthStencil", j[I] = b, this._internalTexturesCache.push(b);
+  }
+  if (U.setTextures(j), s && _.drawBuffers(g), this._bindUnboundFramebuffer(l), U.setLayerAndFaceIndices(S, y), this.resetTextureCache(), !Z)
+    this.updateMultipleRenderTargetTextureSampleCount(U, L, s);
+  else if (L > 1) {
+    const b = _.createFramebuffer();
+    if (!b)
+      throw new Error("Unable to create multi sampled framebuffer");
+    U._samples = L, U._MSAAFramebuffer = b, I > 0 && s && (this._bindUnboundFramebuffer(b), _.drawBuffers(g), this._bindUnboundFramebuffer(l));
+  }
+  return U;
+};
+J.prototype.updateMultipleRenderTargetTextureSampleCount = function(p, t, s = !0) {
+  if (this.webGLVersion < 2 || !p)
+    return 1;
+  if (p.samples === t)
+    return t;
+  const e = this._gl;
+  t = Math.min(t, this.getCaps().maxMSAASamples), p._depthStencilBuffer && (e.deleteRenderbuffer(p._depthStencilBuffer), p._depthStencilBuffer = null), p._MSAAFramebuffer && (e.deleteFramebuffer(p._MSAAFramebuffer), p._MSAAFramebuffer = null);
+  const i = p._attachments.length;
+  for (let a = 0; a < i; a++)
+    p.textures[a]._hardwareTexture?.releaseMSAARenderBuffers();
+  if (t > 1 && typeof e.renderbufferStorageMultisample == "function") {
+    const a = e.createFramebuffer();
+    if (!a)
+      throw new Error("Unable to create multi sampled framebuffer");
+    p._MSAAFramebuffer = a, this._bindUnboundFramebuffer(a);
+    const f = [];
+    for (let I = 0; I < i; I++) {
+      const L = p.textures[I], h = L._hardwareTexture, u = e[this.webGLVersion > 1 ? "COLOR_ATTACHMENT" + I : "COLOR_ATTACHMENT" + I + "_WEBGL"], A = this._createRenderBuffer(L.width, L.height, t, -1, this._getRGBABufferInternalSizedFormat(L.type, L.format, L._useSRGBBuffer), u);
+      if (!A)
+        throw new Error("Unable to create multi sampled framebuffer");
+      h.addMSAARenderBuffer(A), L.samples = t, f.push(u);
+    }
+    s && e.drawBuffers(f);
+  } else
+    this._bindUnboundFramebuffer(p._framebuffer);
+  const n = p._depthStencilTexture ? p._depthStencilTexture.format : void 0;
+  return p._depthStencilBuffer = this._setupFramebufferDepthAttachments(p._generateStencilBuffer, p._generateDepthBuffer, p.width, p.height, t, n), this._bindUnboundFramebuffer(null), p._samples = t, t;
+};
+J.prototype.generateMipMapsMultiFramebuffer = function(p) {
+  const t = p, s = this._gl;
+  if (t.isMulti)
+    for (let e = 0; e < t._attachments.length; e++) {
+      const i = t.textures[e];
+      i?.generateMipMaps && !i?.isCube && !i?.is3D && (this._bindTextureDirectly(s.TEXTURE_2D, i, !0), s.generateMipmap(s.TEXTURE_2D), this._bindTextureDirectly(s.TEXTURE_2D, null));
+    }
+};
+J.prototype.resolveMultiFramebuffer = function(p) {
+  const t = p, s = this._gl;
+  if (!t._MSAAFramebuffer || !t.isMulti)
+    return;
+  let e = t.resolveMSAAColors ? s.COLOR_BUFFER_BIT : 0;
+  e |= t._generateDepthBuffer && t.resolveMSAADepth ? s.DEPTH_BUFFER_BIT : 0, e |= t._generateStencilBuffer && t.resolveMSAAStencil ? s.STENCIL_BUFFER_BIT : 0;
+  const i = t._attachments, n = i.length;
+  s.bindFramebuffer(s.READ_FRAMEBUFFER, t._MSAAFramebuffer), s.bindFramebuffer(s.DRAW_FRAMEBUFFER, t._framebuffer);
+  for (let a = 0; a < n; a++) {
+    const f = t.textures[a];
+    for (let I = 0; I < n; I++)
+      i[I] = s.NONE;
+    i[a] = s[this.webGLVersion > 1 ? "COLOR_ATTACHMENT" + a : "COLOR_ATTACHMENT" + a + "_WEBGL"], s.readBuffer(i[a]), s.drawBuffers(i), s.blitFramebuffer(0, 0, f.width, f.height, 0, 0, f.width, f.height, e, s.NEAREST);
+  }
+  for (let a = 0; a < n; a++)
+    i[a] = s[this.webGLVersion > 1 ? "COLOR_ATTACHMENT" + a : "COLOR_ATTACHMENT" + a + "_WEBGL"];
+  s.drawBuffers(i), s.bindFramebuffer(this._gl.FRAMEBUFFER, t._MSAAFramebuffer);
+};
+class Dt extends ke {
+  /**
+   * Get if draw buffers (render textures) are currently supported by the used hardware and browser.
+   */
+  get isSupported() {
+    return this._engine?.getCaps().drawBuffersExtension ?? !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(t) {
+    if (this._textures)
+      for (let s = 0; s < this._textures.length; s++)
+        this._textures[s].wrapU = t;
+  }
+  /**
+   * 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(t) {
+    if (this._textures)
+      for (let s = 0; s < this._textures.length; s++)
+        this._textures[s].wrapV = t;
+  }
+  /**
+   * 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 (render textures) 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(t, s, e, i, n, a) {
+    const f = n && n.generateMipMaps ? n.generateMipMaps : !1, I = n && n.generateDepthTexture ? n.generateDepthTexture : !1, L = n && n.depthTextureFormat ? n.depthTextureFormat : 15, h = !n || n.doNotChangeAspectRatio === void 0 ? !0 : n.doNotChangeAspectRatio, u = n && n.drawOnlyOnFirstAttachmentByDefault ? n.drawOnlyOnFirstAttachmentByDefault : !1;
+    if (super(t, s, i, f, h, void 0, void 0, void 0, void 0, void 0, void 0, void 0, !0), !this.isSupported) {
+      this.dispose();
+      return;
+    }
+    this._textureNames = a;
+    const A = [], N = [], x = [], M = [], R = [], T = [], m = [], F = [];
+    this._initTypes(e, A, N, x, M, R, T, m, F, n);
+    const y = !n || n.generateDepthBuffer === void 0 ? !0 : n.generateDepthBuffer, S = !n || n.generateStencilBuffer === void 0 ? !1 : n.generateStencilBuffer, c = n && n.samples ? n.samples : 1;
+    this._multiRenderTargetOptions = {
+      samplingModes: N,
+      generateMipMaps: f,
+      generateDepthBuffer: y,
+      generateStencilBuffer: S,
+      generateDepthTexture: I,
+      depthTextureFormat: L,
+      types: A,
+      textureCount: e,
+      useSRGBBuffers: x,
+      samples: c,
+      formats: M,
+      targetTypes: R,
+      faceIndex: T,
+      layerIndex: m,
+      layerCounts: F,
+      labels: a,
+      label: t
+    }, this._count = e, this._drawOnlyOnFirstAttachmentByDefault = u, e > 0 && (this._createInternalTextures(), this._createTextures(a));
+  }
+  _initTypes(t, s, e, i, n, a, f, I, L, h) {
+    for (let u = 0; u < t; u++)
+      h && h.types && h.types[u] !== void 0 ? s.push(h.types[u]) : s.push(h && h.defaultType ? h.defaultType : 0), h && h.samplingModes && h.samplingModes[u] !== void 0 ? e.push(h.samplingModes[u]) : e.push(re.BILINEAR_SAMPLINGMODE), h && h.useSRGBBuffers && h.useSRGBBuffers[u] !== void 0 ? i.push(h.useSRGBBuffers[u]) : i.push(!1), h && h.formats && h.formats[u] !== void 0 ? n.push(h.formats[u]) : n.push(5), h && h.targetTypes && h.targetTypes[u] !== void 0 ? a.push(h.targetTypes[u]) : a.push(3553), h && h.faceIndex && h.faceIndex[u] !== void 0 ? f.push(h.faceIndex[u]) : f.push(0), h && h.layerIndex && h.layerIndex[u] !== void 0 ? I.push(h.layerIndex[u]) : I.push(0), h && h.layerCounts && h.layerCounts[u] !== void 0 ? L.push(h.layerCounts[u]) : L.push(1);
+  }
+  _createInternaTextureIndexMapping() {
+    const t = {}, s = [];
+    if (!this._renderTarget)
+      return s;
+    const e = this._renderTarget.textures;
+    for (let i = 0; i < e.length; i++) {
+      const n = e[i];
+      if (!n)
+        continue;
+      const a = t[n.uniqueId];
+      a !== void 0 ? s[i] = a : t[n.uniqueId] = i;
+    }
+    return s;
+  }
+  /**
+   * @internal
+   */
+  _rebuild(t = !1, s = !1, e) {
+    if (this._count < 1 || t)
+      return;
+    const i = this._createInternaTextureIndexMapping();
+    this.releaseInternalTextures(), this._createInternalTextures(), s && (this._releaseTextures(), this._createTextures(e));
+    const n = this._renderTarget.textures;
+    for (let a = 0; a < n.length; a++) {
+      const f = this._textures[a];
+      i[a] !== void 0 && this._renderTarget.setTexture(n[i[a]], a), f._texture = n[a], f._texture && (f._noMipmap = !f._texture.useMipMaps, f._useSRGBBuffer = f._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 t = 0; t < this._textures.length; t++)
+        this._textures[t]._texture = null, this._textures[t].dispose();
+  }
+  _createTextures(t) {
+    const s = this._renderTarget.textures;
+    this._textures = [];
+    for (let e = 0; e < s.length; e++) {
+      const i = new re(null, this.getScene());
+      t?.[e] && (i.name = t[e]), i._texture = s[e], i._texture && (i._noMipmap = !i._texture.useMipMaps, i._useSRGBBuffer = i._texture._useSRGBBuffer), this._textures.push(i);
+    }
+  }
+  /**
+   * 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(t, s, e = !0) {
+    if (this.renderTarget && (s === 0 && (this._texture = t), this.renderTarget.setTexture(t, s, e), this.textures[s] || (this.textures[s] = new re(null, this.getScene()), this.textures[s].name = this._textureNames?.[s] ?? this.textures[s].name), this.textures[s]._texture = t, this.textures[s]._noMipmap = !t.useMipMaps, this.textures[s]._useSRGBBuffer = t._useSRGBBuffer, this._count = this.renderTarget.textures ? this.renderTarget.textures.length : 0, this._multiRenderTargetOptions.types && (this._multiRenderTargetOptions.types[s] = t.type), this._multiRenderTargetOptions.samplingModes && (this._multiRenderTargetOptions.samplingModes[s] = t.samplingMode), this._multiRenderTargetOptions.useSRGBBuffers && (this._multiRenderTargetOptions.useSRGBBuffers[s] = t._useSRGBBuffer), this._multiRenderTargetOptions.targetTypes && this._multiRenderTargetOptions.targetTypes[s] !== -1)) {
+      let i;
+      t.is2DArray ? i = 35866 : t.isCube ? i = 34067 : t.is3D ? i = 32879 : i = 3553, this._multiRenderTargetOptions.targetTypes[s] = i;
+    }
+  }
+  /**
+   * 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(t, s = -1, e = -1) {
+    !this.textures[t] || !this.renderTarget || (this._multiRenderTargetOptions.layerIndex && (this._multiRenderTargetOptions.layerIndex[t] = s), this._multiRenderTargetOptions.faceIndex && (this._multiRenderTargetOptions.faceIndex[t] = e), this.renderTarget.setLayerAndFaceIndex(t, s, e));
+  }
+  /**
+   * 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(t, s) {
+    this.renderTarget && (this._multiRenderTargetOptions.layerIndex = t, this._multiRenderTargetOptions.faceIndex = s, this.renderTarget.setLayerAndFaceIndices(t, s));
+  }
+  /**
+   * Define the number of samples used if MSAA is enabled.
+   */
+  get samples() {
+    return this._samples;
+  }
+  set samples(t) {
+    this._renderTarget ? this._samples = this._renderTarget.setSamples(t) : this._samples = t;
+  }
+  /**
+   * 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(t) {
+    this._processSizeParameter(t), this._rebuild(!1, 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(t, s, e) {
+    this._multiRenderTargetOptions.textureCount = t, this._count = t;
+    const i = [], n = [], a = [], f = [], I = [], L = [], h = [], u = [];
+    this._textureNames = e, this._initTypes(t, i, n, a, f, I, L, h, u, s), this._multiRenderTargetOptions.types = i, this._multiRenderTargetOptions.samplingModes = n, this._multiRenderTargetOptions.useSRGBBuffers = a, this._multiRenderTargetOptions.formats = f, this._multiRenderTargetOptions.targetTypes = I, this._multiRenderTargetOptions.faceIndex = L, this._multiRenderTargetOptions.layerIndex = h, this._multiRenderTargetOptions.layerCounts = u, this._multiRenderTargetOptions.labels = e, this._rebuild(!1, !0, e);
+  }
+  _unbindFrameBuffer(t, s) {
+    this._renderTarget && t.unBindMultiColorAttachmentFramebuffer(this._renderTarget, this.isCube, () => {
+      this.onAfterRenderObservable.notifyObservers(s);
+    });
+  }
+  /**
+   * Dispose the render targets and their associated resources
+   * @param doNotDisposeInternalTextures if set to true, internal textures won't be disposed (default: false).
+   */
+  dispose(t = !1) {
+    this._releaseTextures(), t ? this._texture = null : this.releaseInternalTextures(), super.dispose();
+  }
+  /**
+   * Release all the underlying texture used as draw buffers (render textures).
+   */
+  releaseInternalTextures() {
+    const t = this._renderTarget?.textures;
+    if (t) {
+      for (let s = t.length - 1; s >= 0; s--)
+        this._textures[s]._texture = null;
+      this._renderTarget?.dispose(), this._renderTarget = null;
+    }
+  }
+}
+const xe = "mrtFragmentDeclaration", Pt = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+layout(location=0) out vec4 glFragData[{X}];
+#endif
+`;
+B.IncludesShadersStore[xe] || (B.IncludesShadersStore[xe] = Pt);
+const ve = "sceneFragmentDeclaration", Ut = `uniform mat4 viewProjection;
+#ifdef MULTIVIEW
+uniform mat4 viewProjectionR;
+#endif
+uniform mat4 view;uniform mat4 projection;uniform vec4 vEyePosition;uniform mat4 inverseProjection;
+`;
+B.IncludesShadersStore[ve] || (B.IncludesShadersStore[ve] = Ut);
+const Le = "openpbrDielectricReflectance", Bt = `struct ReflectanceParams
+{float F0;float F90;vec3 coloredF0;vec3 coloredF90;};
+#define pbr_inline
+ReflectanceParams dielectricReflectance(
+in float insideIOR,in float outsideIOR,in vec3 specularColor,in float specularWeight
+)
+{ReflectanceParams outParams;float dielectricF0=pow((insideIOR-outsideIOR)/(insideIOR+outsideIOR),2.0);float dielectricF0_NoSpec=pow((1.0-outsideIOR)/(1.0+outsideIOR),2.0);float f90Scale=clamp(2.0*abs(insideIOR-outsideIOR),0.0,1.0);float f90Scale_NoSpec=clamp(2.0*abs(1.0-outsideIOR),0.0,1.0);
+#if (DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_OPENPBR)
+vec3 dielectricColorF90=specularColor.rgb*vec3(f90Scale);vec3 dielectricColorF90_NoSpec=specularColor.rgb*vec3(f90Scale_NoSpec);
+#else
+vec3 dielectricColorF90=vec3(f90Scale);vec3 dielectricColorF90_NoSpec=vec3(f90Scale_NoSpec);
+#endif
+#if DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_GLTF
+float maxF0=max(specularColor.r,max(specularColor.g,specularColor.b));outParams.F0=mix(dielectricF0_NoSpec,dielectricF0,specularWeight)*maxF0;
+#else
+outParams.F0=mix(dielectricF0_NoSpec,dielectricF0,specularWeight);
+#endif
+outParams.F90=mix(f90Scale_NoSpec,f90Scale,specularWeight);outParams.coloredF0=mix(vec3(dielectricF0_NoSpec),vec3(dielectricF0),specularWeight)*specularColor.rgb;outParams.coloredF90=mix(dielectricColorF90_NoSpec,dielectricColorF90,specularWeight);return outParams;}
+`;
+B.IncludesShadersStore[Le] || (B.IncludesShadersStore[Le] = Bt);
+const Ce = "openpbrGeometryInfo", Vt = `struct geometryInfoOutParams
+{float NdotV;float NdotVUnclamped;vec3 environmentBrdf;float horizonOcclusion;};struct geometryInfoAnisoOutParams
+{float NdotV;float NdotVUnclamped;vec3 environmentBrdf;float horizonOcclusion;float anisotropy;vec3 anisotropicTangent;vec3 anisotropicBitangent;mat3 TBN;};
+#define pbr_inline
+geometryInfoOutParams geometryInfo(
+in vec3 normalW,in vec3 viewDirectionW,in float roughness,in vec3 geometricNormalW
+)
+{geometryInfoOutParams outParams;outParams.NdotVUnclamped=dot(normalW,viewDirectionW);outParams.NdotV=absEps(outParams.NdotVUnclamped);
+#if defined(ENVIRONMENTBRDF)
+outParams.environmentBrdf=getBRDFLookup(outParams.NdotV,roughness);
+#else
+outParams.environmentBrdf=vec3(0.0);
+#endif
+outParams.horizonOcclusion=1.0;
+#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+#ifdef HORIZONOCCLUSION
+#if defined(GEOMETRY_NORMAL) || defined(GEOMETRY_COAT_NORMAL)
+#ifdef REFLECTIONMAP_3D
+outParams.horizonOcclusion=environmentHorizonOcclusion(-viewDirectionW,normalW,geometricNormalW);
+#endif
+#endif
+#endif
+#endif
+return outParams;}
+#define pbr_inline
+geometryInfoAnisoOutParams geometryInfoAniso(
+in vec3 normalW,in vec3 viewDirectionW,in float roughness,in vec3 geometricNormalW
+,in vec3 vAnisotropy,in mat3 TBN
+)
+{geometryInfoOutParams geoInfo=geometryInfo(normalW,viewDirectionW,roughness,geometricNormalW);geometryInfoAnisoOutParams outParams;outParams.NdotV=geoInfo.NdotV;outParams.NdotVUnclamped=geoInfo.NdotVUnclamped;outParams.environmentBrdf=geoInfo.environmentBrdf;outParams.horizonOcclusion=geoInfo.horizonOcclusion;outParams.anisotropy=vAnisotropy.b;vec3 anisotropyDirection=vec3(vAnisotropy.xy,0.);mat3 anisoTBN=mat3(normalize(TBN[0]),normalize(TBN[1]),normalize(TBN[2]));outParams.anisotropicTangent=normalize(anisoTBN*anisotropyDirection);outParams.anisotropicBitangent=normalize(cross(anisoTBN[2],outParams.anisotropicTangent));outParams.TBN=TBN;return outParams;}`;
+B.IncludesShadersStore[Ce] || (B.IncludesShadersStore[Ce] = Vt);
+const Me = "openpbrIblFunctions", Gt = `#ifdef REFLECTION
+vec3 sampleIrradiance(
+in vec3 surfaceNormal
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,in vec3 vEnvironmentIrradianceSH
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,in mat4 iblMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+#ifdef REFLECTIONMAP_3D
+,in samplerCube irradianceSampler
+#else
+,in sampler2D irradianceSampler
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,in vec3 reflectionDominantDirection
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,in sampler2D icdfSampler
+#endif
+#endif
+,in vec2 vReflectionInfos
+,in vec3 viewDirectionW
+,in float diffuseRoughness
+,in vec3 surfaceAlbedo
+) {vec3 environmentIrradiance=vec3(0.,0.,0.);
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+vec3 irradianceVector=(iblMatrix*vec4(surfaceNormal,0)).xyz;vec3 irradianceView=(iblMatrix*vec4(viewDirectionW,0)).xyz;
+#if !defined(USE_IRRADIANCE_DOMINANT_DIRECTION) && !defined(REALTIME_FILTERING)
+#if BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LAMBERT && BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LEGACY
+{float NdotV=max(dot(surfaceNormal,viewDirectionW),0.0);irradianceVector=mix(irradianceVector,irradianceView,(0.5*(1.0-NdotV))*diffuseRoughness);}
+#endif
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+irradianceVector.z*=-1.0;irradianceView.z*=-1.0;
+#endif
+#ifdef INVERTCUBICMAP
+irradianceVector.y*=-1.0;irradianceView.y*=-1.0;
+#endif
+#endif
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+environmentIrradiance=vEnvironmentIrradianceSH;
+#else
+#if defined(REALTIME_FILTERING)
+environmentIrradiance=irradiance(reflectionSampler,irradianceVector,vReflectionFilteringInfo,diffuseRoughness,surfaceAlbedo,irradianceView
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+);
+#else
+environmentIrradiance=computeEnvironmentIrradiance(irradianceVector);
+#endif
+#endif
+#elif defined(USEIRRADIANCEMAP)
+#ifdef REFLECTIONMAP_3D
+vec4 environmentIrradianceFromTexture=sampleReflection(irradianceSampler,irradianceVector);
+#else
+vec4 environmentIrradianceFromTexture=sampleReflection(irradianceSampler,reflectionCoords);
+#endif
+environmentIrradiance=environmentIrradianceFromTexture.rgb;
+#ifdef RGBDREFLECTION
+environmentIrradiance.rgb=fromRGBD(environmentIrradianceFromTexture);
+#endif
+#ifdef GAMMAREFLECTION
+environmentIrradiance.rgb=toLinearSpace(environmentIrradiance.rgb);
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+vec3 Ls=normalize(reflectionDominantDirection);float NoL=dot(irradianceVector,Ls);float NoV=dot(irradianceVector,irradianceView);vec3 diffuseRoughnessTerm=vec3(1.0);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+float LoV=dot (Ls,irradianceView);float mag=length(reflectionDominantDirection)*2.0;vec3 clampedAlbedo=clamp(surfaceAlbedo,vec3(0.1),vec3(1.0));diffuseRoughnessTerm=diffuseBRDF_EON(clampedAlbedo,diffuseRoughness,NoL,NoV,LoV)*PI;diffuseRoughnessTerm=diffuseRoughnessTerm/clampedAlbedo;diffuseRoughnessTerm=mix(vec3(1.0),diffuseRoughnessTerm,sqrt(clamp(mag*NoV,0.0,1.0)));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+vec3 H=(irradianceView+Ls)*0.5;float VoH=dot(irradianceView,H);diffuseRoughnessTerm=vec3(diffuseBRDF_Burley(NoL,NoV,VoH,diffuseRoughness)*PI);
+#endif
+environmentIrradiance=environmentIrradiance.rgb*diffuseRoughnessTerm;
+#endif
+#endif
+environmentIrradiance*=vReflectionInfos.x;return environmentIrradiance;}
+#define pbr_inline
+#ifdef REFLECTIONMAP_3D
+vec3 createReflectionCoords(
+#else
+vec2 createReflectionCoords(
+#endif
+in vec3 vPositionW
+,in vec3 normalW
+)
+{vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+vec3 reflectionCoords=reflectionVector;
+#else
+vec2 reflectionCoords=reflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+reflectionCoords/=reflectionVector.z;
+#endif
+reflectionCoords.y=1.0-reflectionCoords.y;
+#endif
+return reflectionCoords;}
+#define pbr_inline
+#define inline
+vec3 sampleRadiance(
+in float alphaG
+,in vec3 vReflectionMicrosurfaceInfos
+,in vec2 vReflectionInfos
+,in geometryInfoOutParams geoInfo
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSampler
+,const vec3 reflectionCoords
+#else
+,in sampler2D reflectionSampler
+,const vec2 reflectionCoords
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vReflectionFilteringInfo
+#endif
+)
+{vec4 environmentRadiance=vec4(0.,0.,0.,0.);
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG,geoInfo.NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+float reflectionLOD=getLinearLodFromRoughness(vReflectionMicrosurfaceInfos.x,roughness);
+#else
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG);
+#endif
+reflectionLOD=reflectionLOD*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;
+#ifdef REALTIME_FILTERING
+environmentRadiance=vec4(radiance(alphaG,reflectionSampler,reflectionCoords,vReflectionFilteringInfo),1.0);
+#else
+environmentRadiance=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);
+#endif
+#ifdef RGBDREFLECTION
+environmentRadiance.rgb=fromRGBD(environmentRadiance);
+#endif
+#ifdef GAMMAREFLECTION
+environmentRadiance.rgb=toLinearSpace(environmentRadiance.rgb);
+#endif
+environmentRadiance.rgb*=vec3(vReflectionInfos.x);return environmentRadiance.rgb;}
+#if defined(ANISOTROPIC)
+#define pbr_inline
+#define inline
+vec3 sampleRadianceAnisotropic(
+in float alphaG
+,in vec3 vReflectionMicrosurfaceInfos
+,in vec2 vReflectionInfos
+,in geometryInfoAnisoOutParams geoInfo
+,const vec3 normalW
+,const vec3 viewDirectionW
+,const vec3 positionW
+,const vec3 noise
+,bool isRefraction
+,float ior
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSampler
+#else
+,in sampler2D reflectionSampler
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vReflectionFilteringInfo
+#endif
+)
+{vec4 environmentRadiance=vec4(0.,0.,0.,0.);float alphaT=alphaG*sqrt(2.0/(1.0+(1.0-geoInfo.anisotropy)*(1.0-geoInfo.anisotropy)));float alphaB=(1.0-geoInfo.anisotropy)*alphaT;alphaG=alphaB;
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG,geoInfo.NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+float reflectionLOD=getLinearLodFromRoughness(vReflectionMicrosurfaceInfos.x,roughness);
+#else
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG);
+#endif
+reflectionLOD=reflectionLOD*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;
+#ifdef REALTIME_FILTERING
+vec3 view=(reflectionMatrix*vec4(viewDirectionW,0.0)).xyz;vec3 tangent=(reflectionMatrix*vec4(geoInfo.anisotropicTangent,0.0)).xyz;vec3 bitangent=(reflectionMatrix*vec4(geoInfo.anisotropicBitangent,0.0)).xyz;vec3 normal=(reflectionMatrix*vec4(normalW,0.0)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+view.z*=-1.0;tangent.z*=-1.0;bitangent.z*=-1.0;normal.z*=-1.0;
+#endif
+environmentRadiance =
+vec4(radianceAnisotropic(alphaT,alphaB,reflectionSampler,
+view,tangent,
+bitangent,normal,
+vReflectionFilteringInfo,noise.xy,isRefraction,ior),
+1.0);
+#else
+const int samples=16;vec4 radianceSample=vec4(0.0);vec3 reflectionCoords=vec3(0.0);float sample_weight=0.0;float total_weight=0.0;float step=1.0/float(max(samples-1,1));for (int i=0; i<samples; ++i) {float t=mix(-1.0,1.0,float(i)*step);t+=step*2.0*noise.x;sample_weight=max(1.0-abs(t),0.001);sample_weight*=sample_weight;t*=min(4.0*alphaT*geoInfo.anisotropy,1.0);vec3 bentNormal;if (t<0.0) {float blend=t+1.0;bentNormal=normalize(mix(-geoInfo.anisotropicTangent,normalW,blend));} else if (t>0.0) {float blend=t;bentNormal=normalize(mix(normalW,geoInfo.anisotropicTangent,blend));} else {bentNormal=normalW;}
+if (isRefraction) {reflectionCoords=double_refract(-viewDirectionW,bentNormal,ior);} else {reflectionCoords=reflect(-viewDirectionW,bentNormal);}
+reflectionCoords=vec3(reflectionMatrix*vec4(reflectionCoords,0));
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionCoords.z*=-1.0;
+#endif
+radianceSample=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);
+#ifdef RGBDREFLECTION
+environmentRadiance.rgb+=sample_weight*fromRGBD(radianceSample);
+#elif defined(GAMMAREFLECTION)
+environmentRadiance.rgb+=sample_weight*toLinearSpace(radianceSample.rgb);
+#else
+environmentRadiance.rgb+=sample_weight*radianceSample.rgb;
+#endif
+total_weight+=sample_weight;}
+environmentRadiance=vec4(environmentRadiance.xyz/float(total_weight),1.0);
+#endif
+environmentRadiance.rgb*=vec3(vReflectionInfos.x);return environmentRadiance.rgb;}
+#endif
+#endif
+#if defined(ENVIRONMENTBRDF)
+#define pbr_inline
+float computeDielectricIblFresnel(in ReflectanceParams reflectance,in vec3 environmentBrdf)
+{float dielectricIblFresnel=getReflectanceFromBRDFLookup(vec3(reflectance.F0),vec3(reflectance.F90),environmentBrdf).r;float dielectricECF=1.0+reflectance.F0*(1.0/environmentBrdf.y-1.0);return clamp(dielectricIblFresnel*dielectricECF,0.0,1.0);}
+#define pbr_inline
+vec3 computeConductorIblFresnel(in ReflectanceParams reflectance,in vec3 environmentBrdf)
+{
+#if (CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR) && defined(ENVIRONMENTBRDF)
+vec3 openPBRBrdf=vec3(environmentBrdf.xy,environmentBrdf.z/BRDF_Z_SCALE);vec3 b =getF82B(reflectance.coloredF0,reflectance.coloredF90);vec3 E_F82=getF82DirectionalAlbedo(reflectance.coloredF0,vec3(1.0),b,openPBRBrdf);vec3 F_avg=getF82AverageFresnel(reflectance.coloredF0,b);vec3 ECF =vec3(1.0)+F_avg*(vec3(1.0)/openPBRBrdf.y-vec3(1.0));return clamp(E_F82*ECF,vec3(0.0),vec3(1.0));
+#else
+return getReflectanceFromBRDFLookup(reflectance.coloredF0,reflectance.coloredF90,environmentBrdf);
+#endif
+}
+#endif
+`;
+B.IncludesShadersStore[Me] || (B.IncludesShadersStore[Me] = Gt);
+const be = "openpbrSubsurfaceLayerData", Wt = `float subsurface_weight=vSubsurfaceWeight;vec3 subsurface_color=vSubsurfaceColor.rgb;float subsurface_radius=vSubsurfaceRadius;vec3 subsurface_radius_scale=vSubsurfaceRadiusScale;float subsurface_scatter_anisotropy=clamp(vSubsurfaceScatterAnisotropy,-0.9999,0.9999);
+#ifdef SUBSURFACE_WEIGHT
+vec4 subsurfaceWeightFromTexture=TEXRD(subsurfaceWeightSampler,vSubsurfaceWeightUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_COLOR
+vec4 subsurfaceColorFromTexture=TEXRD(subsurfaceColorSampler,vSubsurfaceColorUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_RADIUS_SCALE
+vec4 subsurfaceRadiusScaleFromTexture=TEXRD(subsurfaceRadiusScaleSampler,vSubsurfaceRadiusScaleUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_WEIGHT
+#ifdef SUBSURFACE_WEIGHT_FROM_TEXTURE_ALPHA
+subsurface_weight*=subsurfaceWeightFromTexture.a;
+#else
+subsurface_weight*=subsurfaceWeightFromTexture.r;
+#endif
+#endif
+#ifdef SUBSURFACE_COLOR
+#ifdef SUBSURFACE_COLOR_GAMMA
+subsurface_color*=toLinearSpace(subsurfaceColorFromTexture.rgb);
+#else
+subsurface_color*=subsurfaceColorFromTexture.rgb;
+#endif
+subsurface_color*=vSubsurfaceColorInfos.y;
+#endif
+#ifdef SUBSURFACE_RADIUS_SCALE
+subsurface_radius_scale*=subsurfaceRadiusScaleFromTexture.rgb;
+#endif
+`;
+B.IncludesShadersStore[be] || (B.IncludesShadersStore[be] = Wt);
+const Oe = "openpbrTransmissionLayerData", wt = `float transmission_weight=vTransmissionWeight;vec3 transmission_color=vTransmissionColor.rgb;float transmission_depth=vTransmissionDepth;vec3 transmission_scatter=vTransmissionScatter.rgb;float transmission_scatter_anisotropy=clamp(vTransmissionScatterAnisotropy,-0.9999,0.9999);float transmission_dispersion_scale=vTransmissionDispersionScale;float transmission_dispersion_abbe_number=vTransmissionDispersionAbbeNumber;
+#ifdef TRANSMISSION_WEIGHT
+vec4 transmissionWeightFromTexture=TEXRD(transmissionWeightSampler,vTransmissionWeightUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_COLOR
+vec4 transmissionColorFromTexture=TEXRD(transmissionColorSampler,vTransmissionColorUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_DEPTH
+vec4 transmissionDepthFromTexture=TEXRD(transmissionDepthSampler,vTransmissionDepthUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_SCATTER
+vec4 transmissionScatterFromTexture=TEXRD(transmissionScatterSampler,vTransmissionScatterUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_DISPERSION_SCALE
+vec4 transmissionDispersionScaleFromTexture=TEXRD(transmissionDispersionScaleSampler,vTransmissionDispersionScaleUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_WEIGHT
+transmission_weight*=transmissionWeightFromTexture.r;
+#endif
+#ifdef TRANSMISSION_COLOR
+#ifdef TRANSMISSION_COLOR_GAMMA
+transmission_color*=toLinearSpace(transmissionColorFromTexture.rgb);
+#else
+transmission_color*=transmissionColorFromTexture.rgb;
+#endif
+transmission_color*=vTransmissionColorInfos.y;
+#endif
+#ifdef TRANSMISSION_DEPTH
+transmission_depth*=transmissionDepthFromTexture.r;
+#endif
+#ifdef TRANSMISSION_SCATTER
+transmission_scatter*=transmissionScatterFromTexture.rgb;
+#endif
+#ifdef TRANSMISSION_DISPERSION_SCALE
+transmission_dispersion_scale*=transmissionDispersionScaleFromTexture.r;
+#endif
+`;
+B.IncludesShadersStore[Oe] || (B.IncludesShadersStore[Oe] = wt);
+const de = "geometryPixelShader", Ge = `#extension GL_EXT_draw_buffers : require
+#if defined(BUMP) || !defined(NORMAL)
+#extension GL_OES_standard_derivatives : enable
+#endif
+precision highp float;
+#ifdef BUMP
+varying mat4 vWorldView;varying vec3 vNormalW;
+#else
+varying vec3 vNormalV;
+#endif
+varying vec4 vViewPos;
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+varying vec3 vPositionW;
+#endif
+#if defined(VELOCITY) || defined(VELOCITY_LINEAR)
+varying vec4 vCurrentPosition;varying vec4 vPreviousPosition;
+#endif
+#ifdef NEED_UV
+varying vec2 vUV;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;uniform vec2 vTangentSpaceParams;
+#endif
+#if defined(REFLECTIVITY)
+#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+uniform sampler2D reflectivitySampler;varying vec2 vReflectivityUV;
+#else
+#ifdef METALLIC_TEXTURE
+uniform sampler2D metallicSampler;varying vec2 vMetallicUV;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+uniform sampler2D roughnessSampler;varying vec2 vRoughnessUV;
+#endif
+#endif
+#ifdef ALBEDOTEXTURE
+varying vec2 vAlbedoUV;uniform sampler2D albedoSampler;
+#endif
+#ifdef REFLECTIVITYCOLOR
+uniform vec3 reflectivityColor;
+#endif
+#ifdef ALBEDOCOLOR
+uniform vec3 albedoColor;
+#endif
+#ifdef METALLIC
+uniform float metallic;
+#endif
+#if defined(ROUGHNESS) || defined(GLOSSINESS)
+uniform float glossiness;
+#endif
+#endif
+#if defined(ALPHATEST) && defined(NEED_UV)
+uniform sampler2D diffuseSampler;
+#endif
+#include<clipPlaneFragmentDeclaration>
+#include<mrtFragmentDeclaration>[SCENE_MRT_COUNT]
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<helperFunctions>
+#ifdef IRRADIANCE
+#include<pbrFragmentReflectionDeclaration>
+#ifdef REFLECTION
+#ifdef USEIRRADIANCEMAP
+#include<__decl__sceneFragment>
+uniform mat4 reflectionMatrix;uniform vec2 vReflectionInfos;uniform vec3 vReflectionDominantDirection;
+#include<pbrBRDFFunctions>
+#include<openpbrDielectricReflectance>
+#include<pbrIBLFunctions>
+#include<reflectionFunction>
+#include<openpbrGeometryInfo>
+#include<openpbrIblFunctions>
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+varying vec3 vEnvironmentIrradiance;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+uniform sampler2D iblShadowSampler;uniform vec2 shadowTextureSize;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+uniform float vSubsurfaceWeight;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_SAMPLERNAME_,subsurfaceWeight)
+uniform float vSubsurfaceScatterAnisotropy;uniform float vTransmissionWeight;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_SAMPLERNAME_,transmissionWeight)
+uniform float vTransmissionScatterAnisotropy;
+#endif
+#endif
+#endif
+void main() {
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (texture2D(diffuseSampler,vUV).a<0.4)
+discard;
+#endif
+vec3 normalOutput;
+#ifdef BUMP
+vec3 normalW=normalize(vNormalW);
+#include<bumpFragment>
+#ifdef NORMAL_WORLDSPACE
+normalOutput=normalW;
+#else
+normalOutput=normalize(vec3(vWorldView*vec4(normalW,0.0)));
+#endif
+#elif defined(HAS_NORMAL_ATTRIBUTE)
+normalOutput=normalize(vNormalV);
+#elif defined(POSITION)
+normalOutput=normalize(-cross(dFdx(vPositionW),dFdy(vPositionW)));
+#endif
+#ifdef ENCODE_NORMAL
+normalOutput=normalOutput*0.5+0.5;
+#endif
+#ifdef DEPTH
+gl_FragData[DEPTH_INDEX]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);
+#endif
+#ifdef NORMAL
+gl_FragData[NORMAL_INDEX]=vec4(normalOutput,1.0);
+#endif
+#ifdef SCREENSPACE_DEPTH
+gl_FragData[SCREENSPACE_DEPTH_INDEX]=vec4(gl_FragCoord.z,0.0,0.0,1.0);
+#endif
+#ifdef POSITION
+gl_FragData[POSITION_INDEX]=vec4(vPositionW,1.0);
+#endif
+#ifdef VELOCITY
+vec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;vec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;vec2 velocity=abs(a-b);velocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;gl_FragData[VELOCITY_INDEX]=vec4(velocity,0.0,1.0);
+#endif
+#ifdef VELOCITY_LINEAR
+vec2 velocity=vec2(0.5)*((vPreviousPosition.xy/vPreviousPosition.w) -
+(vCurrentPosition.xy/vCurrentPosition.w));gl_FragData[VELOCITY_LINEAR_INDEX]=vec4(velocity,0.0,1.0);
+#endif
+#ifdef REFLECTIVITY
+vec4 reflectivity=vec4(0.0,0.0,0.0,1.0);
+#ifdef METALLICWORKFLOW
+float metal=1.0;float roughness=1.0;
+#ifdef ORMTEXTURE
+metal*=texture2D(reflectivitySampler,vReflectivityUV).b;roughness*=texture2D(reflectivitySampler,vReflectivityUV).g;
+#else
+#ifdef METALLIC_TEXTURE
+metal*=texture2D(metallicSampler,vMetallicUV).r;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+roughness*=texture2D(roughnessSampler,vRoughnessUV).r;
+#endif
+#endif
+#ifdef METALLIC
+metal*=metallic;
+#endif
+#ifdef ROUGHNESS
+roughness*=(1.0-glossiness); 
+#endif
+reflectivity.a-=roughness;vec3 color=vec3(1.0);
+#ifdef ALBEDOTEXTURE
+color=texture2D(albedoSampler,vAlbedoUV).rgb;
+#ifdef GAMMAALBEDO
+color=toLinearSpace(color);
+#endif
+#endif
+#ifdef ALBEDOCOLOR
+color*=albedoColor.xyz;
+#endif
+reflectivity.rgb=mix(vec3(0.04),color,metal);
+#else
+#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+reflectivity=texture2D(reflectivitySampler,vReflectivityUV);
+#ifdef GAMMAREFLECTIVITYTEXTURE
+reflectivity.rgb=toLinearSpace(reflectivity.rgb);
+#endif
+#else 
+#ifdef REFLECTIVITYCOLOR
+reflectivity.rgb=toLinearSpace(reflectivityColor.xyz);reflectivity.a=1.0;
+#endif
+#endif
+#ifdef GLOSSINESSS
+reflectivity.a*=glossiness; 
+#endif
+#endif
+gl_FragData[REFLECTIVITY_INDEX]=reflectivity;
+#endif
+#ifdef IRRADIANCE
+vec3 irradiance=vec3(0.0);float irradiance_alpha=1.0;
+#ifdef REFLECTION
+#ifdef IRRADIANCE_SCATTER_MASK
+#ifndef BUMP
+vec2 uvOffset=vec2(0.0);
+#endif
+vec3 vSubsurfaceColor=vec3(1.0);float vSubsurfaceRadius=0.0;vec3 vSubsurfaceRadiusScale=vec3(1.0);
+#include<openpbrSubsurfaceLayerData>
+float vTransmissionDepth=1.0;vec3 vTransmissionColor=vec3(1.0);vec3 vTransmissionScatter=vec3(0.0);float vTransmissionDispersionScale=0.0;float vTransmissionDispersionAbbeNumber=0.0;
+#include<openpbrTransmissionLayerData>
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+#ifdef COLORED_IBL_SHADOWS
+vec3 iblShadowValue=texture(iblShadowSampler,gl_FragCoord.xy/shadowTextureSize).rgb;
+#else
+vec3 iblShadowValue=vec3(texture(iblShadowSampler,gl_FragCoord.xy/shadowTextureSize).r);
+#endif
+#endif
+#if defined(USEIRRADIANCEMAP)
+#ifdef IRRADIANCE_SCATTER_MASK
+float bendAmount=subsurface_weight*-min(subsurface_scatter_anisotropy,0.0);bendAmount=mix(bendAmount,-min(transmission_scatter_anisotropy,0.0),transmission_weight);vec3 viewVector=normalize(vEyePosition.xyz-vPositionW.xyz);vec3 bentNormal=mix(normalOutput,viewVector,bendAmount*dot(normalOutput,viewVector));
+#else
+vec3 bentNormal=normalOutput;
+#endif
+irradiance=sampleIrradiance(
+bentNormal
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,vEnvironmentIrradiance
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,reflectionMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+,irradianceSampler
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,vReflectionDominantDirection
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+#endif
+,vReflectionInfos
+,vViewPos.xyz
+,1.0
+,vec3(1.0)
+);
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+irradiance=vEnvironmentIrradiance;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+irradiance*=iblShadowValue;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+irradiance_alpha=min(subsurface_weight+transmission_weight,1.0);
+#endif
+#endif
+gl_FragData[IRRADIANCE_INDEX]=vec4(irradiance,irradiance_alpha);
+#endif
+}
+`;
+B.ShadersStore[de] || (B.ShadersStore[de] = Ge);
+const Ht = { name: de, shader: Ge }, kt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  geometryPixelShader: Ht
+}, Symbol.toStringTag, { value: "Module" })), Ne = "geometryVertexDeclaration", zt = "uniform mat4 viewProjection;uniform mat4 view;";
+B.IncludesShadersStore[Ne] || (B.IncludesShadersStore[Ne] = zt);
+const Fe = "geometryUboDeclaration", Xt = `#include<sceneUboDeclaration>
+`;
+B.IncludesShadersStore[Fe] || (B.IncludesShadersStore[Fe] = Xt);
+const _e = "geometryVertexShader", We = `precision highp float;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<instancesDeclaration>
+#include<__decl__geometryVertex>
+#include<clipPlaneVertexDeclaration>
+#ifdef IRRADIANCE
+#ifdef REFLECTION
+uniform mat4 reflectionMatrix;uniform vec2 vReflectionInfos;uniform vec3 vReflectionColor;
+#ifdef USESPHERICALFROMREFLECTIONMAP
+varying vec3 vEnvironmentIrradiance;
+#ifdef SPHERICAL_HARMONICS
+uniform vec3 vSphericalL00;uniform vec3 vSphericalL1_1;uniform vec3 vSphericalL10;uniform vec3 vSphericalL11;uniform vec3 vSphericalL2_2;uniform vec3 vSphericalL2_1;uniform vec3 vSphericalL20;uniform vec3 vSphericalL21;uniform vec3 vSphericalL22;
+#else
+uniform vec3 vSphericalX;uniform vec3 vSphericalY;uniform vec3 vSphericalZ;uniform vec3 vSphericalXX_ZZ;uniform vec3 vSphericalYY_ZZ;uniform vec3 vSphericalZZ;uniform vec3 vSphericalXY;uniform vec3 vSphericalYZ;uniform vec3 vSphericalZX;
+#endif
+#include<harmonicsFunctions>
+#endif
+#endif
+#endif
+attribute vec3 position;
+#ifdef HAS_NORMAL_ATTRIBUTE
+attribute vec3 normal;
+#endif
+#ifdef NEED_UV
+varying vec2 vUV;
+#ifdef ALPHATEST
+uniform mat4 diffuseMatrix;
+#endif
+#ifdef BUMP
+uniform mat4 bumpMatrix;varying vec2 vBumpUV;
+#endif
+#ifdef REFLECTIVITY
+uniform mat4 reflectivityMatrix;uniform mat4 albedoMatrix;varying vec2 vReflectivityUV;varying vec2 vAlbedoUV;
+#endif
+#ifdef METALLIC_TEXTURE
+varying vec2 vMetallicUV;uniform mat4 metallicMatrix;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+varying vec2 vRoughnessUV;uniform mat4 roughnessMatrix;
+#endif
+#ifdef SUBSURFACE_WEIGHT
+varying vec2 vSubsurfaceWeightUV;uniform mat4 subsurfaceWeightMatrix;
+#endif
+#ifdef TRANSMISSION_WEIGHT
+varying vec2 vTransmissionWeightUV;uniform mat4 transmissionWeightMatrix;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#endif
+#ifdef BUMP
+varying mat4 vWorldView;
+#endif
+#ifdef BUMP
+varying vec3 vNormalW;
+#else
+varying vec3 vNormalV;
+#endif
+varying vec4 vViewPos;
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+varying vec3 vPositionW;
+#endif
+#if defined(VELOCITY) || defined(VELOCITY_LINEAR)
+uniform mat4 previousViewProjection;varying vec4 vCurrentPosition;varying vec4 vPreviousPosition;
+#endif
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void)
+{vec3 positionUpdated=position;
+#ifdef HAS_NORMAL_ATTRIBUTE
+vec3 normalUpdated=normal;
+#else
+vec3 normalUpdated=vec3(0.0,0.0,0.0);
+#endif
+#ifdef UV1
+vec2 uvUpdated=uv;
+#endif
+#ifdef UV2
+vec2 uv2Updated=uv2;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#if (defined(VELOCITY) || defined(VELOCITY_LINEAR)) && !defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+vec4 worldPos=vec4(finalWorld*vec4(positionUpdated,1.0));
+#ifdef BUMP
+vWorldView=view*finalWorld;mat3 normalWorld=mat3(finalWorld);vNormalW=normalize(normalWorld*normalUpdated);
+#else
+#ifdef NORMAL_WORLDSPACE
+vNormalV=normalize(vec3(finalWorld*vec4(normalUpdated,0.0)));
+#else
+vNormalV=normalize(vec3((view*finalWorld)*vec4(normalUpdated,0.0)));
+#endif
+#endif
+vViewPos=view*worldPos;
+#if (defined(VELOCITY) || defined(VELOCITY_LINEAR)) && defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+#if NUM_BONE_INFLUENCERS>0
+mat4 previousInfluence;previousInfluence=mPreviousBones[int(matricesIndices[0])]*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=mPreviousBones[int(matricesIndices[1])]*matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=mPreviousBones[int(matricesIndices[2])]*matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=mPreviousBones[int(matricesIndices[3])]*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];
+#endif
+vPreviousPosition=previousViewProjection*finalPreviousWorld*previousInfluence*vec4(positionUpdated,1.0);
+#else
+vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#endif
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+vPositionW=worldPos.xyz/worldPos.w;
+#endif
+gl_Position=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+#include<clipPlaneVertex>
+#ifdef NEED_UV
+#ifdef UV1
+#if defined(ALPHATEST) && defined(ALPHATEST_UV1)
+vUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));
+#else
+vUV=uvUpdated;
+#endif
+#ifdef BUMP_UV1
+vBumpUV=vec2(bumpMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef REFLECTIVITY_UV1
+vReflectivityUV=vec2(reflectivityMatrix*vec4(uvUpdated,1.0,0.0));
+#else
+#ifdef METALLIC_UV1
+vMetallicUV=vec2(metallicMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef ROUGHNESS_UV1
+vRoughnessUV=vec2(roughnessMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#endif
+#ifdef ALBEDO_UV1
+vAlbedoUV=vec2(albedoMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_COLOR_UV1
+vSubsurfaceColorUV=vec2(subsurfaceColorMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_WEIGHT_UV1
+vSubsurfaceWeightUV=vec2(subsurfaceWeightMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#endif
+#ifdef UV2
+#if defined(ALPHATEST) && defined(ALPHATEST_UV2)
+vUV=vec2(diffuseMatrix*vec4(uv2Updated,1.0,0.0));
+#else
+vUV=uv2Updated;
+#endif
+#ifdef BUMP_UV2
+vBumpUV=vec2(bumpMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef REFLECTIVITY_UV2
+vReflectivityUV=vec2(reflectivityMatrix*vec4(uv2Updated,1.0,0.0));
+#else
+#ifdef METALLIC_UV2
+vMetallicUV=vec2(metallicMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef ROUGHNESS_UV2
+vRoughnessUV=vec2(roughnessMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#endif
+#ifdef ALBEDO_UV2
+vAlbedoUV=vec2(albedoMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_COLOR_UV2
+vSubsurfaceColorUV=vec2(subsurfaceColorMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_WEIGHT_UV2
+vSubsurfaceWeightUV=vec2(subsurfaceWeightMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#endif
+#endif
+#include<bumpVertex>
+#ifdef IRRADIANCE
+#ifdef REFLECTION
+#ifdef USESPHERICALFROMREFLECTIONMAP
+vec3 reflectionVector=vec3(reflectionMatrix*vec4(normalUpdated,0.0)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+vEnvironmentIrradiance=computeEnvironmentIrradiance(reflectionVector)*vReflectionInfos.x;
+#endif
+#endif
+#endif
+}
+`;
+B.ShadersStore[_e] || (B.ShadersStore[_e] = We);
+const Yt = { name: _e, shader: We }, Zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  geometryVertexShader: Yt
+}, Symbol.toStringTag, { value: "Module" })), we = [
+  "diffuseSampler",
+  "bumpSampler",
+  "reflectivitySampler",
+  "albedoSampler",
+  "morphTargets",
+  "boneSampler",
+  "transmissionWeightSampler",
+  "subsurfaceWeightSampler",
+  "iblShadowSampler"
+], Te = [
+  "world",
+  "mBones",
+  "viewProjection",
+  "diffuseMatrix",
+  "view",
+  "previousWorld",
+  "previousViewProjection",
+  "mPreviousBones",
+  "bumpMatrix",
+  "reflectivityMatrix",
+  "albedoMatrix",
+  "reflectivityColor",
+  "albedoColor",
+  "reflectionMatrix",
+  "vTransmissionWeight",
+  "vSubsurfaceWeight",
+  "vEyePosition",
+  "vTransmissionScatterAnisotropy",
+  "vSubsurfaceScatterAnisotropy",
+  "shadowTextureSize",
+  "metallic",
+  "glossiness",
+  "vTangentSpaceParams",
+  "vBumpInfos",
+  "morphTargetInfluences",
+  "morphTargetCount",
+  "morphTargetTextureInfo",
+  "morphTargetTextureIndices",
+  "boneTextureInfo"
+];
+Be(Te, we, !0);
+Ve(Te);
+class C {
+  /**
+   * Gets a boolean indicating if normals are encoded in the [0,1] range in the render target. If true, you should do `normal = normal_rt * 2.0 - 1.0` to get the right normal
+   */
+  get normalsAreUnsigned() {
+    return this._normalsAreUnsigned;
+  }
+  /**
+   * @internal
+   * Sets up internal structures to share outputs with PrePassRenderer
+   * This method should only be called by the PrePassRenderer itself
+   */
+  _linkPrePassRenderer(t) {
+    this._linkedWithPrePass = !0, this._prePassRenderer = t, this._multiRenderTarget && (this._multiRenderTarget.onClearObservable.clear(), this._multiRenderTarget.onClearObservable.add(() => {
+    }));
+  }
+  /**
+   * @internal
+   * Separates internal structures from PrePassRenderer so the geometry buffer can now operate by itself.
+   * This method should only be called by the PrePassRenderer itself
+   */
+  _unlinkPrePassRenderer() {
+    this._linkedWithPrePass = !1, this._createRenderTargets();
+  }
+  /**
+   * @internal
+   * Resets the geometry buffer layout
+   */
+  _resetLayout() {
+    this._enableDepth = !0, this._enableNormal = !0, this._enablePosition = !1, this._enableReflectivity = !1, this._enableVelocity = !1, this._enableVelocityLinear = !1, this._enableScreenspaceDepth = !1, this._enableIrradiance = !1, this._attachmentsFromPrePass = [];
+  }
+  /**
+   * @internal
+   * Replaces a texture in the geometry buffer renderer
+   * Useful when linking textures of the prepass renderer
+   */
+  _forceTextureType(t, s) {
+    t === C.POSITION_TEXTURE_TYPE ? (this._positionIndex = s, this._enablePosition = !0) : t === C.VELOCITY_TEXTURE_TYPE ? (this._velocityIndex = s, this._enableVelocity = !0) : t === C.VELOCITY_LINEAR_TEXTURE_TYPE ? (this._velocityLinearIndex = s, this._enableVelocityLinear = !0) : t === C.REFLECTIVITY_TEXTURE_TYPE ? (this._reflectivityIndex = s, this._enableReflectivity = !0) : t === C.DEPTH_TEXTURE_TYPE ? (this._depthIndex = s, this._enableDepth = !0) : t === C.NORMAL_TEXTURE_TYPE ? (this._normalIndex = s, this._enableNormal = !0) : t === C.SCREENSPACE_DEPTH_TEXTURE_TYPE ? (this._screenspaceDepthIndex = s, this._enableScreenspaceDepth = !0) : t === C.IRRADIANCE_TEXTURE_TYPE && (this._irradianceIndex = s, this._enableIrradiance = !0);
+  }
+  /**
+   * @internal
+   * Sets texture attachments
+   * Useful when linking textures of the prepass renderer
+   */
+  _setAttachments(t) {
+    this._attachmentsFromPrePass = t;
+  }
+  /**
+   * @internal
+   * Replaces the first texture which is hard coded as a depth texture in the geometry buffer
+   * Useful when linking textures of the prepass renderer
+   */
+  _linkInternalTexture(t) {
+    this._multiRenderTarget.setInternalTexture(t, 0, !1);
+  }
+  /**
+   * Gets the render list (meshes to be rendered) used in the G buffer.
+   */
+  get renderList() {
+    return this._multiRenderTarget.renderList;
+  }
+  /**
+   * Set the render list (meshes to be rendered) used in the G buffer.
+   */
+  set renderList(t) {
+    this._multiRenderTarget.renderList = t;
+  }
+  /**
+   * Gets whether or not G buffer are supported by the running hardware.
+   * This requires draw buffer supports
+   */
+  get isSupported() {
+    return this._multiRenderTarget.isSupported;
+  }
+  /**
+   * Returns the index of the given texture type in the G-Buffer textures array
+   * @param textureType The texture type constant. For example GeometryBufferRenderer.POSITION_TEXTURE_INDEX
+   * @returns the index of the given texture type in the G-Buffer textures array
+   */
+  getTextureIndex(t) {
+    switch (t) {
+      case C.POSITION_TEXTURE_TYPE:
+        return this._positionIndex;
+      case C.VELOCITY_TEXTURE_TYPE:
+        return this._velocityIndex;
+      case C.VELOCITY_LINEAR_TEXTURE_TYPE:
+        return this._velocityLinearIndex;
+      case C.REFLECTIVITY_TEXTURE_TYPE:
+        return this._reflectivityIndex;
+      case C.DEPTH_TEXTURE_TYPE:
+        return this._depthIndex;
+      case C.NORMAL_TEXTURE_TYPE:
+        return this._normalIndex;
+      case C.SCREENSPACE_DEPTH_TEXTURE_TYPE:
+        return this._screenspaceDepthIndex;
+      case C.IRRADIANCE_TEXTURE_TYPE:
+        return this._irradianceIndex;
+      default:
+        return -1;
+    }
+  }
+  /**
+   * @returns a boolean indicating if object's depths are enabled for the G buffer.
+   */
+  get enableDepth() {
+    return this._enableDepth;
+  }
+  /**
+   * Sets whether or not object's depths are enabled for the G buffer.
+   */
+  set enableDepth(t) {
+    this._enableDepth = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * @returns a boolean indicating if object's normals are enabled for the G buffer.
+   */
+  get enableNormal() {
+    return this._enableNormal;
+  }
+  /**
+   * Sets whether or not object's normals are enabled for the G buffer.
+   */
+  set enableNormal(t) {
+    this._enableNormal = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * @returns a boolean indicating if objects positions are enabled for the G buffer.
+   */
+  get enablePosition() {
+    return this._enablePosition;
+  }
+  /**
+   * Sets whether or not objects positions are enabled for the G buffer.
+   */
+  set enablePosition(t) {
+    this._enablePosition = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * @returns a boolean indicating if objects velocities are enabled for the G buffer.
+   */
+  get enableVelocity() {
+    return this._enableVelocity;
+  }
+  /**
+   * Sets whether or not objects velocities are enabled for the G buffer.
+   */
+  set enableVelocity(t) {
+    this._enableVelocity = t, t || (this._previousTransformationMatrices = {}), this._linkedWithPrePass || (this.dispose(), this._createRenderTargets()), this._scene.needsPreviousWorldMatrices = t;
+  }
+  /**
+   * @returns a boolean indicating if object's linear velocities are enabled for the G buffer.
+   */
+  get enableVelocityLinear() {
+    return this._enableVelocityLinear;
+  }
+  /**
+   * Sets whether or not object's linear velocities are enabled for the G buffer.
+   */
+  set enableVelocityLinear(t) {
+    this._enableVelocityLinear = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * Gets a boolean indicating if objects reflectivity are enabled in the G buffer.
+   */
+  get enableReflectivity() {
+    return this._enableReflectivity;
+  }
+  /**
+   * Sets whether or not objects reflectivity are enabled for the G buffer.
+   * For Metallic-Roughness workflow with ORM texture, we assume that ORM texture is defined according to the default layout:
+   * pbr.useRoughnessFromMetallicTextureAlpha = false;
+   * pbr.useRoughnessFromMetallicTextureGreen = true;
+   * pbr.useMetallnessFromMetallicTextureBlue = true;
+   */
+  set enableReflectivity(t) {
+    this._enableReflectivity = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * Sets whether or not objects screenspace depth are enabled for the G buffer.
+   */
+  get enableScreenspaceDepth() {
+    return this._enableScreenspaceDepth;
+  }
+  set enableScreenspaceDepth(t) {
+    this._enableScreenspaceDepth = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * Gets a boolean indicating if objects irradiance are enabled in the G buffer.
+   */
+  get enableIrradiance() {
+    return this._enableIrradiance;
+  }
+  /**
+   * Sets whether or not objects irradiance are enabled for the G buffer.
+   */
+  set enableIrradiance(t) {
+    this._enableIrradiance = t, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * Gets the scene associated with the buffer.
+   */
+  get scene() {
+    return this._scene;
+  }
+  /**
+   * Gets the ratio used by the buffer during its creation.
+   * How big is the buffer related to the main canvas.
+   */
+  get ratio() {
+    return typeof this._ratioOrDimensions == "object" ? 1 : this._ratioOrDimensions;
+  }
+  /**
+   * Gets the shader language used in this material.
+   */
+  get shaderLanguage() {
+    return this._shaderLanguage;
+  }
+  /**
+   * Creates a new G Buffer for the scene
+   * @param scene The scene the buffer belongs to
+   * @param ratioOrDimensions How big is the buffer related to the main canvas (default: 1). You can also directly pass a width and height for the generated textures
+   * @param depthFormat Format of the depth texture (default: 15)
+   * @param textureTypesAndFormats The types, formats and optional sampling modes of textures to create as render targets.
+   * If not provided, all textures will be RGBA and float or half float, depending on the engine capabilities.
+   */
+  constructor(t, s = 1, e = 15, i) {
+    this._previousTransformationMatrices = {}, this._previousBonesTransformationMatrices = {}, this.excludedSkinnedMeshesFromVelocity = [], this.renderTransparentMeshes = !0, this.generateNormalsInWorldSpace = !1, this._normalsAreUnsigned = !1, this._resizeObserver = null, this._enableDepth = !0, this._enableNormal = !0, this._enablePosition = !1, this._enableVelocity = !1, this._enableVelocityLinear = !1, this._enableReflectivity = !1, this._enableScreenspaceDepth = !1, this._enableIrradiance = !1, this._clearColor = new ge(0, 0, 0, 0), this._clearDepthColor = new ge(0, 0, 0, 1), this._positionIndex = -1, this._velocityIndex = -1, this._velocityLinearIndex = -1, this._reflectivityIndex = -1, this._depthIndex = -1, this._normalIndex = -1, this._screenspaceDepthIndex = -1, this._irradianceIndex = -1, this._linkedWithPrePass = !1, this.generateIrradianceWithScatterMask = !1, this.useSpecificClearForDepthTexture = !1, this._shaderLanguage = 0, this._shadersLoaded = !1, this._scene = t, this._ratioOrDimensions = s, this._useUbo = t.getEngine().supportsUniformBuffers, this._depthFormat = e, this._textureTypesAndFormats = i || {}, this._initShaderSourceAsync(), C._SceneComponentInitialization(this._scene), this._createRenderTargets();
+  }
+  async _initShaderSourceAsync() {
+    this._scene.getEngine().isWebGPU && !C.ForceGLSL ? (this._shaderLanguage = 1, await Promise.all([import("./geometry.vertex-DskQ5b8j.js"), import("./geometry.fragment-Bsis3UG2.js")])) : await Promise.all([Promise.resolve().then(() => Zt), Promise.resolve().then(() => kt)]), this._shadersLoaded = !0;
+  }
+  /**
+   * Checks whether everything is ready to render a submesh to the G buffer.
+   * @param subMesh the submesh to check readiness for
+   * @param useInstances is the mesh drawn using instance or not
+   * @returns true if ready otherwise false
+   */
+  isReady(t, s) {
+    if (!this._shadersLoaded)
+      return !1;
+    const e = t.getMaterial();
+    if (e && e.disableDepthWrite)
+      return !1;
+    const i = [], n = [G.PositionKind], a = t.getMesh();
+    a.isVerticesDataPresent(G.NormalKind) && (i.push("#define HAS_NORMAL_ATTRIBUTE"), n.push(G.NormalKind));
+    let I = !1, L = !1;
+    const h = !1;
+    if (e) {
+      let R = !1;
+      if (e.needAlphaTestingForMesh(a) && e.getAlphaTestTexture() && (i.push("#define ALPHATEST"), i.push(`#define ALPHATEST_UV${e.getAlphaTestTexture().coordinatesIndex + 1}`), R = !0), (e.bumpTexture || e.normalTexture || e.geometryNormalTexture) && H.BumpTextureEnabled) {
+        const T = e.bumpTexture || e.normalTexture || e.geometryNormalTexture;
+        i.push("#define BUMP"), i.push(`#define BUMP_UV${T.coordinatesIndex + 1}`), R = !0;
+      }
+      if (this._enableReflectivity) {
+        let T = !1;
+        if (e.getClassName() === "PBRMetallicRoughnessMaterial")
+          e.metallicRoughnessTexture && (i.push("#define ORMTEXTURE"), i.push(`#define REFLECTIVITY_UV${e.metallicRoughnessTexture.coordinatesIndex + 1}`), i.push("#define METALLICWORKFLOW"), R = !0, T = !0), e.metallic != null && (i.push("#define METALLIC"), i.push("#define METALLICWORKFLOW"), T = !0), e.roughness != null && (i.push("#define ROUGHNESS"), i.push("#define METALLICWORKFLOW"), T = !0), T && (e.baseTexture && (i.push("#define ALBEDOTEXTURE"), i.push(`#define ALBEDO_UV${e.baseTexture.coordinatesIndex + 1}`), e.baseTexture.gammaSpace && i.push("#define GAMMAALBEDO"), R = !0), e.baseColor && i.push("#define ALBEDOCOLOR"));
+        else if (e.getClassName() === "PBRSpecularGlossinessMaterial")
+          e.specularGlossinessTexture ? (i.push("#define SPECULARGLOSSINESSTEXTURE"), i.push(`#define REFLECTIVITY_UV${e.specularGlossinessTexture.coordinatesIndex + 1}`), R = !0, e.specularGlossinessTexture.gammaSpace && i.push("#define GAMMAREFLECTIVITYTEXTURE")) : e.specularColor && i.push("#define REFLECTIVITYCOLOR"), e.glossiness != null && i.push("#define GLOSSINESS");
+        else if (e.getClassName() === "PBRMaterial")
+          e.metallicTexture && (i.push("#define ORMTEXTURE"), i.push(`#define REFLECTIVITY_UV${e.metallicTexture.coordinatesIndex + 1}`), i.push("#define METALLICWORKFLOW"), R = !0, T = !0), e.metallic != null && (i.push("#define METALLIC"), i.push("#define METALLICWORKFLOW"), T = !0), e.roughness != null && (i.push("#define ROUGHNESS"), i.push("#define METALLICWORKFLOW"), T = !0), T ? (e.albedoTexture && (i.push("#define ALBEDOTEXTURE"), i.push(`#define ALBEDO_UV${e.albedoTexture.coordinatesIndex + 1}`), e.albedoTexture.gammaSpace && i.push("#define GAMMAALBEDO"), R = !0), e.albedoColor && i.push("#define ALBEDOCOLOR")) : (e.reflectivityTexture ? (i.push("#define SPECULARGLOSSINESSTEXTURE"), i.push(`#define REFLECTIVITY_UV${e.reflectivityTexture.coordinatesIndex + 1}`), e.reflectivityTexture.gammaSpace && i.push("#define GAMMAREFLECTIVITYTEXTURE"), R = !0) : e.reflectivityColor && i.push("#define REFLECTIVITYCOLOR"), e.microSurface != null && i.push("#define GLOSSINESS"));
+        else if (e.getClassName() === "StandardMaterial")
+          e.specularTexture && (i.push("#define REFLECTIVITYTEXTURE"), i.push(`#define REFLECTIVITY_UV${e.specularTexture.coordinatesIndex + 1}`), e.specularTexture.gammaSpace && i.push("#define GAMMAREFLECTIVITYTEXTURE"), R = !0), e.specularColor && i.push("#define REFLECTIVITYCOLOR");
+        else if (e.getClassName() === "OpenPBRMaterial") {
+          const m = e;
+          i.push("#define METALLIC"), i.push("#define ROUGHNESS"), m._useRoughnessFromMetallicTextureGreen && m.baseMetalnessTexture ? (i.push("#define ORMTEXTURE"), i.push(`#define REFLECTIVITY_UV${m.baseMetalnessTexture.coordinatesIndex + 1}`), R = !0) : m.baseMetalnessTexture ? (i.push("#define METALLIC_TEXTURE"), i.push(`#define METALLIC_UV${m.baseMetalnessTexture.coordinatesIndex + 1}`), R = !0) : m.specularRoughnessTexture && (i.push("#define ROUGHNESS_TEXTURE"), i.push(`#define ROUGHNESS_UV${m.specularRoughnessTexture.coordinatesIndex + 1}`), R = !0), m.baseColorTexture && (i.push("#define ALBEDOTEXTURE"), i.push(`#define ALBEDO_UV${m.baseColorTexture.coordinatesIndex + 1}`), m.baseColorTexture.gammaSpace && i.push("#define GAMMAALBEDO"), R = !0), m.baseColor && i.push("#define ALBEDOCOLOR");
+        }
+      }
+      if (this._enableIrradiance && this.generateIrradianceWithScatterMask && (i.push("#define IRRADIANCE_SCATTER_MASK"), e.getClassName() === "OpenPBRMaterial")) {
+        const T = e;
+        T.subsurfaceWeight > 0 && T.subsurfaceWeightTexture && (i.push("#define SUBSURFACE_WEIGHT"), i.push(`#define SUBSURFACEWEIGHT_UV${T.subsurfaceWeightTexture.coordinatesIndex + 1}`), R = !0), T.transmissionWeight > 0 && T.transmissionWeightTexture && (i.push("#define TRANSMISSION_WEIGHT"), i.push(`#define TRANSMISSIONWEIGHT_UV${T.transmissionWeightTexture.coordinatesIndex + 1}`), R = !0);
+      }
+      R && (i.push("#define NEED_UV"), a.isVerticesDataPresent(G.UVKind) && (n.push(G.UVKind), i.push("#define UV1"), I = !0), a.isVerticesDataPresent(G.UV2Kind) && (n.push(G.UV2Kind), i.push("#define UV2"), L = !0));
+    }
+    if (this._enableDepth && (i.push("#define DEPTH"), i.push("#define DEPTH_INDEX " + this._depthIndex)), this._enableNormal && (i.push("#define NORMAL"), i.push("#define NORMAL_INDEX " + this._normalIndex)), this._enablePosition && (i.push("#define POSITION"), i.push("#define POSITION_INDEX " + this._positionIndex)), this._enableVelocity && (i.push("#define VELOCITY"), i.push("#define VELOCITY_INDEX " + this._velocityIndex), this.excludedSkinnedMeshesFromVelocity.indexOf(a) === -1 && i.push("#define BONES_VELOCITY_ENABLED")), this._enableVelocityLinear && (i.push("#define VELOCITY_LINEAR"), i.push("#define VELOCITY_LINEAR_INDEX " + this._velocityLinearIndex), this.excludedSkinnedMeshesFromVelocity.indexOf(a) === -1 && i.push("#define BONES_VELOCITY_ENABLED")), this._enableReflectivity && (i.push("#define REFLECTIVITY"), i.push("#define REFLECTIVITY_INDEX " + this._reflectivityIndex)), this._enableScreenspaceDepth && this._screenspaceDepthIndex !== -1 && (i.push("#define SCREENSPACE_DEPTH_INDEX " + this._screenspaceDepthIndex), i.push("#define SCREENSPACE_DEPTH")), this._enableIrradiance && this._irradianceIndex !== -1) {
+      i.push("#define IRRADIANCE_INDEX " + this._irradianceIndex), i.push("#define IRRADIANCE");
+      const R = this._scene;
+      if (R.environmentTexture) {
+        const T = {};
+        let m = !1, F = 0;
+        (e.getClassName() === "OpenPBRMaterial" || e.getClassName() === "StandardMaterial" || e.getClassName() === "PBRMetallicRoughnessMaterial" || e.getClassName() === "PBRSpecularGlossinessMaterial" || e.getClassName() === "PBRMaterial") && (m = !!e.realtimeFiltering, F = e.realtimeFilteringQuality || 0), De(R, R.environmentTexture, T, m, F, !0);
+        for (const S in T)
+          T[S] && i.push("#define " + S);
+        T.USEIRRADIANCEMAP || i.push("#define SPHERICAL_HARMONICS");
+        const y = R.postProcessRenderPipelineManager.supportedPipelines.find((S) => S.getClassName() === "IBLShadowsRenderPipeline");
+        if (y) {
+          const S = y;
+          S._getAccumulatedTexture() && (i.push("#define IBL_SHADOW_TEXTURE"), S.coloredShadows && i.push("#define COLORED_IBL_SHADOWS"));
+        }
+      }
+    }
+    this.generateNormalsInWorldSpace && i.push("#define NORMAL_WORLDSPACE"), this._normalsAreUnsigned && i.push("#define ENCODE_NORMAL"), a.useBones && a.computeBonesUsingShaders && a.skeleton ? (n.push(G.MatricesIndicesKind), n.push(G.MatricesWeightsKind), a.numBoneInfluencers > 4 && (n.push(G.MatricesIndicesExtraKind), n.push(G.MatricesWeightsExtraKind)), i.push("#define NUM_BONE_INFLUENCERS " + a.numBoneInfluencers), i.push("#define BONETEXTURE " + a.skeleton.isUsingTextureForMatrices), i.push("#define BonesPerMesh " + (a.skeleton.bones.length + 1))) : (i.push("#define NUM_BONE_INFLUENCERS 0"), i.push("#define BONETEXTURE false"), i.push("#define BonesPerMesh 0"));
+    const u = a.morphTargetManager ? ze(
+      a.morphTargetManager,
+      i,
+      n,
+      a,
+      !0,
+      // usePositionMorph
+      !0,
+      // useNormalMorph
+      !1,
+      // useTangentMorph
+      I,
+      // useUVMorph
+      L,
+      // useUV2Morph
+      h
+      // useColorMorph
+    ) : 0;
+    s && (i.push("#define INSTANCES"), Xe(n, this._enableVelocity || this._enableVelocityLinear), t.getRenderingMesh().hasThinInstances && i.push("#define THIN_INSTANCES")), this._linkedWithPrePass ? i.push("#define SCENE_MRT_COUNT " + this._attachmentsFromPrePass.length) : i.push("#define SCENE_MRT_COUNT " + this._multiRenderTarget.textures.length), Ye(e, this._scene, i);
+    const A = this._scene.getEngine(), N = t._getDrawWrapper(void 0, !0), x = N.defines, M = i.join(`
+`);
+    return x !== M && N.setEffect(A.createEffect("geometry", {
+      attributes: n,
+      uniformsNames: Te,
+      samplers: we,
+      defines: M,
+      onCompiled: null,
+      fallbacks: null,
+      onError: null,
+      uniformBuffersNames: ["Scene"],
+      indexParameters: { buffersCount: this._multiRenderTarget.textures.length - 1, maxSimultaneousMorphTargets: u },
+      shaderLanguage: this.shaderLanguage
+    }, A), M), N.effect.isReady();
+  }
+  /**
+   * Gets the current underlying G Buffer.
+   * @returns the buffer
+   */
+  getGBuffer() {
+    return this._multiRenderTarget;
+  }
+  /**
+   * Gets the number of samples used to render the buffer (anti aliasing).
+   */
+  get samples() {
+    return this._multiRenderTarget.samples;
+  }
+  /**
+   * Sets the number of samples used to render the buffer (anti aliasing).
+   */
+  set samples(t) {
+    this._multiRenderTarget.samples = t;
+  }
+  /**
+   * Disposes the renderer and frees up associated resources.
+   */
+  dispose() {
+    this._resizeObserver && (this._scene.getEngine().onResizeObservable.remove(this._resizeObserver), this._resizeObserver = null), this._multiRenderTarget?.renderTarget && this.scene.getEngine()._currentRenderTarget === this._multiRenderTarget.renderTarget && this.scene.getEngine().unBindFramebuffer(this._multiRenderTarget?.renderTarget), this.getGBuffer().dispose();
+  }
+  _assignRenderTargetIndices() {
+    const t = [], s = [];
+    let e = 0;
+    return this._enableDepth && (this._depthIndex = e, e++, t.push("gBuffer_Depth"), s.push(this._textureTypesAndFormats[C.DEPTH_TEXTURE_TYPE])), this._enableNormal && (this._normalIndex = e, e++, t.push("gBuffer_Normal"), s.push(this._textureTypesAndFormats[C.NORMAL_TEXTURE_TYPE])), this._enablePosition && (this._positionIndex = e, e++, t.push("gBuffer_Position"), s.push(this._textureTypesAndFormats[C.POSITION_TEXTURE_TYPE])), this._enableVelocity && (this._velocityIndex = e, e++, t.push("gBuffer_Velocity"), s.push(this._textureTypesAndFormats[C.VELOCITY_TEXTURE_TYPE])), this._enableVelocityLinear && (this._velocityLinearIndex = e, e++, t.push("gBuffer_VelocityLinear"), s.push(this._textureTypesAndFormats[C.VELOCITY_LINEAR_TEXTURE_TYPE])), this._enableReflectivity && (this._reflectivityIndex = e, e++, t.push("gBuffer_Reflectivity"), s.push(this._textureTypesAndFormats[C.REFLECTIVITY_TEXTURE_TYPE])), this._enableScreenspaceDepth && (this._screenspaceDepthIndex = e, e++, t.push("gBuffer_ScreenspaceDepth"), s.push(this._textureTypesAndFormats[C.SCREENSPACE_DEPTH_TEXTURE_TYPE])), this._enableIrradiance && (this._irradianceIndex = e, e++, t.push("gBuffer_Irradiance"), s.push(this._textureTypesAndFormats[C.IRRADIANCE_TEXTURE_TYPE])), [e, t, s];
+  }
+  _createRenderTargets() {
+    const t = this._scene.getEngine(), [s, e, i] = this._assignRenderTargetIndices();
+    let n = 0;
+    t._caps.textureFloat && t._caps.textureFloatLinearFiltering ? n = 1 : t._caps.textureHalfFloat && t._caps.textureHalfFloatLinearFiltering && (n = 2);
+    const a = this._ratioOrDimensions.width !== void 0 ? this._ratioOrDimensions : { width: t.getRenderWidth() * this._ratioOrDimensions, height: t.getRenderHeight() * this._ratioOrDimensions }, f = [], I = [], L = [];
+    for (const T of i)
+      T ? (f.push(T.textureType), I.push(T.textureFormat), L.push(T.samplingMode ?? 2)) : (f.push(n), I.push(5), L.push(2));
+    if (this._normalsAreUnsigned = f[C.NORMAL_TEXTURE_TYPE] === 11 || f[C.NORMAL_TEXTURE_TYPE] === 13, this._multiRenderTarget = new Dt("gBuffer", a, s, this._scene, { generateMipMaps: !1, generateDepthTexture: !0, types: f, formats: I, samplingModes: L, depthTextureFormat: this._depthFormat }, e.concat("gBuffer_DepthBuffer")), !this.isSupported)
+      return;
+    this._multiRenderTarget.wrapU = re.CLAMP_ADDRESSMODE, this._multiRenderTarget.wrapV = re.CLAMP_ADDRESSMODE, this._multiRenderTarget.refreshRate = 1, this._multiRenderTarget.renderParticles = !1, this._multiRenderTarget.renderList = null;
+    const h = [!0], u = [!1], A = [!0];
+    for (let T = 1; T < s; ++T)
+      h.push(!0), A.push(!1), u.push(!0);
+    const N = t.buildTextureLayout(h), x = t.buildTextureLayout(u), M = t.buildTextureLayout(A);
+    this._multiRenderTarget.onClearObservable.add((T) => {
+      T.bindAttachments(this.useSpecificClearForDepthTexture ? x : N), T.clear(this._clearColor, !0, !0, !0), this.useSpecificClearForDepthTexture && (T.bindAttachments(M), T.clear(this._clearDepthColor, !0, !0, !0)), T.bindAttachments(N);
+    }), this._resizeObserver = t.onResizeObservable.add(() => {
+      if (this._multiRenderTarget) {
+        const T = this._ratioOrDimensions.width !== void 0 ? this._ratioOrDimensions : { width: t.getRenderWidth() * this._ratioOrDimensions, height: t.getRenderHeight() * this._ratioOrDimensions };
+        this._multiRenderTarget.resize(T);
+      }
+    });
+    const R = (T) => {
+      const m = T.getRenderingMesh(), F = T.getEffectiveMesh(), y = this._scene, S = y.getEngine(), c = T.getMaterial();
+      if (!c)
+        return;
+      if (F._internalAbstractMeshDataInfo._isActiveIntermediate = !1, (this._enableVelocity || this._enableVelocityLinear) && !this._previousTransformationMatrices[F.uniqueId] && (this._previousTransformationMatrices[F.uniqueId] = {
+        world: Ze.Identity(),
+        viewProjection: y.getTransformMatrix()
+      }, m.skeleton)) {
+        const _ = m.skeleton.getTransformMatrices(m);
+        this._previousBonesTransformationMatrices[m.uniqueId] = this._copyBonesTransformationMatrices(_, new Float32Array(_.length));
+      }
+      const Y = m._getInstancesRenderList(T._id, !!T.getReplacementMesh());
+      if (Y.mustReturn)
+        return;
+      const Z = S.getCaps().instancedArrays && (Y.visibleInstances[T._id] !== null || m.hasThinInstances), U = F.getWorldMatrix();
+      if (this.isReady(T, Z)) {
+        const _ = T._getDrawWrapper();
+        if (!_)
+          return;
+        const l = _.effect;
+        S.enableEffect(_), Z || m._bind(T, l, c.fillMode), this._useUbo ? (Ke(l, this._scene.getSceneUniformBuffer()), this._scene.finalizeSceneUbo()) : (l.setMatrix("viewProjection", y.getTransformMatrix()), l.setMatrix("view", y.getViewMatrix()), this._scene.bindEyePosition(l, "vEyePosition"));
+        let ee;
+        if (!m._instanceDataStorage.isFrozen && (c.backFaceCulling || c.sideOrientation !== null)) {
+          const E = F._getWorldMatrixDeterminant();
+          ee = c._getEffectiveOrientation(m), E < 0 && (ee = ee === k.ClockWiseSideOrientation ? k.CounterClockWiseSideOrientation : k.ClockWiseSideOrientation);
+        } else
+          ee = m._effectiveSideOrientation;
+        if (c._preBind(_, ee), c.needAlphaTestingForMesh(F)) {
+          const E = c.getAlphaTestTexture();
+          E && (l.setTexture("diffuseSampler", E), l.setMatrix("diffuseMatrix", E.getTextureMatrix()));
+        }
+        if ((c.bumpTexture || c.normalTexture || c.geometryNormalTexture) && y.getEngine().getCaps().standardDerivatives && H.BumpTextureEnabled) {
+          const E = c.bumpTexture || c.normalTexture || c.geometryNormalTexture;
+          l.setFloat3("vBumpInfos", E.coordinatesIndex, 1 / E.level, c.parallaxScaleBias), l.setMatrix("bumpMatrix", E.getTextureMatrix()), l.setTexture("bumpSampler", E), l.setFloat2("vTangentSpaceParams", c.invertNormalMapX ? -1 : 1, c.invertNormalMapY ? -1 : 1);
+        }
+        if (this._enableReflectivity) {
+          if (c.getClassName() === "PBRMetallicRoughnessMaterial")
+            c.metallicRoughnessTexture !== null && (l.setTexture("reflectivitySampler", c.metallicRoughnessTexture), l.setMatrix("reflectivityMatrix", c.metallicRoughnessTexture.getTextureMatrix())), c.metallic !== null && l.setFloat("metallic", c.metallic), c.roughness !== null && l.setFloat("glossiness", 1 - c.roughness), c.baseTexture !== null && (l.setTexture("albedoSampler", c.baseTexture), l.setMatrix("albedoMatrix", c.baseTexture.getTextureMatrix())), c.baseColor !== null && l.setColor3("albedoColor", c.baseColor);
+          else if (c.getClassName() === "PBRSpecularGlossinessMaterial")
+            c.specularGlossinessTexture !== null ? (l.setTexture("reflectivitySampler", c.specularGlossinessTexture), l.setMatrix("reflectivityMatrix", c.specularGlossinessTexture.getTextureMatrix())) : c.specularColor !== null && l.setColor3("reflectivityColor", c.specularColor), c.glossiness !== null && l.setFloat("glossiness", c.glossiness);
+          else if (c.getClassName() === "PBRMaterial")
+            c.metallicTexture !== null && (l.setTexture("reflectivitySampler", c.metallicTexture), l.setMatrix("reflectivityMatrix", c.metallicTexture.getTextureMatrix())), c.metallic !== null && l.setFloat("metallic", c.metallic), c.roughness !== null && l.setFloat("glossiness", 1 - c.roughness), c.roughness !== null || c.metallic !== null || c.metallicTexture !== null ? (c.albedoTexture !== null && (l.setTexture("albedoSampler", c.albedoTexture), l.setMatrix("albedoMatrix", c.albedoTexture.getTextureMatrix())), c.albedoColor !== null && l.setColor3("albedoColor", c.albedoColor)) : (c.reflectivityTexture !== null ? (l.setTexture("reflectivitySampler", c.reflectivityTexture), l.setMatrix("reflectivityMatrix", c.reflectivityTexture.getTextureMatrix())) : c.reflectivityColor !== null && l.setColor3("reflectivityColor", c.reflectivityColor), c.microSurface !== null && l.setFloat("glossiness", c.microSurface));
+          else if (c.getClassName() === "StandardMaterial")
+            c.specularTexture !== null && (l.setTexture("reflectivitySampler", c.specularTexture), l.setMatrix("reflectivityMatrix", c.specularTexture.getTextureMatrix())), c.specularColor !== null && l.setColor3("reflectivityColor", c.specularColor);
+          else if (c.getClassName() === "OpenPBRMaterial") {
+            const E = c;
+            E._useRoughnessFromMetallicTextureGreen && E.baseMetalnessTexture ? (l.setTexture("reflectivitySampler", E.baseMetalnessTexture), l.setMatrix("reflectivityMatrix", E.baseMetalnessTexture.getTextureMatrix())) : E.baseMetalnessTexture ? (l.setTexture("metallicSampler", E.baseMetalnessTexture), l.setMatrix("metallicMatrix", E.baseMetalnessTexture.getTextureMatrix())) : E.specularRoughnessTexture && (l.setTexture("roughnessSampler", E.specularRoughnessTexture), l.setMatrix("roughnessMatrix", E.specularRoughnessTexture.getTextureMatrix())), l.setFloat("metallic", E.baseMetalness), l.setFloat("glossiness", 1 - E.specularRoughness), E.baseColorTexture !== null && (l.setTexture("albedoSampler", E.baseColorTexture), l.setMatrix("albedoMatrix", E.baseColorTexture.getTextureMatrix())), E.baseColor !== null && l.setColor3("albedoColor", E.baseColor);
+          }
+        }
+        if (this._enableIrradiance && y.environmentTexture) {
+          const E = y.environmentTexture, j = y.postProcessRenderPipelineManager.supportedPipelines.find((g) => g.getClassName() === "IBLShadowsRenderPipeline");
+          if (j) {
+            const w = j._getAccumulatedTexture();
+            w && (l.setTexture("iblShadowSampler", w), l.setFloat2("shadowTextureSize", w.getSize().width, w.getSize().height));
+          }
+          if (l.setMatrix("reflectionMatrix", E.getReflectionTextureMatrix()), l.setFloat2("vReflectionInfos", E.level * y.iblIntensity, 0), l.setTexture("reflectionSampler", E), E.irradianceTexture && (l.setTexture("irradianceSampler", E.irradianceTexture), E.irradianceTexture._dominantDirection && l.setVector3("vReflectionDominantDirection", E.irradianceTexture._dominantDirection)), E.sphericalPolynomial) {
+            const g = E.sphericalPolynomial;
+            if (g.preScaledHarmonics) {
+              const w = g.preScaledHarmonics;
+              l.setVector3("vSphericalL00", w.l00), l.setVector3("vSphericalL1_1", w.l1_1), l.setVector3("vSphericalL10", w.l10), l.setVector3("vSphericalL11", w.l11), l.setVector3("vSphericalL2_2", w.l2_2), l.setVector3("vSphericalL2_1", w.l2_1), l.setVector3("vSphericalL20", w.l20), l.setVector3("vSphericalL21", w.l21), l.setVector3("vSphericalL22", w.l22);
+            } else
+              l.setFloat3("vSphericalX", g.x.x, g.x.y, g.x.z), l.setFloat3("vSphericalY", g.y.x, g.y.y, g.y.z), l.setFloat3("vSphericalZ", g.z.x, g.z.y, g.z.z), l.setFloat3("vSphericalXX_ZZ", g.xx.x - g.zz.x, g.xx.y - g.zz.y, g.xx.z - g.zz.z), l.setFloat3("vSphericalYY_ZZ", g.yy.x - g.zz.x, g.yy.y - g.zz.y, g.yy.z - g.zz.z), l.setFloat3("vSphericalZZ", g.zz.x, g.zz.y, g.zz.z), l.setFloat3("vSphericalXY", g.xy.x, g.xy.y, g.xy.z), l.setFloat3("vSphericalYZ", g.yz.x, g.yz.y, g.yz.z), l.setFloat3("vSphericalZX", g.zx.x, g.zx.y, g.zx.z);
+          }
+          if (this.generateIrradianceWithScatterMask && c.getClassName() === "OpenPBRMaterial") {
+            const g = c;
+            l.setFloat("vSubsurfaceWeight", g.subsurfaceWeight), g.subsurfaceWeightTexture && (l.setTexture("subsurfaceWeightSampler", g.subsurfaceWeightTexture), l.setMatrix("subsurfaceWeightMatrix", g.subsurfaceWeightTexture.getTextureMatrix())), l.setFloat("vTransmissionWeight", g.transmissionWeight), g.transmissionWeightTexture && (l.setTexture("transmissionWeightSampler", g.transmissionWeightTexture), l.setMatrix("transmissionWeightMatrix", g.transmissionWeightTexture.getTextureMatrix())), l.setFloat("vTransmissionScatterAnisotropy", g.transmissionScatterAnisotropy), l.setFloat("vSubsurfaceScatterAnisotropy", g.subsurfaceScatterAnisotropy);
+          }
+        }
+        if (Pe(l, c, this._scene), m.useBones && m.computeBonesUsingShaders && m.skeleton) {
+          const E = m.skeleton;
+          if (E.isUsingTextureForMatrices && l.getUniformIndex("boneTextureInfo") > -1) {
+            const j = E.getTransformMatrixTexture(m);
+            l.setTexture("boneSampler", j), l.setFloat2("boneTextureInfo", E._textureWidth, E._textureHeight);
+          } else
+            l.setMatrices("mBones", m.skeleton.getTransformMatrices(m));
+          (this._enableVelocity || this._enableVelocityLinear) && l.setMatrices("mPreviousBones", this._previousBonesTransformationMatrices[m.uniqueId]);
+        }
+        Ue(m, l), m.morphTargetManager && m.morphTargetManager.isUsingTextureForTargets && m.morphTargetManager._bind(l), (this._enableVelocity || this._enableVelocityLinear) && (l.setMatrix("previousWorld", this._previousTransformationMatrices[F.uniqueId].world), l.setMatrix("previousViewProjection", this._previousTransformationMatrices[F.uniqueId].viewProjection)), Z && m.hasThinInstances && l.setMatrix("world", U), m._processRendering(F, T, l, c.fillMode, Y, Z, (E, j) => {
+          E || l.setMatrix("world", j);
+        });
+      }
+      (this._enableVelocity || this._enableVelocityLinear) && (this._previousTransformationMatrices[F.uniqueId].world = U.clone(), this._previousTransformationMatrices[F.uniqueId].viewProjection = this._scene.getTransformMatrix().clone(), m.skeleton && this._copyBonesTransformationMatrices(m.skeleton.getTransformMatrices(m), this._previousBonesTransformationMatrices[F.uniqueId]));
+    };
+    this._multiRenderTarget.customIsReadyFunction = (T, m, F) => {
+      if ((F || m === 0) && T.subMeshes)
+        for (let y = 0; y < T.subMeshes.length; ++y) {
+          const S = T.subMeshes[y], c = S.getMaterial(), Y = S.getRenderingMesh();
+          if (!c)
+            continue;
+          const Z = Y._getInstancesRenderList(S._id, !!S.getReplacementMesh()), U = t.getCaps().instancedArrays && (Z.visibleInstances[S._id] !== null || Y.hasThinInstances);
+          if (!this.isReady(S, U))
+            return !1;
+        }
+      return !0;
+    }, this._multiRenderTarget.customRenderFunction = (T, m, F, y) => {
+      let S;
+      if (this._linkedWithPrePass) {
+        if (!this._prePassRenderer.enabled)
+          return;
+        this._scene.getEngine().bindAttachments(this._attachmentsFromPrePass);
+      }
+      if (y.length) {
+        for (t.setColorWrite(!1), S = 0; S < y.length; S++)
+          R(y.data[S]);
+        t.setColorWrite(!0);
+      }
+      for (S = 0; S < T.length; S++)
+        R(T.data[S]);
+      for (t.setDepthWrite(!1), S = 0; S < m.length; S++)
+        R(m.data[S]);
+      if (this.renderTransparentMeshes)
+        for (S = 0; S < F.length; S++)
+          R(F.data[S]);
+      t.setDepthWrite(!0);
+    };
+  }
+  // Copies the bones transformation matrices into the target array and returns the target's reference
+  _copyBonesTransformationMatrices(t, s) {
+    for (let e = 0; e < t.length; e++)
+      s[e] = t[e];
+    return s;
+  }
+}
+C.ForceGLSL = !1;
+C.DEPTH_TEXTURE_TYPE = 0;
+C.NORMAL_TEXTURE_TYPE = 1;
+C.POSITION_TEXTURE_TYPE = 2;
+C.VELOCITY_TEXTURE_TYPE = 3;
+C.REFLECTIVITY_TEXTURE_TYPE = 4;
+C.SCREENSPACE_DEPTH_TEXTURE_TYPE = 5;
+C.VELOCITY_LINEAR_TEXTURE_TYPE = 6;
+C.IRRADIANCE_TEXTURE_TYPE = 7;
+C._SceneComponentInitialization = (p) => {
+  throw $e("GeometryBufferRendererSceneComponent");
+};
+const ie = { effect: null, subMesh: null };
+class ne {
+  populateVectorFromLinkedProperties(t) {
+    const s = t.dimension[0];
+    for (const e in this.linkedProperties) {
+      const i = this.linkedProperties[e], n = i.numComponents;
+      if (s < n || i.targetUniformComponentOffset > s - n) {
+        n == 1 ? se.Error(`Float property ${i.name} has an offset that is too large.`) : se.Error(`Vector${n} property ${i.name} won't fit in Vector${s} or has an offset that is too large.`);
+        return;
+      }
+      typeof i.value == "number" ? ne._tmpArray[i.targetUniformComponentOffset] = i.value : i.value.toArray(ne._tmpArray, i.targetUniformComponentOffset);
+    }
+    t.fromArray(ne._tmpArray);
+  }
+  constructor(t, s) {
+    this.linkedProperties = {}, this.firstLinkedKey = "", this.name = t, this.numComponents = s;
+  }
+}
+ne._tmpArray = [0, 0, 0, 0];
+class v {
+  /**
+   * Creates a new Property instance.
+   * @param name The name of the property in the shader
+   * @param defaultValue The default value of the property
+   * @param targetUniformName The name of the property in the shader uniform block
+   * @param targetUniformComponentNum The number of components in the target uniform. All properties that are
+   * packed into the same uniform must agree on the size of the target uniform.
+   * @param targetUniformComponentOffset The offset in the uniform where this property will be packed.
+   * @param requiredDefine Optional define name. When provided, the per-frame
+   *  bind loop will skip pushing the owning uniform to the UBO unless
+   *  `defines[requiredDefine]` is true.
+   */
+  constructor(t, s, e, i, n = 0, a) {
+    this.targetUniformComponentNum = 4, this.targetUniformComponentOffset = 0, this.name = t, this.targetUniformName = e, this.defaultValue = s, this.value = s, this.targetUniformComponentNum = i, this.targetUniformComponentOffset = n, this.requiredDefine = a;
+  }
+  /**
+   * Returns the number of components of the property based on its default value type.
+   */
+  get numComponents() {
+    return typeof this.defaultValue == "number" ? 1 : this.defaultValue.dimension[0];
+  }
+}
+class O {
+  /**
+   * The name of the sampler used in the shader.
+   * If this naming changes, we'll also need to change:
+   * - samplerFragmentDeclaration.fx
+   * - openpbr.fragment.fx
+   */
+  get samplerName() {
+    return this.samplerPrefix + "Sampler";
+  }
+  /**
+   * The name of the sampler info used in the shader.
+   * If this naming changes, we'll also need to change:
+   * - openpbr.vertex.fx
+   * - openpbr.fragment.fx
+   */
+  get samplerInfoName() {
+    return "v" + this.samplerPrefix.charAt(0).toUpperCase() + this.samplerPrefix.slice(1) + "Infos";
+  }
+  /**
+   * The name of the matrix used for this sampler in the shader.
+   * If this naming changes, we'll also need to change:
+   * - materialHelper.functions.BindTextureMatrix
+   * - samplerVertexImplementation.fx
+   * - openpbr.fragment.fx
+   */
+  get samplerMatrixName() {
+    return this.samplerPrefix + "Matrix";
+  }
+  /**
+   * Creates a new Sampler instance.
+   * @param name The name of the texture property
+   * @param samplerPrefix The prefix used for the name of the sampler in the shader
+   * @param textureDefine The define used in the shader for this sampler
+   */
+  constructor(t, s, e) {
+    this.value = null, this.samplerPrefix = "", this.textureDefine = "", this.name = t, this.samplerPrefix = s, this.textureDefine = e;
+  }
+}
+class Kt extends Mt(bt(Ot)) {
+}
+class $t extends yt(Kt) {
+}
+class ye extends Ct($t) {
+  /**
+   * Initializes the PBR Material defines.
+   * @param externalProperties The external properties
+   */
+  constructor(t) {
+    super(t), this.NUM_SAMPLES = "0", this.REALTIME_FILTERING = !1, this.IBL_CDF_FILTERING = !1, this.LIGHTCOUNT = 0, this.VERTEXCOLOR = !1, this.BAKED_VERTEX_ANIMATION_TEXTURE = !1, this.VERTEXALPHA = !1, this.ALPHATEST = !1, this.DEPTHPREPASS = !1, this.ALPHABLEND = !1, this.ALPHA_FROM_BASE_COLOR_TEXTURE = !1, this.ALPHATESTVALUE = "0.5", this.PREMULTIPLYALPHA = !1, this.REFLECTIVITY_GAMMA = !1, this.REFLECTIVITYDIRECTUV = 0, this.SPECULARTERM = !1, this.LODBASEDMICROSFURACE = !0, this.SPECULAR_ROUGHNESS_FROM_METALNESS_TEXTURE_GREEN = !1, this.BASE_METALNESS_FROM_METALNESS_TEXTURE_BLUE = !1, this.AOSTOREINMETALMAPRED = !1, this.SPECULAR_WEIGHT_IN_ALPHA = !1, this.SPECULAR_WEIGHT_FROM_SPECULAR_COLOR_TEXTURE = !1, this.SPECULAR_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE = !1, this.COAT_ROUGHNESS_FROM_GREEN_CHANNEL = !1, this.COAT_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE = !1, this.USE_GLTF_STYLE_ANISOTROPY = !1, this.THIN_FILM_THICKNESS_FROM_THIN_FILM_TEXTURE = !1, this.FUZZ_ROUGHNESS_FROM_TEXTURE_ALPHA = !1, this.SUBSURFACE_WEIGHT_FROM_TEXTURE_ALPHA = !1, this.GEOMETRY_THICKNESS_FROM_GREEN_CHANNEL = !1, this.ENVIRONMENTBRDF = !1, this.ENVIRONMENTBRDF_RGBD = !1, this.FUZZENVIRONMENTBRDF = !1, this.NORMAL = !1, this.TANGENT = !1, this.OBJECTSPACE_NORMALMAP = !1, this.PARALLAX = !1, this.PARALLAX_RHS = !1, this.PARALLAXOCCLUSION = !1, this.NORMALXYSCALE = !0, this.ANISOTROPIC = !1, this.ANISOTROPIC_OPENPBR = !0, this.ANISOTROPIC_BASE = !1, this.ANISOTROPIC_COAT = !1, this.FUZZ_IBL_SAMPLES = 6, this.REFRACTION_HIGH_QUALITY_BLUR = !1, this.FUZZ = !1, this.THIN_FILM = !1, this.IRIDESCENCE = !1, this.DISPERSION = !1, this.SCATTERING = !1, this.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING = !1, this.SSS_SAMPLE_COUNT = 16, this.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING_GBUFFER = !1, this.TRANSMISSION_SLAB = !1, this.TRANSMISSION_SLAB_VOLUME = !1, this.SUBSURFACE_SLAB = !1, this.GEOMETRY_THIN_WALLED = !1, this.REFRACTED_BACKGROUND = !1, this.REFRACTED_LIGHTS = !1, this.REFRACTED_ENVIRONMENT = !1, this.REFRACTED_ENVIRONMENT_OPPOSITEZ = !1, this.REFRACTED_ENVIRONMENT_LOCAL_CUBE = !1, this.RADIANCEOCCLUSION = !1, this.HORIZONOCCLUSION = !1, this.INSTANCES = !1, this.THIN_INSTANCES = !1, this.INSTANCESCOLOR = !1, this.NUM_BONE_INFLUENCERS = 0, this.BonesPerMesh = 0, this.BONETEXTURE = !1, this.BONES_VELOCITY_ENABLED = !1, this.NONUNIFORMSCALING = !1, this.MORPHTARGETS = !1, this.MORPHTARGETS_POSITION = !1, this.MORPHTARGETS_NORMAL = !1, this.MORPHTARGETS_TANGENT = !1, this.MORPHTARGETS_UV = !1, this.MORPHTARGETS_UV2 = !1, this.MORPHTARGETS_COLOR = !1, this.MORPHTARGETTEXTURE_HASPOSITIONS = !1, this.MORPHTARGETTEXTURE_HASNORMALS = !1, this.MORPHTARGETTEXTURE_HASTANGENTS = !1, this.MORPHTARGETTEXTURE_HASUVS = !1, this.MORPHTARGETTEXTURE_HASUV2S = !1, this.MORPHTARGETTEXTURE_HASCOLORS = !1, this.NUM_MORPH_INFLUENCERS = 0, this.MORPHTARGETS_TEXTURE = !1, this.USEPHYSICALLIGHTFALLOFF = !1, this.USEGLTFLIGHTFALLOFF = !1, this.TWOSIDEDLIGHTING = !1, this.MIRRORED = !1, this.SHADOWFLOAT = !1, this.CLIPPLANE = !1, this.CLIPPLANE2 = !1, this.CLIPPLANE3 = !1, this.CLIPPLANE4 = !1, this.CLIPPLANE5 = !1, this.CLIPPLANE6 = !1, this.POINTSIZE = !1, this.FOG = !1, this.LOGARITHMICDEPTH = !1, this.CAMERA_ORTHOGRAPHIC = !1, this.CAMERA_PERSPECTIVE = !1, this.AREALIGHTSUPPORTED = !0, this.FORCENORMALFORWARD = !1, this.SPECULARAA = !1, this.UNLIT = !1, this.DECAL_AFTER_DETAIL = !1, this.TEXTURE_REPETITION_MODE = 0, this.DEBUGMODE = 0, this.USE_VERTEX_PULLING = !1, this.VERTEX_PULLING_USE_INDEX_BUFFER = !1, this.VERTEX_PULLING_INDEX_BUFFER_32BITS = !1, this.RIGHT_HANDED = !1, this.CLUSTLIGHT_SLICES = 0, this.CLUSTLIGHT_BATCH = 0, this.BRDF_V_HEIGHT_CORRELATED = !0, this.MS_BRDF_ENERGY_CONSERVATION = !0, this.SPHERICAL_HARMONICS = !0, this.SPECULAR_GLOSSINESS_ENERGY_CONSERVATION = !0, this.MIX_IBL_RADIANCE_WITH_IRRADIANCE = !0, this.LEGACY_SPECULAR_ENERGY_CONSERVATION = !1, this.BASE_DIFFUSE_MODEL = 0, this.DIELECTRIC_SPECULAR_MODEL = 1, this.CONDUCTOR_SPECULAR_MODEL = 1, this.rebuild();
+  }
+  /**
+   * Resets the PBR Material defines.
+   */
+  reset() {
+    super.reset(), this.ALPHATESTVALUE = "0.5", this.NORMALXYSCALE = !0;
+  }
+}
+class jt extends vt(Lt) {
+}
+class r extends jt {
+  /**
+   * Defines the angle of the tangent of the material's geometry. Used only for anisotropic reflections.
+   * See OpenPBR's specs for geometry_tangent
+   */
+  get geometryTangentAngle() {
+    return Math.atan2(this.geometryTangent.y, this.geometryTangent.x);
+  }
+  set geometryTangentAngle(t) {
+    this.geometryTangent = new ae(Math.cos(t), Math.sin(t));
+  }
+  /**
+   * Defines the angle of the tangent of the material's coat layer.
+   */
+  get geometryCoatTangentAngle() {
+    return Math.atan2(this.geometryCoatTangent.y, this.geometryCoatTangent.x);
+  }
+  /**
+   * Defines the angle of the tangent of the material's coat layer.
+   */
+  set geometryCoatTangentAngle(t) {
+    this.geometryCoatTangent = new ae(Math.cos(t), Math.sin(t));
+  }
+  /**
+   * Controls the sample count of the screen-space SSS convolution kernel.
+   * Use the SSS_QUALITY_LOW / MEDIUM / HIGH constants (8 / 16 / 32 samples).
+   * Higher quality reduces noise at the cost of GPU time. Default: MEDIUM.
+   */
+  get sssQuality() {
+    return this._sssQuality;
+  }
+  set sssQuality(t) {
+    this._sssQuality !== t && (this._sssQuality = t, this.markAsDirty(1));
+  }
+  /**
+   * Defines the irradiance texture used for subsurface scattering.
+   * If it's not provided, the irradiance will be looked for in the scene.geometryBufferRenderer.
+   * Accepts a {@link ThinTexture} so that an {@link InternalTexture} obtained from a frame graph
+   * handle can be wrapped with `new ThinTexture(internalTexture)` and assigned directly.
+   * Setting this property marks all sub-meshes as textures-dirty so the shader recompiles.
+   */
+  get sssIrradianceTexture() {
+    return this._sssIrradianceTexture;
+  }
+  set sssIrradianceTexture(t) {
+    this._sssIrradianceTexture !== t && (this._sssIrradianceTexture = t, this._markAllSubMeshesAsTexturesDirty());
+  }
+  /**
+   * Defines the depth texture used for subsurface scattering. This is the depth defined
+   * in screen space. If it's not provided, the depth will be looked for in the scene.geometryBufferRenderer.
+   * Accepts a {@link ThinTexture} so that an {@link InternalTexture} obtained from a frame graph
+   * handle can be wrapped with `new ThinTexture(internalTexture)` and assigned directly.
+   * Setting this property marks all sub-meshes as textures-dirty so the shader recompiles.
+   */
+  get sssDepthTexture() {
+    return this._sssDepthTexture;
+  }
+  set sssDepthTexture(t) {
+    this._sssDepthTexture !== t && (this._sssDepthTexture = t, this._markAllSubMeshesAsTexturesDirty());
+  }
+  /**
+   * Specifies if we can see through the surface of the material due to subsurface scattering or transmission.
+   */
+  get hasTransparency() {
+    return this.subsurfaceWeight > 0 || this.transmissionWeight > 0;
+  }
+  /** Specifies if the material has scattering properties such as subsurface scattering or transmission scattering. */
+  get hasScattering() {
+    return this.transmissionWeight > 0 && this.transmissionDepth > 0 && !this.transmissionScatter.equals(K.BlackReadOnly) || this.subsurfaceWeight > 0;
+  }
+  /**
+   * BJS is using an hardcoded light falloff based on a manually sets up range.
+   * In PBR, one way to represents the falloff is to use the inverse squared root algorithm.
+   * This parameter can help you switch back to the BJS mode in order to create scenes using both materials.
+   */
+  get usePhysicalLightFalloff() {
+    return this._lightFalloff === k.LIGHTFALLOFF_PHYSICAL;
+  }
+  /**
+   * BJS is using an hardcoded light falloff based on a manually sets up range.
+   * In PBR, one way to represents the falloff is to use the inverse squared root algorithm.
+   * This parameter can help you switch back to the BJS mode in order to create scenes using both materials.
+   */
+  set usePhysicalLightFalloff(t) {
+    t !== this.usePhysicalLightFalloff && (this._markAllSubMeshesAsTexturesDirty(), t ? this._lightFalloff = k.LIGHTFALLOFF_PHYSICAL : this._lightFalloff = k.LIGHTFALLOFF_STANDARD);
+  }
+  /**
+   * In order to support the falloff compatibility with gltf, a special mode has been added
+   * to reproduce the gltf light falloff.
+   */
+  get useGLTFLightFalloff() {
+    return this._lightFalloff === k.LIGHTFALLOFF_GLTF;
+  }
+  /**
+   * In order to support the falloff compatibility with gltf, a special mode has been added
+   * to reproduce the gltf light falloff.
+   */
+  set useGLTFLightFalloff(t) {
+    t !== this.useGLTFLightFalloff && (this._markAllSubMeshesAsTexturesDirty(), t ? this._lightFalloff = k.LIGHTFALLOFF_GLTF : this._lightFalloff = k.LIGHTFALLOFF_STANDARD);
+  }
+  /**
+   * Set the texture used for refraction of the background of transparent materials
+   * @internal
+   */
+  get backgroundRefractionTexture() {
+    return this._backgroundRefractionTexture;
+  }
+  set backgroundRefractionTexture(t) {
+    this._backgroundRefractionTexture = t, this._markAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * When true, uses a 4-tap rotated-grid kernel for refractive background blur,
+   * eliminating bilinear block artifacts at the cost of 3 extra texture samples.
+   * When false, a single dithered sample is used. Default: true.
+   */
+  get refractionHighQualityBlur() {
+    return this._refractionHighQualityBlur;
+  }
+  set refractionHighQualityBlur(t) {
+    this._refractionHighQualityBlur !== t && (this._refractionHighQualityBlur = t, this.markAsDirty(1));
+  }
+  /**
+   * Enables realtime filtering on the texture.
+   */
+  get realTimeFiltering() {
+    return this._realTimeFiltering;
+  }
+  set realTimeFiltering(t) {
+    this._realTimeFiltering = t, this.markAsDirty(1);
+  }
+  /**
+   * Quality switch for realtime filtering
+   */
+  get realTimeFilteringQuality() {
+    return this._realTimeFilteringQuality;
+  }
+  set realTimeFilteringQuality(t) {
+    this._realTimeFilteringQuality = t, this.markAsDirty(1);
+  }
+  /**
+   * The number of samples used to compute the fuzz IBL lighting.
+   */
+  get fuzzSampleNumber() {
+    return this._fuzzSampleNumber;
+  }
+  set fuzzSampleNumber(t) {
+    this._fuzzSampleNumber = t, this.markAsDirty(1);
+  }
+  /**
+   * Can this material render to several textures at once
+   */
+  get canRenderToMRT() {
+    return !0;
+  }
+  /**
+   * Instantiates a new OpenPBRMaterial instance.
+   *
+   * @param name The material name
+   * @param scene The scene the material will be use in.
+   * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+   */
+  constructor(t, s, e = !1) {
+    super(t, s, void 0, e || r.ForceGLSL), this._baseWeight = new v("base_weight", 1, "vBaseWeight", 1), this._baseWeightTexture = new O("base_weight", "baseWeight", "BASE_WEIGHT"), this._baseColor = new v("base_color", K.White(), "vBaseColor", 4), this._baseColorTexture = new O("base_color", "baseColor", "BASE_COLOR"), this._baseDiffuseRoughness = new v("base_diffuse_roughness", 0, "vBaseDiffuseRoughness", 1), this._baseDiffuseRoughnessTexture = new O("base_diffuse_roughness", "baseDiffuseRoughness", "BASE_DIFFUSE_ROUGHNESS"), this._baseMetalness = new v("base_metalness", 0, "vReflectanceInfo", 4, 0), this._baseMetalnessTexture = new O("base_metalness", "baseMetalness", "BASE_METALNESS"), this._specularWeight = new v("specular_weight", 1, "vReflectanceInfo", 4, 3), this._specularWeightTexture = new O("specular_weight", "specularWeight", "SPECULAR_WEIGHT"), this._specularColor = new v("specular_color", K.White(), "vSpecularColor", 4), this._specularColorTexture = new O("specular_color", "specularColor", "SPECULAR_COLOR"), this._specularRoughness = new v("specular_roughness", 0.3, "vReflectanceInfo", 4, 1), this._specularRoughnessTexture = new O("specular_roughness", "specularRoughness", "SPECULAR_ROUGHNESS"), this._specularRoughnessAnisotropy = new v("specular_roughness_anisotropy", 0, "vSpecularAnisotropy", 3, 2), this._specularRoughnessAnisotropyTexture = new O("specular_roughness_anisotropy", "specularRoughnessAnisotropy", "SPECULAR_ROUGHNESS_ANISOTROPY"), this._specularIor = new v("specular_ior", 1.5, "vReflectanceInfo", 4, 2), this._transmissionWeight = new v("transmission_weight", 0, "vTransmissionWeight", 1), this._transmissionWeightTexture = new O("transmission_weight", "transmissionWeight", "TRANSMISSION_WEIGHT"), this._transmissionColor = new v("transmission_color", K.White(), "vTransmissionColor", 3, 0), this._transmissionColorTexture = new O("transmission_color", "transmissionColor", "TRANSMISSION_COLOR"), this._transmissionDepth = new v("transmission_depth", 0, "vTransmissionDepth", 1, 0), this._transmissionDepthTexture = new O("transmission_depth", "transmissionDepth", "TRANSMISSION_DEPTH"), this._transmissionScatter = new v("transmission_scatter", K.Black(), "vTransmissionScatter", 3, 0), this._transmissionScatterTexture = new O("transmission_scatter", "transmissionScatter", "TRANSMISSION_SCATTER"), this._transmissionScatterAnisotropy = new v("transmission_scatter_anisotropy", 0, "vTransmissionScatterAnisotropy", 1, 0), this._transmissionDispersionScale = new v("transmission_dispersion_scale", 0, "vTransmissionDispersionScale", 1, 0), this._transmissionDispersionScaleTexture = new O("transmission_dispersion_scale", "transmissionDispersionScale", "TRANSMISSION_DISPERSION_SCALE"), this._transmissionDispersionAbbeNumber = new v("transmission_dispersion_abbe_number", 20, "vTransmissionDispersionAbbeNumber", 1, 0), this._subsurfaceWeight = new v("subsurface_weight", 0, "vSubsurfaceWeight", 1, 0, "SUBSURFACE_SLAB"), this._subsurfaceWeightTexture = new O("subsurface_weight", "subsurfaceWeight", "SUBSURFACE_WEIGHT"), this._subsurfaceColor = new v("subsurface_color", new K(0.8, 0.8, 0.8), "vSubsurfaceColor", 3, 0, "SUBSURFACE_SLAB"), this._subsurfaceColorTexture = new O("subsurface_color", "subsurfaceColor", "SUBSURFACE_COLOR"), this._subsurfaceRadius = new v("subsurface_radius", 0.1, "vSubsurfaceRadius", 1, 0, "SUBSURFACE_SLAB"), this._subsurfaceRadiusScale = new v("subsurface_radius_scale", new K(1, 0.5, 0.25), "vSubsurfaceRadiusScale", 3, 0, "SUBSURFACE_SLAB"), this._subsurfaceRadiusScaleTexture = new O("subsurface_radius_scale", "subsurfaceRadiusScale", "SUBSURFACE_RADIUS_SCALE"), this._subsurfaceScatterAnisotropy = new v("subsurface_scatter_anisotropy", 0, "vSubsurfaceScatterAnisotropy", 1, 0, "SUBSURFACE_SLAB"), this._coatWeight = new v("coat_weight", 0, "vCoatWeight", 1, 0), this._coatWeightTexture = new O("coat_weight", "coatWeight", "COAT_WEIGHT"), this._coatColor = new v("coat_color", K.White(), "vCoatColor", 3, 0), this._coatColorTexture = new O("coat_color", "coatColor", "COAT_COLOR"), this._coatRoughness = new v("coat_roughness", 0, "vCoatRoughness", 1, 0), this._coatRoughnessTexture = new O("coat_roughness", "coatRoughness", "COAT_ROUGHNESS"), this._coatRoughnessAnisotropy = new v("coat_roughness_anisotropy", 0, "vCoatRoughnessAnisotropy", 1), this._coatRoughnessAnisotropyTexture = new O("coat_roughness_anisotropy", "coatRoughnessAnisotropy", "COAT_ROUGHNESS_ANISOTROPY"), this._coatIor = new v("coat_ior", 1.5, "vCoatIor", 1, 0), this._coatDarkening = new v("coat_darkening", 1, "vCoatDarkening", 1, 0), this._coatDarkeningTexture = new O("coat_darkening", "coatDarkening", "COAT_DARKENING"), this.useCoatRoughnessFromWeightTexture = !1, this._fuzzWeight = new v("fuzz_weight", 0, "vFuzzWeight", 1, 0), this._fuzzWeightTexture = new O("fuzz_weight", "fuzzWeight", "FUZZ_WEIGHT"), this._fuzzColor = new v("fuzz_color", K.White(), "vFuzzColor", 3, 0), this._fuzzColorTexture = new O("fuzz_color", "fuzzColor", "FUZZ_COLOR"), this._fuzzRoughness = new v("fuzz_roughness", 0.5, "vFuzzRoughness", 1, 0), this._fuzzRoughnessTexture = new O("fuzz_roughness", "fuzzRoughness", "FUZZ_ROUGHNESS"), this._geometryThinWalled = new v("geometry_thin_walled", 0, "vGeometryThinWalled", 1, 0), this._geometryNormalTexture = new O("geometry_normal", "geometryNormal", "GEOMETRY_NORMAL"), this._geometryTangent = new v("geometry_tangent", new ae(1, 0), "vSpecularAnisotropy", 3, 0), this._geometryTangentTexture = new O("geometry_tangent", "geometryTangent", "GEOMETRY_TANGENT"), this._geometryCoatNormalTexture = new O("geometry_coat_normal", "geometryCoatNormal", "GEOMETRY_COAT_NORMAL"), this._geometryCoatTangent = new v("geometry_coat_tangent", new ae(1, 0), "vGeometryCoatTangent", 2, 0), this._geometryCoatTangentTexture = new O("geometry_coat_tangent", "geometryCoatTangent", "GEOMETRY_COAT_TANGENT"), this._geometryOpacity = new v("geometry_opacity", 1, "vBaseColor", 4, 3), this._geometryOpacityTexture = new O("geometry_opacity", "geometryOpacity", "GEOMETRY_OPACITY"), this._geometryThickness = new v("geometry_thickness", 0, "vGeometryThickness", 1, 0), this._geometryThicknessTexture = new O("geometry_thickness", "geometryThickness", "GEOMETRY_THICKNESS"), this._emissionLuminance = new v("emission_luminance", 1, "vLightingIntensity", 4, 1), this._emissionColor = new v("emission_color", K.Black(), "vEmissionColor", 3), this._emissionColorTexture = new O("emission_color", "emissionColor", "EMISSION_COLOR"), this._thinFilmWeight = new v("thin_film_weight", 0, "vThinFilmWeight", 1, 0), this._thinFilmWeightTexture = new O("thin_film_weight", "thinFilmWeight", "THIN_FILM_WEIGHT"), this._thinFilmThickness = new v("thin_film_thickness", 0.5, "vThinFilmThickness", 2, 0), this._thinFilmThicknessMin = new v("thin_film_thickness_min", 0, "vThinFilmThickness", 2, 1), this._thinFilmThicknessTexture = new O("thin_film_thickness", "thinFilmThickness", "THIN_FILM_THICKNESS"), this._thinFilmIor = new v("thin_film_ior", 1.4, "vThinFilmIor", 1, 0), this._ambientOcclusionTexture = new O("ambient_occlusion", "ambientOcclusion", "AMBIENT_OCCLUSION"), this._sssQuality = r.SSS_QUALITY_MEDIUM, this._sssIrradianceTexture = null, this._sssDepthTexture = null, this._uniformsList = {}, this._uniformsArray = [], this._samplersList = {}, this._samplerDefines = {}, this.directIntensity = 1, this.environmentIntensity = 1, this.useSpecularWeightFromTextureAlpha = !1, this.forceAlphaTest = !1, this.alphaCutOff = 0.4, this.useAmbientOcclusionFromMetallicTextureRed = !1, this.useAmbientInGrayScale = !1, this.useObjectSpaceNormalMap = !1, this.useParallax = !1, this.useParallaxOcclusion = !1, this.parallaxScaleBias = 0.05, this.disableLighting = !1, this.forceIrradianceInFragment = !1, this.maxSimultaneousLights = 4, this.invertNormalMapX = !1, this.invertNormalMapY = !1, this.twoSidedLighting = !1, this.useAlphaFresnel = !1, this.useLinearAlphaFresnel = !1, this.environmentBRDFTexture = null, this.forceNormalForward = !1, this.enableSpecularAntiAliasing = !1, this.useHorizonOcclusion = !0, this.useRadianceOcclusion = !0, this.unlit = !1, this.applyDecalMapAfterDetailMap = !1, this._lightingInfos = new je(this.directIntensity, 1, this.environmentIntensity, 1), this._radianceTexture = null, this._useSpecularWeightFromAlpha = !1, this._useSpecularWeightFromSpecularColorTexture = !1, this._useSpecularRoughnessAnisotropyFromTangentTexture = !1, this._useCoatRoughnessAnisotropyFromTangentTexture = !1, this._useCoatRoughnessFromGreenChannel = !1, this._useGltfStyleAnisotropy = !1, this._useFuzzRoughnessFromTextureAlpha = !1, this._useSubsurfaceWeightFromTextureAlpha = !1, this._useHorizonOcclusion = !0, this._useRadianceOcclusion = !0, this._useAlphaFromBaseColorTexture = !1, this._useAmbientOcclusionFromMetallicTextureRed = !1, this._useRoughnessFromMetallicTextureGreen = !1, this._useMetallicFromMetallicTextureBlue = !1, this._useThinFilmThicknessFromTextureGreen = !1, this._useGeometryThicknessFromGreenChannel = !1, this._lightFalloff = k.LIGHTFALLOFF_PHYSICAL, this._useObjectSpaceNormalMap = !1, this._useParallax = !1, this._useParallaxOcclusion = !1, this._parallaxScaleBias = 0.05, this._disableLighting = !1, this._maxSimultaneousLights = 4, this._invertNormalMapX = !1, this._invertNormalMapY = !1, this._twoSidedLighting = !1, this._alphaCutOff = 0.4, this._useAlphaFresnel = !1, this._useLinearAlphaFresnel = !1, this._environmentBRDFTexture = null, this._environmentFuzzBRDFTexture = null, this._backgroundRefractionTexture = null, this._refractionHighQualityBlur = !0, this._forceIrradianceInFragment = !1, this._realTimeFiltering = !1, this._realTimeFilteringQuality = 8, this._fuzzSampleNumber = 4, this._forceNormalForward = !1, this._enableSpecularAntiAliasing = !1, this._renderTargets = new Qe(16), this._unlit = !1, this._applyDecalMapAfterDetailMap = !1, this._debugMode = 0, this._shadersLoaded = !1, this._breakShaderLoadedCheck = !1, this._vertexPullingMetadata = null, this.debugMode = 0, this.debugLimit = -1, this.debugFactor = 1, this._cacheHasRenderTargetTextures = !1, this._transparencyMode = k.MATERIAL_OPAQUE, this.getScene() && !this.getScene()?.getEngine().isWebGPU && this.getScene().getEngine().webGLVersion < 2 && se.Error("OpenPBRMaterial: WebGL 2.0 or above is required for this material."), r._noiseTextures[this.getScene().uniqueId] || (r._noiseTextures[this.getScene().uniqueId] = new re(qe.GetAssetUrl("https://assets.babylonjs.com/core/blue_noise/blue_noise_rgb.png"), this.getScene(), !1, !0, 1), this.getScene().onDisposeObservable.addOnce(() => {
+      r._noiseTextures[this.getScene().uniqueId]?.dispose(), delete r._noiseTextures[this.getScene().uniqueId];
+    })), this._attachImageProcessingConfiguration(null), this.getRenderTargetTextures = () => (this._renderTargets.reset(), H.ReflectionTextureEnabled && this._radianceTexture && this._radianceTexture.isRenderTarget && this._renderTargets.push(this._radianceTexture), H.RefractionTextureEnabled && this._backgroundRefractionTexture && this._backgroundRefractionTexture.isRenderTarget && this._renderTargets.push(this._backgroundRefractionTexture), this._eventInfo.renderTargets = this._renderTargets, this._callbackPluginEventFillRenderTargetTextures(this._eventInfo), this._renderTargets), this._environmentBRDFTexture = Ft(this.getScene()), this._environmentFuzzBRDFTexture = Ie(this.getScene()), this.prePassConfiguration = new Se(), this._propertyList = {};
+    for (const n of Object.getOwnPropertyNames(this)) {
+      const a = this[n];
+      a instanceof v && (this._propertyList[n] = a);
+    }
+    Object.keys(this._propertyList).forEach((n) => {
+      const a = this._propertyList[n];
+      let f = this._uniformsList[a.targetUniformName];
+      f ? f.numComponents !== a.targetUniformComponentNum ? se.Error(`Uniform ${a.targetUniformName} already exists of size ${f.numComponents}, but trying to set it to ${a.targetUniformComponentNum}.`) : f.requiredDefine !== a.requiredDefine && (f.requiredDefine = void 0) : (f = new ne(a.targetUniformName, a.targetUniformComponentNum), f.requiredDefine = a.requiredDefine, this._uniformsList[a.targetUniformName] = f), f.firstLinkedKey === "" && (f.firstLinkedKey = a.name), f.linkedProperties[a.name] = a;
+    }), this._uniformsArray = Object.values(this._uniformsList), this._samplersList = {};
+    for (const n of Object.getOwnPropertyNames(this)) {
+      const a = this[n];
+      a instanceof O && (this._samplersList[n] = a);
+    }
+    for (const n in this._samplersList) {
+      const f = this._samplersList[n].textureDefine;
+      this._samplerDefines[f] = { type: "boolean", default: !1 }, this._samplerDefines[f + "DIRECTUV"] = { type: "number", default: 0 }, this._samplerDefines[f + "_GAMMA"] = { type: "boolean", default: !1 };
+    }
+    this._baseWeight, this._baseWeightTexture, this._baseColor, this._baseColorTexture, this._baseDiffuseRoughness, this._baseDiffuseRoughnessTexture, this._baseMetalness, this._baseMetalnessTexture, this._specularWeight, this._specularWeightTexture, this._specularColor, this._specularColorTexture, this._specularRoughness, this._specularIor, this._specularRoughnessTexture, this._specularRoughnessAnisotropy, this._specularRoughnessAnisotropyTexture, this._transmissionWeight, this._transmissionWeightTexture, this._transmissionColor, this._transmissionColorTexture, this._transmissionDepth, this._transmissionDepthTexture, this._transmissionScatter, this._transmissionScatterTexture, this._transmissionScatterAnisotropy, this._transmissionDispersionScale, this._transmissionDispersionScaleTexture, this._transmissionDispersionAbbeNumber, this._subsurfaceWeight, this._subsurfaceWeightTexture, this._subsurfaceColor, this._subsurfaceColorTexture, this._subsurfaceRadius, this._subsurfaceRadiusScale, this._subsurfaceRadiusScaleTexture, this._subsurfaceScatterAnisotropy, this._coatWeight, this._coatWeightTexture, this._coatColor, this._coatColorTexture, this._coatRoughness, this._coatRoughnessTexture, this._coatRoughnessAnisotropy, this._coatRoughnessAnisotropyTexture, this._coatIor, this._coatDarkening, this._coatDarkeningTexture, this._fuzzWeight, this._fuzzWeightTexture, this._fuzzColor, this._fuzzColorTexture, this._fuzzRoughness, this._fuzzRoughnessTexture, this._geometryThinWalled, this._geometryNormalTexture, this._geometryTangent, this._geometryTangentTexture, this._geometryCoatNormalTexture, this._geometryCoatTangent, this._geometryCoatTangentTexture, this._geometryOpacity, this._geometryOpacityTexture, this._geometryThickness, this._geometryThicknessTexture, this._thinFilmWeight, this._thinFilmWeightTexture, this._thinFilmThickness, this._thinFilmThicknessMin, this._thinFilmThicknessTexture, this._thinFilmIor, this._emissionLuminance, this._emissionColor, this._emissionColorTexture, this._ambientOcclusionTexture;
+  }
+  /**
+   * Gets a boolean indicating that current material needs to register RTT
+   */
+  get hasRenderTargetTextures() {
+    return H.ReflectionTextureEnabled && this._radianceTexture && this._radianceTexture.isRenderTarget || H.RefractionTextureEnabled && this._backgroundRefractionTexture && this._backgroundRefractionTexture.isRenderTarget ? !0 : this._cacheHasRenderTargetTextures;
+  }
+  /**
+   * Can this material render to prepass
+   */
+  get isPrePassCapable() {
+    return !this.disableDepthWrite;
+  }
+  /**
+   * @returns the name of the material class.
+   */
+  getClassName() {
+    return "OpenPBRMaterial";
+  }
+  get transparencyMode() {
+    return this._transparencyMode;
+  }
+  set transparencyMode(t) {
+    this._transparencyMode !== t && (this._transparencyMode = t, this._markAllSubMeshesAsTexturesAndMiscDirty());
+  }
+  /**
+   * @returns whether or not the alpha value of the albedo texture should be used for alpha blending.
+   */
+  _shouldUseAlphaFromBaseColorTexture() {
+    return this._hasAlphaChannel() && this._transparencyMode !== k.MATERIAL_OPAQUE && !this.geometryOpacityTexture;
+  }
+  /**
+   * @returns whether or not there is a usable alpha channel for transparency.
+   */
+  _hasAlphaChannel() {
+    return this.baseColorTexture != null && this.baseColorTexture.hasAlpha && this._useAlphaFromBaseColorTexture || this.geometryOpacityTexture != null;
+  }
+  /**
+   * Makes a duplicate of the current material.
+   * @param name - name to use for the new material.
+   * @param cloneTexturesOnlyOnce - if a texture is used in more than one channel (e.g baseColor and opacity), only clone it once and reuse it on the other channels. Default false.
+   * @param rootUrl defines the root URL to use to load textures
+   * @returns cloned material instance
+   */
+  clone(t, s = !0, e = "") {
+    const i = Ae.Clone(() => new r(t, this.getScene()), this, { cloneTexturesOnlyOnce: s });
+    return i.id = t, i.name = t, this.stencil.copyTo(i.stencil), this._clonePlugins(i, e), i;
+  }
+  /**
+   * Serializes this PBR Material.
+   * @returns - An object with the serialized material.
+   */
+  serialize() {
+    const t = super.serialize();
+    return t.customType = "BABYLON.OpenPBRMaterial", t;
+  }
+  // Statics
+  /**
+   * Parses a PBR Material from a serialized object.
+   * @param source - Serialized object.
+   * @param scene - BJS scene instance.
+   * @param rootUrl - url for the scene object
+   * @returns - OpenPBRMaterial
+   */
+  static Parse(t, s, e) {
+    const i = Ae.Parse(() => new r(t.name, s), t, s, e);
+    return t.stencil && i.stencil.parse(t.stencil, s, e), k._ParsePlugins(t, i, s, e), i;
+  }
+  /**
+   * Force shader compilation
+   * @param mesh - Define the mesh we want to force the compilation for
+   * @param onCompiled - Define a callback triggered when the compilation completes
+   * @param options - Define the options used to create the compilation
+   */
+  forceCompilation(t, s, e) {
+    const i = {
+      clipPlane: !1,
+      useInstances: !1,
+      ...e
+    };
+    this._uniformBufferLayoutBuilt || this.buildUniformLayout(), this._callbackPluginEventGeneric(4, this._eventInfo), (() => {
+      if (this._breakShaderLoadedCheck)
+        return;
+      const a = new ye({
+        ...this._eventInfo.defineNames || {},
+        ...this._samplerDefines || {}
+      }), f = this._prepareEffect(t, t, a, void 0, void 0, i.useInstances, i.clipPlane);
+      this._onEffectCreatedObservable && (ie.effect = f, ie.subMesh = null, this._onEffectCreatedObservable.notifyObservers(ie)), f.isReady() ? s && s(this) : f.onCompileObservable.add(() => {
+        s && s(this);
+      });
+    })();
+  }
+  /**
+   * Specifies that the submesh is ready to be used.
+   * @param mesh - BJS mesh.
+   * @param subMesh - A submesh of the BJS mesh.  Used to check if it is ready.
+   * @param useInstances - Specifies that instances should be used.
+   * @returns - boolean indicating that the submesh is ready or not.
+   */
+  isReadyForSubMesh(t, s, e) {
+    this._uniformBufferLayoutBuilt || this.buildUniformLayout();
+    const i = s._drawWrapper;
+    if (i.effect && this.isFrozen && i._wasPreviouslyReady && i._wasPreviouslyUsingInstances === e)
+      return !0;
+    s.materialDefines || (this._callbackPluginEventGeneric(4, this._eventInfo), s.materialDefines = new ye({
+      ...this._eventInfo.defineNames || {},
+      ...this._samplerDefines || {}
+    }));
+    const n = s.materialDefines;
+    if (this._isReadyForSubMesh(s))
+      return !0;
+    const a = this.getScene(), f = a.getEngine();
+    if (n._areTexturesDirty && (this._eventInfo.hasRenderTargetTextures = !1, this._callbackPluginEventHasRenderTargetTextures(this._eventInfo), this._cacheHasRenderTargetTextures = this._eventInfo.hasRenderTargetTextures, a.texturesEnabled)) {
+      for (const N in this._samplersList) {
+        const x = this._samplersList[N];
+        if (x.value && !x.value.isReadyOrNotBlocking())
+          return !1;
+      }
+      const A = this._getRadianceTexture();
+      if (A && H.ReflectionTextureEnabled) {
+        if (!A.isReadyOrNotBlocking())
+          return !1;
+        if (A.irradianceTexture) {
+          if (!A.irradianceTexture.isReadyOrNotBlocking())
+            return !1;
+        } else if (!A.sphericalPolynomial && A.getInternalTexture()?._sphericalPolynomialPromise)
+          return !1;
+      }
+      if (this._environmentBRDFTexture && H.ReflectionTextureEnabled && !this._environmentBRDFTexture.isReady() || this._environmentFuzzBRDFTexture && H.ReflectionTextureEnabled && !this._environmentFuzzBRDFTexture.isReady() || this._backgroundRefractionTexture && H.RefractionTextureEnabled && !this._backgroundRefractionTexture.isReadyOrNotBlocking() || r._noiseTextures[a.uniqueId] && !r._noiseTextures[a.uniqueId].isReady() || this._sssIrradianceTexture && this._sssDepthTexture && (!this._sssIrradianceTexture.isReady() || !this._sssDepthTexture.isReady()))
+        return !1;
+    }
+    if (this._eventInfo.isReadyForSubMesh = !0, this._eventInfo.defines = n, this._eventInfo.subMesh = s, this._callbackPluginEventIsReadyForSubMesh(this._eventInfo), !this._eventInfo.isReadyForSubMesh || n._areImageProcessingDirty && this._imageProcessingConfiguration && !this._imageProcessingConfiguration.isReady())
+      return !1;
+    if (n.AREALIGHTUSED) {
+      for (let A = 0; A < t.lightSources.length; A++)
+        if (!t.lightSources[A]._isReady())
+          return !1;
+    }
+    if (!f.getCaps().standardDerivatives && !t.isVerticesDataPresent(G.NormalKind) && (t.createNormals(!0), se.Warn("OpenPBRMaterial: Normals have been created for the mesh: " + t.name)), !Je(a, t, this._maxSimultaneousLights, this._disableLighting))
+      return !1;
+    const I = s.effect, L = n._areLightsDisposed, h = this._prepareEffect(t, s.getRenderingMesh(), n, this.onCompiled, this.onError, e, null);
+    let u = !1;
+    if (h)
+      if (this._onEffectCreatedObservable && (ie.effect = h, ie.subMesh = s, this._onEffectCreatedObservable.notifyObservers(ie)), this.allowShaderHotSwapping && I && !h.isReady()) {
+        if (n.markAsUnprocessed(), u = this.isFrozen, L)
+          return n._areLightsDisposed = !0, !1;
+      } else
+        a.resetCachedMaterial(), s.setEffect(h, n, this._materialContext);
+    return !s.effect || !s.effect.isReady() ? !1 : (n._renderId = a.getRenderId(), i._wasPreviouslyReady = !u, i._wasPreviouslyUsingInstances = !!e, this._checkScenePerformancePriority(), !0);
+  }
+  /**
+   * Initializes the uniform buffer layout for the shader.
+   */
+  buildUniformLayout() {
+    const t = this._uniformBuffer;
+    t.addUniform("vTangentSpaceParams", 2), t.addUniform("vLightingIntensity", 4), t.addUniform("pointSize", 1), t.addUniform("vDebugMode", 2), t.addUniform("renderTargetSize", 2), t.addUniform("cameraInfo", 4), t.addUniform("vTextureRepetitionHexTilingParams", 4), t.addUniform("backgroundRefractionMatrix", 16), t.addUniform("vBackgroundRefractionInfos", 3), et(t, !0, !0, !0, !0, !0), Object.values(this._uniformsList).forEach((s) => {
+      t.addUniform(s.name, s.numComponents);
+    }), Object.values(this._samplersList).forEach((s) => {
+      t.addUniform(s.samplerInfoName, 2), t.addUniform(s.samplerMatrixName, 16);
+    }), super.buildUniformLayout();
+  }
+  /**
+   * Binds the material data (this function is called even if mustRebind() returns false)
+   * @param uniformBuffer defines the Uniform buffer to fill in.
+   * @param scene defines the scene the material belongs to.
+   * @param engine defines the engine the material belongs to.
+   * @param subMesh the submesh to bind data for
+   */
+  bindPropertiesForSubMesh(t, s, e, i) {
+    if (this.geometryThickness === 0)
+      t.updateFloat("vGeometryThickness", 0);
+    else {
+      i.getRenderingMesh().getWorldMatrix().decompose(X.Vector3[0]);
+      const n = Math.max(Math.abs(X.Vector3[0].x), Math.abs(X.Vector3[0].y), Math.abs(X.Vector3[0].z));
+      t.updateFloat("vGeometryThickness", this.geometryThickness * n);
+    }
+  }
+  /**
+   * Binds the submesh data.
+   * @param world - The world matrix.
+   * @param mesh - The BJS mesh.
+   * @param subMesh - A submesh of the BJS mesh.
+   */
+  bindForSubMesh(t, s, e) {
+    const i = this.getScene(), n = e.materialDefines;
+    if (!n)
+      return;
+    const a = e.effect;
+    if (!a)
+      return;
+    this._activeEffect = a, s.getMeshUniformBuffer().bindToEffect(a, "Mesh"), s.transferToEffect(t);
+    const f = i.getEngine();
+    this._uniformBuffer.bindToEffect(a, "Material"), this.prePassConfiguration.bindForSubMesh(this._activeEffect, i, s, t, this.isFrozen), ce.Bind(f.currentRenderPassId, this._activeEffect, s, t, this);
+    const I = i.activeCamera;
+    I ? this._uniformBuffer.updateFloat4("cameraInfo", I.minZ, I.maxZ, 0, 0) : this._uniformBuffer.updateFloat4("cameraInfo", 0, 0, 0, 0);
+    const L = this.textureRepetitionHexTilingParams;
+    this._uniformBuffer.updateFloat4("vTextureRepetitionHexTilingParams", L[0], L[1], L[2], L[3]), this._eventInfo.subMesh = e, this._callbackPluginEventHardBindForSubMesh(this._eventInfo), n.OBJECTSPACE_NORMALMAP && (t.toNormalMatrix(this._normalMatrix), this.bindOnlyNormalMatrix(this._normalMatrix));
+    const h = this._mustRebind(i, a, e, s.visibility);
+    tt(s, this._activeEffect, this.prePassConfiguration), this._vertexPullingMetadata && it(this._activeEffect, this._vertexPullingMetadata);
+    const u = this._uniformBuffer;
+    if (h) {
+      this.bindViewProjection(a);
+      const A = this._getRadianceTexture();
+      if (!u.useUbo || !this.isFrozen || !u.isSync || e._drawWrapper._forceRebindOnNextCall) {
+        if (i.texturesEnabled) {
+          for (const x in this._samplersList) {
+            const M = this._samplersList[x];
+            M.value && (u.updateFloat2(M.samplerInfoName, M.value.coordinatesIndex, M.value.level), st(M.value, u, M.samplerPrefix));
+          }
+          (this.geometryNormalTexture || this.geometryCoatNormalTexture) && (i._mirroredCameraPosition ? u.updateFloat2("vTangentSpaceParams", this._invertNormalMapX ? 1 : -1, this._invertNormalMapY ? 1 : -1) : u.updateFloat2("vTangentSpaceParams", this._invertNormalMapX ? -1 : 1, this._invertNormalMapY ? -1 : 1)), rt(i, n, u, K.White(), A, this.realTimeFiltering, !0, !0, !0, !0, !0);
+        }
+        this.pointsCloud && u.updateFloat("pointSize", this.pointSize);
+        const N = this._uniformsArray;
+        for (let x = 0, M = N.length; x < M; x++) {
+          const R = N[x];
+          R.requiredDefine !== void 0 && !n[R.requiredDefine] || (R.numComponents === 4 ? (R.populateVectorFromLinkedProperties(X.Vector4[0]), u.updateVector4(R.name, X.Vector4[0])) : R.numComponents === 3 ? (R.populateVectorFromLinkedProperties(X.Vector3[0]), u.updateVector3(R.name, X.Vector3[0])) : R.numComponents === 2 ? (R.populateVectorFromLinkedProperties(X.Vector2[0]), u.updateFloat2(R.name, X.Vector2[0].x, X.Vector2[0].y)) : R.numComponents === 1 && u.updateFloat(R.name, R.linkedProperties[R.firstLinkedKey].value));
+        }
+        this._lightingInfos.x = this.directIntensity, this._lightingInfos.y = this.emissionLuminance, this._lightingInfos.z = this.environmentIntensity * i.environmentIntensity, this._lightingInfos.w = 1, u.updateVector4("vLightingIntensity", this._lightingInfos), u.updateFloat2("vDebugMode", this.debugLimit, this.debugFactor);
+      }
+      if (i.texturesEnabled) {
+        for (const N in this._samplersList) {
+          const x = this._samplersList[N];
+          x.value && u.setTexture(x.samplerName, x.value);
+        }
+        if (nt(i, n, u, A, this.realTimeFiltering), n.ENVIRONMENTBRDF && u.setTexture("environmentBrdfSampler", this._environmentBRDFTexture), n.FUZZENVIRONMENTBRDF && u.setTexture("environmentFuzzBrdfSampler", this._environmentFuzzBRDFTexture), n.REFRACTED_BACKGROUND && (u.setTexture("backgroundRefractionSampler", this._backgroundRefractionTexture), u.updateMatrix("backgroundRefractionMatrix", this._backgroundRefractionTexture.getReflectionTextureMatrix()), X.Vector3[1].set(Math.log2(this._backgroundRefractionTexture.getSize().width), 0, 0), u.updateVector3("vBackgroundRefractionInfos", X.Vector3[1])), (n.ANISOTROPIC || n.FUZZ || n.REFRACTED_BACKGROUND || n.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING) && u.setTexture("blueNoiseSampler", r._noiseTextures[this.getScene().uniqueId]), n.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING && this.sssIrradianceTexture && this.sssDepthTexture) {
+          const N = this.sssIrradianceTexture.getSize().width, x = this.sssIrradianceTexture.getSize().height;
+          u.setTexture("sceneIrradianceSampler", this.sssIrradianceTexture), u.setTexture("sceneDepthSampler", this.sssDepthTexture), u.updateFloat2("renderTargetSize", N, x);
+        }
+      }
+      this.getScene().useOrderIndependentTransparency && this.needAlphaBlendingForMesh(s) && this.getScene().depthPeelingRenderer.bind(a), this._eventInfo.subMesh = e, this._callbackPluginEventBindForSubMesh(this._eventInfo), Pe(this._activeEffect, this, i), this.bindEyePosition(a);
+    } else i.getEngine()._features.needToAlwaysBindUniformBuffers && (this._needToBindSceneUbo = !0);
+    this.bindPropertiesForSubMesh(this._uniformBuffer, i, i.getEngine(), e), (h || !this.isFrozen) && (i.lightsEnabled && !this._disableLighting && at(i, s, this._activeEffect, n, this._maxSimultaneousLights), this.bindView(a), ot(i, s, this._activeEffect, !0), n.NUM_MORPH_INFLUENCERS && Ue(s, this._activeEffect), n.BAKED_VERTEX_ANIMATION_TEXTURE && s.bakedVertexAnimationManager?.bind(a, n.INSTANCES), this._imageProcessingConfiguration.bind(this._activeEffect), lt(n, this._activeEffect, i)), this._afterBind(s, this._activeEffect, e), u.update();
+  }
+  /**
+   * Returns the animatable textures.
+   * If material have animatable metallic texture, then reflectivity texture will not be returned, even if it has animations.
+   * @returns - Array of animatable textures.
+   */
+  getAnimatables() {
+    const t = super.getAnimatables();
+    for (const s in this._samplersList) {
+      const e = this._samplersList[s];
+      e.value && e.value.animations && e.value.animations.length > 0 && t.push(e.value);
+    }
+    return this._radianceTexture && this._radianceTexture.animations && this._radianceTexture.animations.length > 0 && t.push(this._radianceTexture), t;
+  }
+  /**
+   * Returns an array of the actively used textures.
+   * @returns - Array of BaseTextures
+   */
+  getActiveTextures() {
+    const t = super.getActiveTextures();
+    for (const s in this._samplersList) {
+      const e = this._samplersList[s];
+      e.value && t.push(e.value);
+    }
+    return this._radianceTexture && t.push(this._radianceTexture), t;
+  }
+  /**
+   * Checks to see if a texture is used in the material.
+   * @param texture - Base texture to use.
+   * @returns - Boolean specifying if a texture is used in the material.
+   */
+  hasTexture(t) {
+    if (super.hasTexture(t))
+      return !0;
+    for (const s in this._samplersList)
+      if (this._samplersList[s].value === t)
+        return !0;
+    return this._radianceTexture === t;
+  }
+  /**
+   * Sets the required values to the prepass renderer.
+   * It can't be sets when subsurface scattering of this material is disabled.
+   * When scene have ability to enable subsurface prepass effect, it will enable.
+   * @returns - If prepass is enabled or not.
+   */
+  setPrePassRenderer() {
+    return !1;
+  }
+  /**
+   * Disposes the resources of the material.
+   * @param forceDisposeEffect - Forces the disposal of effects.
+   * @param forceDisposeTextures - Forces the disposal of all textures.
+   */
+  dispose(t, s) {
+    if (this._breakShaderLoadedCheck = !0, s) {
+      this._environmentBRDFTexture && this.getScene().openPBREnvironmentBRDFTexture !== this._environmentBRDFTexture && this._environmentBRDFTexture.dispose(), this._environmentFuzzBRDFTexture && this.getScene().environmentFuzzBRDFTexture !== this._environmentFuzzBRDFTexture && this._environmentFuzzBRDFTexture.dispose(), this._backgroundRefractionTexture = null;
+      for (const e in this._samplersList)
+        this._samplersList[e].value?.dispose();
+      this._radianceTexture?.dispose();
+    }
+    this._renderTargets.dispose(), this._imageProcessingConfiguration && this._imageProcessingObserver && this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver), super.dispose(t, s);
+  }
+  /**
+   * Returns the texture used for reflections.
+   * @returns - Reflection texture if present.  Otherwise, returns the environment texture.
+   */
+  _getRadianceTexture() {
+    return this._radianceTexture ? this._radianceTexture : this.getScene().environmentTexture;
+  }
+  _prepareEffect(t, s, e, i = null, n = null, a = null, f = null) {
+    if (this._prepareDefines(t, s, e, a, f), !e.isDirty)
+      return null;
+    e.markAsProcessed();
+    const L = this.getScene().getEngine(), h = new ut();
+    let u = 0;
+    e.USESPHERICALINVERTEX && h.addFallback(u++, "USESPHERICALINVERTEX"), e.FOG && h.addFallback(u, "FOG"), e.SPECULARAA && h.addFallback(u, "SPECULARAA"), e.POINTSIZE && h.addFallback(u, "POINTSIZE"), e.LOGARITHMICDEPTH && h.addFallback(u, "LOGARITHMICDEPTH"), e.PARALLAX && h.addFallback(u, "PARALLAX"), e.PARALLAX_RHS && h.addFallback(u, "PARALLAX_RHS"), e.PARALLAXOCCLUSION && h.addFallback(u++, "PARALLAXOCCLUSION"), e.ENVIRONMENTBRDF && h.addFallback(u++, "ENVIRONMENTBRDF"), e.TANGENT && h.addFallback(u++, "TANGENT"), u = ft(e, h, this._maxSimultaneousLights, u), e.SPECULARTERM && h.addFallback(u++, "SPECULARTERM"), e.USESPHERICALFROMREFLECTIONMAP && h.addFallback(u++, "USESPHERICALFROMREFLECTIONMAP"), e.USEIRRADIANCEMAP && h.addFallback(u++, "USEIRRADIANCEMAP"), e.NORMAL && h.addFallback(u++, "NORMAL"), e.VERTEXCOLOR && h.addFallback(u++, "VERTEXCOLOR"), e.MORPHTARGETS && h.addFallback(u++, "MORPHTARGETS"), e.MULTIVIEW && h.addFallback(0, "MULTIVIEW");
+    const A = [G.PositionKind];
+    e.NORMAL && A.push(G.NormalKind), e.TANGENT && A.push(G.TangentKind);
+    for (let S = 1; S <= 6; ++S)
+      e["UV" + S] && A.push(`uv${S === 1 ? "" : S}`);
+    e.VERTEXCOLOR && A.push(G.ColorKind), ct(A, t, e, h), ht(A, e), dt(A, t, e), _t(A, t, e);
+    let N = "openpbr";
+    const x = [
+      "world",
+      "view",
+      "viewProjection",
+      "projection",
+      "vEyePosition",
+      "inverseProjection",
+      "renderTargetSize",
+      "vLightsType",
+      "visibility",
+      "vFogInfos",
+      "vFogColor",
+      "pointSize",
+      "mBones",
+      "normalMatrix",
+      "vLightingIntensity",
+      "logarithmicDepthConstant",
+      "vTangentSpaceParams",
+      "boneTextureInfo",
+      "vDebugMode",
+      "morphTargetTextureInfo",
+      "morphTargetTextureIndices",
+      "cameraInfo",
+      "vTextureRepetitionHexTilingParams",
+      "backgroundRefractionMatrix",
+      "vBackgroundRefractionInfos"
+    ];
+    for (const S in this._uniformsList)
+      x.push(S);
+    const M = ["environmentBrdfSampler", "boneSampler", "morphTargets", "oitDepthSampler", "oitFrontColorSampler", "areaLightsLTC1Sampler", "areaLightsLTC2Sampler"];
+    e.FUZZENVIRONMENTBRDF && M.push("environmentFuzzBrdfSampler"), e.REFRACTED_BACKGROUND && M.push("backgroundRefractionSampler"), (e.ANISOTROPIC || e.FUZZ || e.REFRACTED_BACKGROUND || e.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING) && M.push("blueNoiseSampler"), e.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING && (M.push("sceneIrradianceSampler"), M.push("sceneDepthSampler"));
+    for (const S in this._samplersList) {
+      const c = this._samplersList[S];
+      M.push(c.samplerName), x.push(c.samplerInfoName), x.push(c.samplerMatrixName);
+    }
+    Be(x, M, !0);
+    const R = ["Material", "Scene", "Mesh"], T = { maxSimultaneousLights: this._maxSimultaneousLights, maxSimultaneousMorphTargets: e.NUM_MORPH_INFLUENCERS };
+    if (this._eventInfo.fallbacks = h, this._eventInfo.fallbackRank = u, this._eventInfo.defines = e, this._eventInfo.uniforms = x, this._eventInfo.attributes = A, this._eventInfo.samplers = M, this._eventInfo.uniformBuffersNames = R, this._eventInfo.customCode = void 0, this._eventInfo.mesh = t, this._eventInfo.indexParameters = T, this._callbackPluginEventGeneric(128, this._eventInfo), ce.AddUniformsAndSamplers(x, M), Se.AddUniforms(x), Ve(x), this._useVertexPulling) {
+      const S = s?.geometry;
+      S && (this._vertexPullingMetadata = Tt(S), this._vertexPullingMetadata && this._vertexPullingMetadata.forEach((c, Y) => {
+        x.push(`vp_${Y}_info`);
+      }));
+    } else
+      this._vertexPullingMetadata = null;
+    he && (he.PrepareUniforms(x, e), he.PrepareSamplers(M, e)), mt({
+      uniformsNames: x,
+      uniformBuffersNames: R,
+      samplers: M,
+      defines: e,
+      maxSimultaneousLights: this._maxSimultaneousLights,
+      shaderLanguage: this._shaderLanguage
+    });
+    const m = {};
+    this.customShaderNameResolve && (N = this.customShaderNameResolve(N, x, R, M, e, A, m));
+    const F = e.toString(), y = L.createEffect(N, {
+      attributes: A,
+      uniformsNames: x,
+      uniformBuffersNames: R,
+      samplers: M,
+      defines: F,
+      fallbacks: h,
+      onCompiled: i,
+      onError: n,
+      indexParameters: T,
+      processFinalCode: m.processFinalCode,
+      processCodeAfterIncludes: this._eventInfo.customCode,
+      multiTarget: e.PREPASS,
+      shaderLanguage: this._shaderLanguage,
+      extraInitializationsAsync: this._shadersLoaded ? void 0 : async () => {
+        this.shaderLanguage === 1 ? await Promise.all([import("./openpbr.vertex-DMdFRTnX.js"), import("./openpbr.fragment-BglYS6LA.js")]) : await Promise.all([import("./openpbr.vertex-B-PaLFOR.js"), import("./openpbr.fragment-DrOTZs4m.js")]), this._shadersLoaded = !0;
+      }
+    }, L);
+    return this._eventInfo.customCode = void 0, y;
+  }
+  _prepareDefines(t, s, e, i = null, n = null) {
+    const a = s.hasThinInstances, f = this.getScene(), I = f.getEngine();
+    pt(f, t, e, !0, this._maxSimultaneousLights, this._disableLighting), e._needNormals = !0, Et(f, e);
+    const L = this.needAlphaBlendingForMesh(t) && this.getScene().useOrderIndependentTransparency;
+    if (Rt(f, e, this.canRenderToMRT && !L), gt(f, e, L), ce.PrepareDefines(I.currentRenderPassId, t, e), e._areTexturesDirty) {
+      e._needUVs = !1;
+      for (let u = 1; u <= 6; ++u)
+        e["MAINUV" + u] = !1;
+      if (f.texturesEnabled) {
+        for (const N in this._samplersList) {
+          const x = this._samplersList[N];
+          x.value ? (St(x.value, e, x.textureDefine), e[x.textureDefine + "_GAMMA"] = x.value.gammaSpace) : e[x.textureDefine] = !1;
+        }
+        const u = this._getRadianceTexture(), A = this._forceIrradianceInFragment || this.realTimeFiltering || this._twoSidedLighting || I.getCaps().maxVaryingVectors <= 8 || this._baseDiffuseRoughnessTexture != null;
+        if (De(f, u, e, this.realTimeFiltering, this.realTimeFilteringQuality, !A), this._baseMetalnessTexture && (e.AOSTOREINMETALMAPRED = this._useAmbientOcclusionFromMetallicTextureRed), e.SPECULAR_WEIGHT_IN_ALPHA = this._useSpecularWeightFromAlpha, e.SPECULAR_WEIGHT_FROM_SPECULAR_COLOR_TEXTURE = this._useSpecularWeightFromSpecularColorTexture, e.SPECULAR_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE = this._useSpecularRoughnessAnisotropyFromTangentTexture, e.COAT_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE = this._useCoatRoughnessAnisotropyFromTangentTexture, e.COAT_ROUGHNESS_FROM_GREEN_CHANNEL = this._useCoatRoughnessFromGreenChannel, e.SPECULAR_ROUGHNESS_FROM_METALNESS_TEXTURE_GREEN = this._useRoughnessFromMetallicTextureGreen, e.FUZZ_ROUGHNESS_FROM_TEXTURE_ALPHA = this._useFuzzRoughnessFromTextureAlpha, e.SUBSURFACE_WEIGHT_FROM_TEXTURE_ALPHA = this._useSubsurfaceWeightFromTextureAlpha, e.BASE_METALNESS_FROM_METALNESS_TEXTURE_BLUE = this._useMetallicFromMetallicTextureBlue, e.THIN_FILM_THICKNESS_FROM_THIN_FILM_TEXTURE = this._useThinFilmThicknessFromTextureGreen, e.GEOMETRY_THICKNESS_FROM_GREEN_CHANNEL = this._useGeometryThicknessFromGreenChannel, this.geometryNormalTexture ? (this._useParallax && this.baseColorTexture && H.DiffuseTextureEnabled ? (e.PARALLAX = !0, e.PARALLAX_RHS = f.useRightHandedSystem, e.PARALLAXOCCLUSION = !!this._useParallaxOcclusion) : e.PARALLAX = !1, e.OBJECTSPACE_NORMALMAP = this._useObjectSpaceNormalMap) : (e.PARALLAX = !1, e.PARALLAX_RHS = !1, e.PARALLAXOCCLUSION = !1, e.OBJECTSPACE_NORMALMAP = !1), this._environmentBRDFTexture && H.ReflectionTextureEnabled ? (e.ENVIRONMENTBRDF = !0, e.ENVIRONMENTBRDF_RGBD = this._environmentBRDFTexture.isRGBD) : (e.ENVIRONMENTBRDF = !1, e.ENVIRONMENTBRDF_RGBD = !1), this._environmentFuzzBRDFTexture ? e.FUZZENVIRONMENTBRDF = !0 : e.FUZZENVIRONMENTBRDF = !1, this.hasTransparency) {
+          e.REFRACTED_BACKGROUND = !!this._backgroundRefractionTexture && H.RefractionTextureEnabled, e.REFRACTION_HIGH_QUALITY_BLUR = this._refractionHighQualityBlur, e.REFRACTED_LIGHTS = !0;
+          const N = this._getRadianceTexture();
+          N ? (e.REFRACTED_ENVIRONMENT = H.RefractionTextureEnabled, e.REFRACTED_ENVIRONMENT_OPPOSITEZ = this.getScene().useRightHandedSystem ? !N.invertZ : N.invertZ, e.REFRACTED_ENVIRONMENT_LOCAL_CUBE = N.isCube && N.boundingBoxSize) : e.REFRACTED_ENVIRONMENT = !1;
+        } else
+          e.REFRACTED_BACKGROUND = !1, e.REFRACTED_LIGHTS = !1, e.REFRACTED_ENVIRONMENT = !1;
+        this._shouldUseAlphaFromBaseColorTexture() ? e.ALPHA_FROM_BASE_COLOR_TEXTURE = !0 : e.ALPHA_FROM_BASE_COLOR_TEXTURE = !1;
+      }
+      this._lightFalloff === k.LIGHTFALLOFF_STANDARD ? (e.USEPHYSICALLIGHTFALLOFF = !1, e.USEGLTFLIGHTFALLOFF = !1) : this._lightFalloff === k.LIGHTFALLOFF_GLTF ? (e.USEPHYSICALLIGHTFALLOFF = !1, e.USEGLTFLIGHTFALLOFF = !0) : (e.USEPHYSICALLIGHTFALLOFF = !0, e.USEGLTFLIGHTFALLOFF = !1), !this.backFaceCulling && this._twoSidedLighting ? e.TWOSIDEDLIGHTING = !0 : e.TWOSIDEDLIGHTING = !1, e.MIRRORED = !!f._mirroredCameraPosition, e.SPECULARAA = I.getCaps().standardDerivatives && this._enableSpecularAntiAliasing;
+    }
+    (e._areTexturesDirty || e._areMiscDirty) && (e.ALPHATESTVALUE = `${this._alphaCutOff}${this._alphaCutOff % 1 === 0 ? "." : ""}`, e.PREMULTIPLYALPHA = this.alphaMode === 7 || this.alphaMode === 8, e.ALPHABLEND = this.needAlphaBlendingForMesh(t)), e._areTexturesDirty && (e.TEXTURE_REPETITION_MODE = I.version > 1 || I.isWebGPU ? this.textureRepetitionMode : 0), e._areImageProcessingDirty && this._imageProcessingConfiguration && this._imageProcessingConfiguration.prepareDefines(e), e.FORCENORMALFORWARD = this._forceNormalForward, e.RADIANCEOCCLUSION = this._useRadianceOcclusion, e.HORIZONOCCLUSION = this._useHorizonOcclusion, (this.specularRoughnessAnisotropy > 0 || this.coatRoughnessAnisotropy > 0) && r._noiseTextures[f.uniqueId] && H.ReflectionTextureEnabled ? (e.ANISOTROPIC = !0, t.isVerticesDataPresent(G.TangentKind) || (e._needUVs = !0, e.MAINUV1 = !0), this._useGltfStyleAnisotropy && (e.USE_GLTF_STYLE_ANISOTROPY = !0), e.ANISOTROPIC_BASE = this.specularRoughnessAnisotropy > 0, e.ANISOTROPIC_COAT = this.coatRoughnessAnisotropy > 0) : (e.ANISOTROPIC = !1, e.USE_GLTF_STYLE_ANISOTROPY = !1, e.ANISOTROPIC_BASE = !1, e.ANISOTROPIC_COAT = !1), e.THIN_FILM = this.thinFilmWeight > 0, e.IRIDESCENCE = this.thinFilmWeight > 0, e.DISPERSION = this.transmissionDispersionScale > 0, e.SCATTERING = this.hasScattering;
+    const h = [8, 16, 32];
+    if (e.SSS_SAMPLE_COUNT = h[this._sssQuality] ?? 16, e.TRANSMISSION_SLAB = this.transmissionWeight > 0, e.TRANSMISSION_SLAB_VOLUME = this.transmissionWeight > 0 && this.transmissionDepth > 0, e.SUBSURFACE_SLAB = this.subsurfaceWeight > 0, !e.PREPASS && (e.SUBSURFACE_SLAB || e.TRANSMISSION_SLAB_VOLUME)) {
+      let u = !1;
+      if (!this.sssIrradianceTexture && f.geometryBufferRenderer) {
+        const A = f.geometryBufferRenderer.getTextureIndex(C.IRRADIANCE_TEXTURE_TYPE);
+        this.sssIrradianceTexture = f.geometryBufferRenderer.getGBuffer().textures[A], u = !0;
+      }
+      if (!this.sssDepthTexture && f.geometryBufferRenderer) {
+        const A = f.geometryBufferRenderer.getTextureIndex(C.SCREENSPACE_DEPTH_TEXTURE_TYPE);
+        this.sssDepthTexture = f.geometryBufferRenderer.getGBuffer().textures[A], u = !0;
+      }
+      this.sssIrradianceTexture && this.sssDepthTexture && (e.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING = !0, u && (e.USE_IRRADIANCE_TEXTURE_FOR_SCATTERING_GBUFFER = !0));
+    }
+    e.FUZZ = this.fuzzWeight > 0 && H.ReflectionTextureEnabled, e.GEOMETRY_THIN_WALLED = this.geometryThinWalled != 0, e.FUZZ ? (t.isVerticesDataPresent(G.TangentKind) || (e._needUVs = !0, e.MAINUV1 = !0), this._environmentFuzzBRDFTexture = Ie(this.getScene()), e.FUZZ_IBL_SAMPLES = this.fuzzSampleNumber) : (this._environmentFuzzBRDFTexture = null, e.FUZZENVIRONMENTBRDF = !1, e.FUZZ_IBL_SAMPLES = 0), e._areMiscDirty && (At(t, f, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(t), e, this._applyDecalMapAfterDetailMap, this._useVertexPulling, s, this._isVertexOutputInvariant), e.UNLIT = this._unlit || (this.pointsCloud || this.wireframe) && !t.isVerticesDataPresent(G.NormalKind), e.DEBUGMODE = this._debugMode), It(f, I, this, e, !!i, n, a), this._eventInfo.defines = e, this._eventInfo.mesh = t, this._callbackPluginEventPrepareDefinesBeforeAttributes(this._eventInfo), xt(t, e, !0, !0, !0, this._transparencyMode !== k.MATERIAL_OPAQUE), this._callbackPluginEventPrepareDefines(this._eventInfo);
+  }
+}
+r.SSS_QUALITY_LOW = 0;
+r.SSS_QUALITY_MEDIUM = 1;
+r.SSS_QUALITY_HIGH = 2;
+r._noiseTextures = {};
+r.ForceGLSL = !1;
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseDiffuseRoughness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseDiffuseRoughness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseDiffuseRoughnessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseDiffuseRoughnessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseMetalness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseMetalness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "baseMetalnessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_baseMetalnessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularRoughness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularRoughness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularRoughnessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularRoughnessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularRoughnessAnisotropy")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularRoughnessAnisotropy", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularRoughnessAnisotropyTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularRoughnessAnisotropyTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "specularIor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_specularIor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionDepth")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionDepth", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionDepthTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionDepthTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionScatter")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionScatter", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionScatterTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionScatterTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionScatterAnisotropy")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionScatterAnisotropy", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionDispersionScale")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionDispersionScale", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionDispersionScaleTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionDispersionScaleTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "transmissionDispersionAbbeNumber")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_transmissionDispersionAbbeNumber", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceRadius")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceRadius", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceRadiusScale")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceRadiusScale", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceRadiusScaleTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceRadiusScaleTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "subsurfaceScatterAnisotropy")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_subsurfaceScatterAnisotropy", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatRoughness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatRoughness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatRoughnessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatRoughnessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatRoughnessAnisotropy")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatRoughnessAnisotropy", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatRoughnessAnisotropyTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatRoughnessAnisotropyTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatIor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatIor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatDarkening")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatDarkening", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "coatDarkeningTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_coatDarkeningTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "fuzzWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_fuzzWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "fuzzWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_fuzzWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "fuzzColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_fuzzColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "fuzzColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_fuzzColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "fuzzRoughness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_fuzzRoughness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "fuzzRoughnessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_fuzzRoughnessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryThinWalled")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryThinWalled", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryNormalTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryNormalTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryTangent")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryTangent", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryTangentTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryTangentTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryCoatNormalTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryCoatNormalTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryCoatTangent")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryCoatTangent", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryCoatTangentTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryCoatTangentTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryOpacity")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryOpacity", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryOpacityTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryOpacityTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryThickness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryThickness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "geometryThicknessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_geometryThicknessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "emissionLuminance")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_emissionLuminance", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "emissionColor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_emissionColor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "emissionColorTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_emissionColorTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "thinFilmWeight")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_thinFilmWeight", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "thinFilmWeightTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_thinFilmWeightTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "thinFilmThickness")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_thinFilmThickness", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "thinFilmThicknessMin")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_thinFilmThicknessMin", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "thinFilmThicknessTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_thinFilmThicknessTexture", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "thinFilmIor")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_thinFilmIor", void 0);
+o([
+  d("_markAllSubMeshesAsTexturesDirty", "ambientOcclusionTexture")
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], r.prototype, "_ambientOcclusionTexture", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "directIntensity", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "environmentIntensity", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useSpecularWeightFromTextureAlpha", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesAndMiscDirty")
+], r.prototype, "forceAlphaTest", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesAndMiscDirty")
+], r.prototype, "alphaCutOff", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useAmbientInGrayScale", void 0);
+o([
+  D()
+], r.prototype, "usePhysicalLightFalloff", null);
+o([
+  D()
+], r.prototype, "useGLTFLightFalloff", null);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useObjectSpaceNormalMap", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useParallax", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useParallaxOcclusion", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "parallaxScaleBias", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsLightsDirty")
+], r.prototype, "disableLighting", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "forceIrradianceInFragment", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsLightsDirty")
+], r.prototype, "maxSimultaneousLights", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "invertNormalMapX", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "invertNormalMapY", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "twoSidedLighting", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useAlphaFresnel", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useLinearAlphaFresnel", void 0);
+o([
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "environmentBRDFTexture", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "forceNormalForward", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "enableSpecularAntiAliasing", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useHorizonOcclusion", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useRadianceOcclusion", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsMiscDirty")
+], r.prototype, "unlit", void 0);
+o([
+  D(),
+  P("_markAllSubMeshesAsMiscDirty")
+], r.prototype, "applyDecalMapAfterDetailMap", void 0);
+o([
+  P("_markAllSubMeshesAsMiscDirty")
+], r.prototype, "debugMode", void 0);
+o([
+  D()
+], r.prototype, "transparencyMode", null);
+Nt("BABYLON.OpenPBRMaterial", r);
+export {
+  r as OpenPBRMaterial,
+  ye as OpenPBRMaterialDefines
+};