@vived/component-abb-6700 1.0.0

package/dist/pbrMaterial-C4FCKBZQ.js

@@ -0,0 +1,1660 @@
+import { ac as P, a9 as v, bC as s, c6 as a, bS as r, y as d, aa as l, aw as p, u as I, c8 as x, c7 as M, be as q, bh as F, c9 as ee, b8 as V, bg as te, b1 as se, H as ie, al as w, a7 as re, j as ae, J as le, Z as ne, ao as ue, ap as oe, aq as he, an as Te, aD as _e, ab as X, g as ce, aF as Ee, _ as Y, aE as Ae, av as fe, ay as Se, aA as Re, az as xe, au as pe, ax as Ie, at as Ce, as as me, aC as de, l as be, v as ye, o as Le, b7 as H, p as Me, m as Ne, q as ge, aY as Oe, n as De, s as Fe, r as ve, a0 as Ue, aI as Pe, $ as ke, aG as He, ba as Ge, a8 as G, aZ as K, aK as Be } from "./index-CS3Icp_r.js";
+import { G as Z } from "./brdfTextureTools-DUyKBAXf.js";
+class Ve extends v {
+  constructor() {
+    super(...arguments), this.BRDF_V_HEIGHT_CORRELATED = !1, this.MS_BRDF_ENERGY_CONSERVATION = !1, this.SPHERICAL_HARMONICS = !1, this.SPECULAR_GLOSSINESS_ENERGY_CONSERVATION = !1, this.MIX_IBL_RADIANCE_WITH_IRRADIANCE = !0, this.LEGACY_SPECULAR_ENERGY_CONSERVATION = !1, this.BASE_DIFFUSE_MODEL = 0, this.DIELECTRIC_SPECULAR_MODEL = 0, this.CONDUCTOR_SPECULAR_MODEL = 0;
+  }
+}
+class c extends P {
+  /** @internal */
+  _markAllSubMeshesAsMiscDirty() {
+    this._internalMarkAllSubMeshesAsMiscDirty();
+  }
+  /**
+   * Gets a boolean indicating that the plugin is compatible with a given shader language.
+   * @returns true if the plugin is compatible with the shader language
+   */
+  isCompatible() {
+    return !0;
+  }
+  constructor(e, i = !0) {
+    super(e, "PBRBRDF", 90, new Ve(), i), this._useEnergyConservation = c.DEFAULT_USE_ENERGY_CONSERVATION, this.useEnergyConservation = c.DEFAULT_USE_ENERGY_CONSERVATION, this._useSmithVisibilityHeightCorrelated = c.DEFAULT_USE_SMITH_VISIBILITY_HEIGHT_CORRELATED, this.useSmithVisibilityHeightCorrelated = c.DEFAULT_USE_SMITH_VISIBILITY_HEIGHT_CORRELATED, this._useSphericalHarmonics = c.DEFAULT_USE_SPHERICAL_HARMONICS, this.useSphericalHarmonics = c.DEFAULT_USE_SPHERICAL_HARMONICS, this._useSpecularGlossinessInputEnergyConservation = c.DEFAULT_USE_SPECULAR_GLOSSINESS_INPUT_ENERGY_CONSERVATION, this.useSpecularGlossinessInputEnergyConservation = c.DEFAULT_USE_SPECULAR_GLOSSINESS_INPUT_ENERGY_CONSERVATION, this._mixIblRadianceWithIrradiance = c.DEFAULT_MIX_IBL_RADIANCE_WITH_IRRADIANCE, this.mixIblRadianceWithIrradiance = c.DEFAULT_MIX_IBL_RADIANCE_WITH_IRRADIANCE, this._useLegacySpecularEnergyConservation = c.DEFAULT_USE_LEGACY_SPECULAR_ENERGY_CONSERVATION, this.useLegacySpecularEnergyConservation = c.DEFAULT_USE_LEGACY_SPECULAR_ENERGY_CONSERVATION, this._baseDiffuseModel = c.DEFAULT_DIFFUSE_MODEL, this.baseDiffuseModel = c.DEFAULT_DIFFUSE_MODEL, this._dielectricSpecularModel = c.DEFAULT_DIELECTRIC_SPECULAR_MODEL, this.dielectricSpecularModel = c.DEFAULT_DIELECTRIC_SPECULAR_MODEL, this._conductorSpecularModel = c.DEFAULT_CONDUCTOR_SPECULAR_MODEL, this.conductorSpecularModel = c.DEFAULT_CONDUCTOR_SPECULAR_MODEL, this._internalMarkAllSubMeshesAsMiscDirty = e._dirtyCallbacks[16], this._enable(!0);
+  }
+  prepareDefines(e) {
+    e.BRDF_V_HEIGHT_CORRELATED = this._useSmithVisibilityHeightCorrelated, e.MS_BRDF_ENERGY_CONSERVATION = this._useEnergyConservation && this._useSmithVisibilityHeightCorrelated, e.SPHERICAL_HARMONICS = this._useSphericalHarmonics, e.SPECULAR_GLOSSINESS_ENERGY_CONSERVATION = this._useSpecularGlossinessInputEnergyConservation, e.MIX_IBL_RADIANCE_WITH_IRRADIANCE = this._mixIblRadianceWithIrradiance && !this._material._disableLighting, e.LEGACY_SPECULAR_ENERGY_CONSERVATION = this._useLegacySpecularEnergyConservation, e.BASE_DIFFUSE_MODEL = this._baseDiffuseModel, e.DIELECTRIC_SPECULAR_MODEL = this._dielectricSpecularModel, e.CONDUCTOR_SPECULAR_MODEL = this._conductorSpecularModel;
+  }
+  getClassName() {
+    return "PBRBRDFConfiguration";
+  }
+}
+c.DEFAULT_USE_ENERGY_CONSERVATION = !0;
+c.DEFAULT_USE_SMITH_VISIBILITY_HEIGHT_CORRELATED = !0;
+c.DEFAULT_USE_SPHERICAL_HARMONICS = !0;
+c.DEFAULT_USE_SPECULAR_GLOSSINESS_INPUT_ENERGY_CONSERVATION = !0;
+c.DEFAULT_MIX_IBL_RADIANCE_WITH_IRRADIANCE = !0;
+c.DEFAULT_USE_LEGACY_SPECULAR_ENERGY_CONSERVATION = !0;
+c.DEFAULT_DIFFUSE_MODEL = 0;
+c.DEFAULT_DIELECTRIC_SPECULAR_MODEL = 0;
+c.DEFAULT_CONDUCTOR_SPECULAR_MODEL = 0;
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "useEnergyConservation", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "useSmithVisibilityHeightCorrelated", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "useSphericalHarmonics", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "useSpecularGlossinessInputEnergyConservation", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "mixIblRadianceWithIrradiance", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "useLegacySpecularEnergyConservation", void 0);
+s([
+  a("baseDiffuseModel"),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "baseDiffuseModel", void 0);
+s([
+  a("dielectricSpecularModel"),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "dielectricSpecularModel", void 0);
+s([
+  a("conductorSpecularModel"),
+  r("_markAllSubMeshesAsMiscDirty")
+], c.prototype, "conductorSpecularModel", void 0);
+class Xe extends v {
+  constructor() {
+    super(...arguments), this.CLEARCOAT = !1, this.CLEARCOAT_DEFAULTIOR = !1, this.CLEARCOAT_TEXTURE = !1, this.CLEARCOAT_TEXTURE_ROUGHNESS = !1, this.CLEARCOAT_TEXTUREDIRECTUV = 0, this.CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV = 0, this.CLEARCOAT_BUMP = !1, this.CLEARCOAT_BUMPDIRECTUV = 0, this.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE = !1, this.CLEARCOAT_REMAP_F0 = !1, this.CLEARCOAT_TINT = !1, this.CLEARCOAT_TINT_TEXTURE = !1, this.CLEARCOAT_TINT_TEXTUREDIRECTUV = 0, this.CLEARCOAT_TINT_GAMMATEXTURE = !1;
+  }
+}
+class m extends P {
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * Gets a boolean indicating that the plugin is compatible with a given shader language.
+   * @returns true if the plugin is compatible with the shader language
+   */
+  isCompatible() {
+    return !0;
+  }
+  constructor(e, i = !0) {
+    super(e, "PBRClearCoat", 100, new Xe(), i), this._isEnabled = !1, this.isEnabled = !1, this.intensity = 1, this.roughness = 0, this._indexOfRefraction = m._DefaultIndexOfRefraction, this.indexOfRefraction = m._DefaultIndexOfRefraction, this._texture = null, this.texture = null, this._useRoughnessFromMainTexture = !0, this.useRoughnessFromMainTexture = !0, this._textureRoughness = null, this.textureRoughness = null, this._remapF0OnInterfaceChange = !0, this.remapF0OnInterfaceChange = !0, this._bumpTexture = null, this.bumpTexture = null, this._isTintEnabled = !1, this.isTintEnabled = !1, this.tintColor = d.White(), this.tintColorAtDistance = 1, this.tintThickness = 1, this._tintTexture = null, this.tintTexture = null, this._internalMarkAllSubMeshesAsTexturesDirty = e._dirtyCallbacks[1];
+  }
+  isReadyForSubMesh(e, i, t) {
+    if (!this._isEnabled)
+      return !0;
+    const o = this._material._disableBumpMap;
+    return !(e._areTexturesDirty && i.texturesEnabled && (this._texture && l.ClearCoatTextureEnabled && !this._texture.isReadyOrNotBlocking() || this._textureRoughness && l.ClearCoatTextureEnabled && !this._textureRoughness.isReadyOrNotBlocking() || t.getCaps().standardDerivatives && this._bumpTexture && l.ClearCoatBumpTextureEnabled && !o && !this._bumpTexture.isReady() || this._isTintEnabled && this._tintTexture && l.ClearCoatTintTextureEnabled && !this._tintTexture.isReadyOrNotBlocking()));
+  }
+  prepareDefinesBeforeAttributes(e, i) {
+    this._isEnabled ? (e.CLEARCOAT = !0, e.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE = this._useRoughnessFromMainTexture, e.CLEARCOAT_REMAP_F0 = this._remapF0OnInterfaceChange, e._areTexturesDirty && i.texturesEnabled && (this._texture && l.ClearCoatTextureEnabled ? p(this._texture, e, "CLEARCOAT_TEXTURE") : e.CLEARCOAT_TEXTURE = !1, this._textureRoughness && l.ClearCoatTextureEnabled ? p(this._textureRoughness, e, "CLEARCOAT_TEXTURE_ROUGHNESS") : e.CLEARCOAT_TEXTURE_ROUGHNESS = !1, this._bumpTexture && l.ClearCoatBumpTextureEnabled ? p(this._bumpTexture, e, "CLEARCOAT_BUMP") : e.CLEARCOAT_BUMP = !1, e.CLEARCOAT_DEFAULTIOR = this._indexOfRefraction === m._DefaultIndexOfRefraction, this._isTintEnabled ? (e.CLEARCOAT_TINT = !0, this._tintTexture && l.ClearCoatTintTextureEnabled ? (p(this._tintTexture, e, "CLEARCOAT_TINT_TEXTURE"), e.CLEARCOAT_TINT_GAMMATEXTURE = this._tintTexture.gammaSpace) : e.CLEARCOAT_TINT_TEXTURE = !1) : (e.CLEARCOAT_TINT = !1, e.CLEARCOAT_TINT_TEXTURE = !1))) : (e.CLEARCOAT = !1, e.CLEARCOAT_TEXTURE = !1, e.CLEARCOAT_TEXTURE_ROUGHNESS = !1, e.CLEARCOAT_BUMP = !1, e.CLEARCOAT_TINT = !1, e.CLEARCOAT_TINT_TEXTURE = !1, e.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE = !1, e.CLEARCOAT_DEFAULTIOR = !1, e.CLEARCOAT_TEXTUREDIRECTUV = 0, e.CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV = 0, e.CLEARCOAT_BUMPDIRECTUV = 0, e.CLEARCOAT_REMAP_F0 = !1, e.CLEARCOAT_TINT_TEXTUREDIRECTUV = 0, e.CLEARCOAT_TINT_GAMMATEXTURE = !1);
+  }
+  bindForSubMesh(e, i, t, o) {
+    if (!this._isEnabled)
+      return;
+    const h = o.materialDefines, R = this._material.isFrozen, S = this._material._disableBumpMap, C = this._material._invertNormalMapX, A = this._material._invertNormalMapY;
+    if (!e.useUbo || !R || !e.isSync) {
+      (this._texture || this._textureRoughness) && l.ClearCoatTextureEnabled && (e.updateFloat4("vClearCoatInfos", this._texture?.coordinatesIndex ?? 0, this._texture?.level ?? 0, this._textureRoughness?.coordinatesIndex ?? 0, this._textureRoughness?.level ?? 0), this._texture && I(this._texture, e, "clearCoat"), this._textureRoughness && !h.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE && I(this._textureRoughness, e, "clearCoatRoughness")), this._bumpTexture && t.getCaps().standardDerivatives && l.ClearCoatTextureEnabled && !S && (e.updateFloat2("vClearCoatBumpInfos", this._bumpTexture.coordinatesIndex, this._bumpTexture.level), I(this._bumpTexture, e, "clearCoatBump"), i._mirroredCameraPosition ? e.updateFloat2("vClearCoatTangentSpaceParams", C ? 1 : -1, A ? 1 : -1) : e.updateFloat2("vClearCoatTangentSpaceParams", C ? -1 : 1, A ? -1 : 1)), this._tintTexture && l.ClearCoatTintTextureEnabled && (e.updateFloat2("vClearCoatTintInfos", this._tintTexture.coordinatesIndex, this._tintTexture.level), I(this._tintTexture, e, "clearCoatTint")), e.updateFloat2("vClearCoatParams", this.intensity, this.roughness);
+      const T = 1 - this._indexOfRefraction, _ = 1 + this._indexOfRefraction, n = Math.pow(-T / _, 2), L = 1 / this._indexOfRefraction;
+      e.updateFloat4("vClearCoatRefractionParams", n, L, T, _), this._isTintEnabled && (e.updateFloat4("vClearCoatTintParams", this.tintColor.r, this.tintColor.g, this.tintColor.b, Math.max(1e-5, this.tintThickness)), e.updateFloat("clearCoatColorAtDistance", Math.max(1e-5, this.tintColorAtDistance)));
+    }
+    i.texturesEnabled && (this._texture && l.ClearCoatTextureEnabled && e.setTexture("clearCoatSampler", this._texture), this._textureRoughness && !h.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE && l.ClearCoatTextureEnabled && e.setTexture("clearCoatRoughnessSampler", this._textureRoughness), this._bumpTexture && t.getCaps().standardDerivatives && l.ClearCoatBumpTextureEnabled && !S && e.setTexture("clearCoatBumpSampler", this._bumpTexture), this._isTintEnabled && this._tintTexture && l.ClearCoatTintTextureEnabled && e.setTexture("clearCoatTintSampler", this._tintTexture));
+  }
+  hasTexture(e) {
+    return this._texture === e || this._textureRoughness === e || this._bumpTexture === e || this._tintTexture === e;
+  }
+  getActiveTextures(e) {
+    this._texture && e.push(this._texture), this._textureRoughness && e.push(this._textureRoughness), this._bumpTexture && e.push(this._bumpTexture), this._tintTexture && e.push(this._tintTexture);
+  }
+  getAnimatables(e) {
+    this._texture && this._texture.animations && this._texture.animations.length > 0 && e.push(this._texture), this._textureRoughness && this._textureRoughness.animations && this._textureRoughness.animations.length > 0 && e.push(this._textureRoughness), this._bumpTexture && this._bumpTexture.animations && this._bumpTexture.animations.length > 0 && e.push(this._bumpTexture), this._tintTexture && this._tintTexture.animations && this._tintTexture.animations.length > 0 && e.push(this._tintTexture);
+  }
+  dispose(e) {
+    e && (this._texture?.dispose(), this._textureRoughness?.dispose(), this._bumpTexture?.dispose(), this._tintTexture?.dispose());
+  }
+  getClassName() {
+    return "PBRClearCoatConfiguration";
+  }
+  addFallbacks(e, i, t) {
+    return e.CLEARCOAT_BUMP && i.addFallback(t++, "CLEARCOAT_BUMP"), e.CLEARCOAT_TINT && i.addFallback(t++, "CLEARCOAT_TINT"), e.CLEARCOAT && i.addFallback(t++, "CLEARCOAT"), t;
+  }
+  getSamplers(e) {
+    e.push("clearCoatSampler", "clearCoatRoughnessSampler", "clearCoatBumpSampler", "clearCoatTintSampler");
+  }
+  getUniforms() {
+    return {
+      ubo: [
+        { name: "vClearCoatParams", size: 2, type: "vec2" },
+        { name: "vClearCoatRefractionParams", size: 4, type: "vec4" },
+        { name: "vClearCoatInfos", size: 4, type: "vec4" },
+        { name: "clearCoatMatrix", size: 16, type: "mat4" },
+        { name: "clearCoatRoughnessMatrix", size: 16, type: "mat4" },
+        { name: "vClearCoatBumpInfos", size: 2, type: "vec2" },
+        { name: "vClearCoatTangentSpaceParams", size: 2, type: "vec2" },
+        { name: "clearCoatBumpMatrix", size: 16, type: "mat4" },
+        { name: "vClearCoatTintParams", size: 4, type: "vec4" },
+        { name: "clearCoatColorAtDistance", size: 1, type: "float" },
+        { name: "vClearCoatTintInfos", size: 2, type: "vec2" },
+        { name: "clearCoatTintMatrix", size: 16, type: "mat4" }
+      ]
+    };
+  }
+}
+m._DefaultIndexOfRefraction = 1.5;
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "isEnabled", void 0);
+s([
+  a()
+], m.prototype, "intensity", void 0);
+s([
+  a()
+], m.prototype, "roughness", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "indexOfRefraction", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "texture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "useRoughnessFromMainTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "textureRoughness", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "remapF0OnInterfaceChange", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "bumpTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "isTintEnabled", void 0);
+s([
+  M()
+], m.prototype, "tintColor", void 0);
+s([
+  a()
+], m.prototype, "tintColorAtDistance", void 0);
+s([
+  a()
+], m.prototype, "tintThickness", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], m.prototype, "tintTexture", void 0);
+class Ye extends v {
+  constructor() {
+    super(...arguments), this.IRIDESCENCE = !1, this.IRIDESCENCE_TEXTURE = !1, this.IRIDESCENCE_TEXTUREDIRECTUV = 0, this.IRIDESCENCE_THICKNESS_TEXTURE = !1, this.IRIDESCENCE_THICKNESS_TEXTUREDIRECTUV = 0;
+  }
+}
+class b extends P {
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * Gets a boolean indicating that the plugin is compatible with a given shader language.
+   * @returns true if the plugin is compatible with the shader language
+   */
+  isCompatible() {
+    return !0;
+  }
+  constructor(e, i = !0) {
+    super(e, "PBRIridescence", 110, new Ye(), i), this._isEnabled = !1, this.isEnabled = !1, this.intensity = 1, this.minimumThickness = b._DefaultMinimumThickness, this.maximumThickness = b._DefaultMaximumThickness, this.indexOfRefraction = b._DefaultIndexOfRefraction, this._texture = null, this.texture = null, this._thicknessTexture = null, this.thicknessTexture = null, this._internalMarkAllSubMeshesAsTexturesDirty = e._dirtyCallbacks[1];
+  }
+  isReadyForSubMesh(e, i) {
+    return this._isEnabled ? !(e._areTexturesDirty && i.texturesEnabled && (this._texture && l.IridescenceTextureEnabled && !this._texture.isReadyOrNotBlocking() || this._thicknessTexture && l.IridescenceTextureEnabled && !this._thicknessTexture.isReadyOrNotBlocking())) : !0;
+  }
+  prepareDefinesBeforeAttributes(e, i) {
+    this._isEnabled ? (e.IRIDESCENCE = !0, e._areTexturesDirty && i.texturesEnabled && (this._texture && l.IridescenceTextureEnabled ? p(this._texture, e, "IRIDESCENCE_TEXTURE") : e.IRIDESCENCE_TEXTURE = !1, this._thicknessTexture && l.IridescenceTextureEnabled ? p(this._thicknessTexture, e, "IRIDESCENCE_THICKNESS_TEXTURE") : e.IRIDESCENCE_THICKNESS_TEXTURE = !1)) : (e.IRIDESCENCE = !1, e.IRIDESCENCE_TEXTURE = !1, e.IRIDESCENCE_THICKNESS_TEXTURE = !1, e.IRIDESCENCE_TEXTUREDIRECTUV = 0, e.IRIDESCENCE_THICKNESS_TEXTUREDIRECTUV = 0);
+  }
+  bindForSubMesh(e, i) {
+    if (!this._isEnabled)
+      return;
+    const t = this._material.isFrozen;
+    (!e.useUbo || !t || !e.isSync) && ((this._texture || this._thicknessTexture) && l.IridescenceTextureEnabled && (e.updateFloat4("vIridescenceInfos", this._texture?.coordinatesIndex ?? 0, this._texture?.level ?? 0, this._thicknessTexture?.coordinatesIndex ?? 0, this._thicknessTexture?.level ?? 0), this._texture && I(this._texture, e, "iridescence"), this._thicknessTexture && I(this._thicknessTexture, e, "iridescenceThickness")), e.updateFloat4("vIridescenceParams", this.intensity, this.indexOfRefraction, this.minimumThickness, this.maximumThickness)), i.texturesEnabled && (this._texture && l.IridescenceTextureEnabled && e.setTexture("iridescenceSampler", this._texture), this._thicknessTexture && l.IridescenceTextureEnabled && e.setTexture("iridescenceThicknessSampler", this._thicknessTexture));
+  }
+  hasTexture(e) {
+    return this._texture === e || this._thicknessTexture === e;
+  }
+  getActiveTextures(e) {
+    this._texture && e.push(this._texture), this._thicknessTexture && e.push(this._thicknessTexture);
+  }
+  getAnimatables(e) {
+    this._texture && this._texture.animations && this._texture.animations.length > 0 && e.push(this._texture), this._thicknessTexture && this._thicknessTexture.animations && this._thicknessTexture.animations.length > 0 && e.push(this._thicknessTexture);
+  }
+  dispose(e) {
+    e && (this._texture?.dispose(), this._thicknessTexture?.dispose());
+  }
+  getClassName() {
+    return "PBRIridescenceConfiguration";
+  }
+  addFallbacks(e, i, t) {
+    return e.IRIDESCENCE && i.addFallback(t++, "IRIDESCENCE"), t;
+  }
+  getSamplers(e) {
+    e.push("iridescenceSampler", "iridescenceThicknessSampler");
+  }
+  getUniforms() {
+    return {
+      ubo: [
+        { name: "vIridescenceParams", size: 4, type: "vec4" },
+        { name: "vIridescenceInfos", size: 4, type: "vec4" },
+        { name: "iridescenceMatrix", size: 16, type: "mat4" },
+        { name: "iridescenceThicknessMatrix", size: 16, type: "mat4" }
+      ]
+    };
+  }
+}
+b._DefaultMinimumThickness = 100;
+b._DefaultMaximumThickness = 400;
+b._DefaultIndexOfRefraction = 1.3;
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], b.prototype, "isEnabled", void 0);
+s([
+  a()
+], b.prototype, "intensity", void 0);
+s([
+  a()
+], b.prototype, "minimumThickness", void 0);
+s([
+  a()
+], b.prototype, "maximumThickness", void 0);
+s([
+  a()
+], b.prototype, "indexOfRefraction", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], b.prototype, "texture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], b.prototype, "thicknessTexture", void 0);
+class We extends v {
+  constructor() {
+    super(...arguments), this.ANISOTROPIC = !1, this.ANISOTROPIC_TEXTURE = !1, this.ANISOTROPIC_TEXTUREDIRECTUV = 0, this.ANISOTROPIC_LEGACY = !1, this.MAINUV1 = !1;
+  }
+}
+class k extends P {
+  /**
+   * Sets the anisotropy direction as an angle.
+   */
+  set angle(e) {
+    this.direction.x = Math.cos(e), this.direction.y = Math.sin(e);
+  }
+  /**
+   * Gets the anisotropy angle value in radians.
+   * @returns the anisotropy angle value in radians.
+   */
+  get angle() {
+    return Math.atan2(this.direction.y, this.direction.x);
+  }
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  /** @internal */
+  _markAllSubMeshesAsMiscDirty() {
+    this._enable(this._isEnabled), this._internalMarkAllSubMeshesAsMiscDirty();
+  }
+  /**
+   * Gets a boolean indicating that the plugin is compatible with a given shader language.
+   * @returns true if the plugin is compatible with the shader language
+   */
+  isCompatible() {
+    return !0;
+  }
+  constructor(e, i = !0) {
+    super(e, "PBRAnisotropic", 110, new We(), i), this._isEnabled = !1, this.isEnabled = !1, this.intensity = 1, this.direction = new q(1, 0), this._texture = null, this.texture = null, this._legacy = !1, this.legacy = !1, this._internalMarkAllSubMeshesAsTexturesDirty = e._dirtyCallbacks[1], this._internalMarkAllSubMeshesAsMiscDirty = e._dirtyCallbacks[16];
+  }
+  isReadyForSubMesh(e, i) {
+    return this._isEnabled ? !(e._areTexturesDirty && i.texturesEnabled && this._texture && l.AnisotropicTextureEnabled && !this._texture.isReadyOrNotBlocking()) : !0;
+  }
+  prepareDefinesBeforeAttributes(e, i, t) {
+    this._isEnabled ? (e.ANISOTROPIC = this._isEnabled, this._isEnabled && !t.isVerticesDataPresent(F.TangentKind) && (e._needUVs = !0, e.MAINUV1 = !0), e._areTexturesDirty && i.texturesEnabled && (this._texture && l.AnisotropicTextureEnabled ? p(this._texture, e, "ANISOTROPIC_TEXTURE") : e.ANISOTROPIC_TEXTURE = !1), e._areMiscDirty && (e.ANISOTROPIC_LEGACY = this._legacy)) : (e.ANISOTROPIC = !1, e.ANISOTROPIC_TEXTURE = !1, e.ANISOTROPIC_TEXTUREDIRECTUV = 0, e.ANISOTROPIC_LEGACY = !1);
+  }
+  bindForSubMesh(e, i) {
+    if (!this._isEnabled)
+      return;
+    const t = this._material.isFrozen;
+    (!e.useUbo || !t || !e.isSync) && (this._texture && l.AnisotropicTextureEnabled && (e.updateFloat2("vAnisotropyInfos", this._texture.coordinatesIndex, this._texture.level), I(this._texture, e, "anisotropy")), e.updateFloat3("vAnisotropy", this.direction.x, this.direction.y, this.intensity)), i.texturesEnabled && this._texture && l.AnisotropicTextureEnabled && e.setTexture("anisotropySampler", this._texture);
+  }
+  hasTexture(e) {
+    return this._texture === e;
+  }
+  getActiveTextures(e) {
+    this._texture && e.push(this._texture);
+  }
+  getAnimatables(e) {
+    this._texture && this._texture.animations && this._texture.animations.length > 0 && e.push(this._texture);
+  }
+  dispose(e) {
+    e && this._texture && this._texture.dispose();
+  }
+  getClassName() {
+    return "PBRAnisotropicConfiguration";
+  }
+  addFallbacks(e, i, t) {
+    return e.ANISOTROPIC && i.addFallback(t++, "ANISOTROPIC"), t;
+  }
+  getSamplers(e) {
+    e.push("anisotropySampler");
+  }
+  getUniforms() {
+    return {
+      ubo: [
+        { name: "vAnisotropy", size: 3, type: "vec3" },
+        { name: "vAnisotropyInfos", size: 2, type: "vec2" },
+        { name: "anisotropyMatrix", size: 16, type: "mat4" }
+      ]
+    };
+  }
+  /**
+   * Parses a anisotropy Configuration from a serialized object.
+   * @param source - Serialized object.
+   * @param scene Defines the scene we are parsing for
+   * @param rootUrl Defines the rootUrl to load from
+   */
+  parse(e, i, t) {
+    super.parse(e, i, t), e.legacy === void 0 && (this.legacy = !0);
+  }
+}
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], k.prototype, "isEnabled", void 0);
+s([
+  a()
+], k.prototype, "intensity", void 0);
+s([
+  ee()
+], k.prototype, "direction", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], k.prototype, "texture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], k.prototype, "legacy", void 0);
+class ze extends v {
+  constructor() {
+    super(...arguments), this.SHEEN = !1, this.SHEEN_TEXTURE = !1, this.SHEEN_GAMMATEXTURE = !1, this.SHEEN_TEXTURE_ROUGHNESS = !1, this.SHEEN_TEXTUREDIRECTUV = 0, this.SHEEN_TEXTURE_ROUGHNESSDIRECTUV = 0, this.SHEEN_LINKWITHALBEDO = !1, this.SHEEN_ROUGHNESS = !1, this.SHEEN_ALBEDOSCALING = !1, this.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE = !1;
+  }
+}
+class g extends P {
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * Gets a boolean indicating that the plugin is compatible with a given shader language.
+   * @returns true if the plugin is compatible with the shader language
+   */
+  isCompatible() {
+    return !0;
+  }
+  constructor(e, i = !0) {
+    super(e, "Sheen", 120, new ze(), i), this._isEnabled = !1, this.isEnabled = !1, this._linkSheenWithAlbedo = !1, this.linkSheenWithAlbedo = !1, this.intensity = 1, this.color = d.White(), this._texture = null, this.texture = null, this._useRoughnessFromMainTexture = !0, this.useRoughnessFromMainTexture = !0, this._roughness = null, this.roughness = null, this._textureRoughness = null, this.textureRoughness = null, this._albedoScaling = !1, this.albedoScaling = !1, this._internalMarkAllSubMeshesAsTexturesDirty = e._dirtyCallbacks[1];
+  }
+  isReadyForSubMesh(e, i) {
+    return this._isEnabled ? !(e._areTexturesDirty && i.texturesEnabled && (this._texture && l.SheenTextureEnabled && !this._texture.isReadyOrNotBlocking() || this._textureRoughness && l.SheenTextureEnabled && !this._textureRoughness.isReadyOrNotBlocking())) : !0;
+  }
+  prepareDefinesBeforeAttributes(e, i) {
+    this._isEnabled ? (e.SHEEN = !0, e.SHEEN_LINKWITHALBEDO = this._linkSheenWithAlbedo, e.SHEEN_ROUGHNESS = this._roughness !== null, e.SHEEN_ALBEDOSCALING = this._albedoScaling, e.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE = this._useRoughnessFromMainTexture, e._areTexturesDirty && i.texturesEnabled && (this._texture && l.SheenTextureEnabled ? (p(this._texture, e, "SHEEN_TEXTURE"), e.SHEEN_GAMMATEXTURE = this._texture.gammaSpace) : e.SHEEN_TEXTURE = !1, this._textureRoughness && l.SheenTextureEnabled ? p(this._textureRoughness, e, "SHEEN_TEXTURE_ROUGHNESS") : e.SHEEN_TEXTURE_ROUGHNESS = !1)) : (e.SHEEN = !1, e.SHEEN_TEXTURE = !1, e.SHEEN_TEXTURE_ROUGHNESS = !1, e.SHEEN_LINKWITHALBEDO = !1, e.SHEEN_ROUGHNESS = !1, e.SHEEN_ALBEDOSCALING = !1, e.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE = !1, e.SHEEN_GAMMATEXTURE = !1, e.SHEEN_TEXTUREDIRECTUV = 0, e.SHEEN_TEXTURE_ROUGHNESSDIRECTUV = 0);
+  }
+  bindForSubMesh(e, i, t, o) {
+    if (!this._isEnabled)
+      return;
+    const h = o.materialDefines, R = this._material.isFrozen;
+    (!e.useUbo || !R || !e.isSync) && ((this._texture || this._textureRoughness) && l.SheenTextureEnabled && (e.updateFloat4("vSheenInfos", this._texture?.coordinatesIndex ?? 0, this._texture?.level ?? 0, this._textureRoughness?.coordinatesIndex ?? 0, this._textureRoughness?.level ?? 0), this._texture && I(this._texture, e, "sheen"), this._textureRoughness && !h.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE && I(this._textureRoughness, e, "sheenRoughness")), e.updateFloat4("vSheenColor", this.color.r, this.color.g, this.color.b, this.intensity), this._roughness !== null && e.updateFloat("vSheenRoughness", this._roughness)), i.texturesEnabled && (this._texture && l.SheenTextureEnabled && e.setTexture("sheenSampler", this._texture), this._textureRoughness && !h.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE && l.SheenTextureEnabled && e.setTexture("sheenRoughnessSampler", this._textureRoughness));
+  }
+  hasTexture(e) {
+    return this._texture === e || this._textureRoughness === e;
+  }
+  getActiveTextures(e) {
+    this._texture && e.push(this._texture), this._textureRoughness && e.push(this._textureRoughness);
+  }
+  getAnimatables(e) {
+    this._texture && this._texture.animations && this._texture.animations.length > 0 && e.push(this._texture), this._textureRoughness && this._textureRoughness.animations && this._textureRoughness.animations.length > 0 && e.push(this._textureRoughness);
+  }
+  dispose(e) {
+    e && (this._texture?.dispose(), this._textureRoughness?.dispose());
+  }
+  getClassName() {
+    return "PBRSheenConfiguration";
+  }
+  addFallbacks(e, i, t) {
+    return e.SHEEN && i.addFallback(t++, "SHEEN"), t;
+  }
+  getSamplers(e) {
+    e.push("sheenSampler", "sheenRoughnessSampler");
+  }
+  getUniforms() {
+    return {
+      ubo: [
+        { name: "vSheenColor", size: 4, type: "vec4" },
+        { name: "vSheenRoughness", size: 1, type: "float" },
+        { name: "vSheenInfos", size: 4, type: "vec4" },
+        { name: "sheenMatrix", size: 16, type: "mat4" },
+        { name: "sheenRoughnessMatrix", size: 16, type: "mat4" }
+      ]
+    };
+  }
+}
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "isEnabled", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "linkSheenWithAlbedo", void 0);
+s([
+  a()
+], g.prototype, "intensity", void 0);
+s([
+  M()
+], g.prototype, "color", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "texture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "useRoughnessFromMainTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "roughness", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "textureRoughness", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], g.prototype, "albedoScaling", void 0);
+class we extends v {
+  constructor() {
+    super(...arguments), this.SUBSURFACE = !1, this.SS_REFRACTION = !1, this.SS_REFRACTION_USE_INTENSITY_FROM_THICKNESS = !1, this.SS_TRANSLUCENCY = !1, this.SS_TRANSLUCENCY_USE_INTENSITY_FROM_THICKNESS = !1, this.SS_SCATTERING = !1, this.SS_DISPERSION = !1, this.SS_THICKNESSANDMASK_TEXTURE = !1, this.SS_THICKNESSANDMASK_TEXTUREDIRECTUV = 0, this.SS_HAS_THICKNESS = !1, this.SS_REFRACTIONINTENSITY_TEXTURE = !1, this.SS_REFRACTIONINTENSITY_TEXTUREDIRECTUV = 0, this.SS_TRANSLUCENCYINTENSITY_TEXTURE = !1, this.SS_TRANSLUCENCYINTENSITY_TEXTUREDIRECTUV = 0, this.SS_TRANSLUCENCYCOLOR_TEXTURE = !1, this.SS_TRANSLUCENCYCOLOR_TEXTUREDIRECTUV = 0, this.SS_TRANSLUCENCYCOLOR_TEXTURE_GAMMA = !1, this.SS_REFRACTIONMAP_3D = !1, this.SS_REFRACTIONMAP_OPPOSITEZ = !1, this.SS_LODINREFRACTIONALPHA = !1, this.SS_GAMMAREFRACTION = !1, this.SS_RGBDREFRACTION = !1, this.SS_LINEARSPECULARREFRACTION = !1, this.SS_LINKREFRACTIONTOTRANSPARENCY = !1, this.SS_ALBEDOFORREFRACTIONTINT = !1, this.SS_ALBEDOFORTRANSLUCENCYTINT = !1, this.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = !1, this.SS_USE_THICKNESS_AS_DEPTH = !1, this.SS_USE_GLTF_TEXTURES = !1, this.SS_APPLY_ALBEDO_AFTER_SUBSURFACE = !1, this.SS_TRANSLUCENCY_LEGACY = !1;
+  }
+}
+class E extends P {
+  /**
+   * Diffusion profile for subsurface scattering.
+   * Useful for better scattering in the skins or foliages.
+   */
+  get scatteringDiffusionProfile() {
+    return this._scene.subSurfaceConfiguration ? this._scene.subSurfaceConfiguration.ssDiffusionProfileColors[this._scatteringDiffusionProfileIndex] : null;
+  }
+  set scatteringDiffusionProfile(e) {
+    this._scene.enableSubSurfaceForPrePass() && e && (this._scatteringDiffusionProfileIndex = this._scene.subSurfaceConfiguration.addDiffusionProfile(e));
+  }
+  /**
+   * Index of refraction of the material's volume.
+   * https://en.wikipedia.org/wiki/List_of_refractive_indices
+   *
+   * This ONLY impacts refraction. If not provided or given a non-valid value,
+   * the volume will use the same IOR as the surface.
+   */
+  get volumeIndexOfRefraction() {
+    return this._volumeIndexOfRefraction >= 1 ? this._volumeIndexOfRefraction : this._indexOfRefraction;
+  }
+  set volumeIndexOfRefraction(e) {
+    e >= 1 ? this._volumeIndexOfRefraction = e : this._volumeIndexOfRefraction = -1;
+  }
+  /**
+   * Keeping for backward compatibility... Should not be used anymore. It has been replaced by
+   * the property with the correct spelling.
+   * @see legacyTranslucency
+   */
+  get legacyTransluceny() {
+    return this.legacyTranslucency;
+  }
+  set legacyTransluceny(e) {
+    this.legacyTranslucency = e;
+  }
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isRefractionEnabled || this._isTranslucencyEnabled || this._isScatteringEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  /** @internal */
+  _markScenePrePassDirty() {
+    this._enable(this._isRefractionEnabled || this._isTranslucencyEnabled || this._isScatteringEnabled), this._internalMarkAllSubMeshesAsTexturesDirty(), this._internalMarkScenePrePassDirty();
+  }
+  /**
+   * Gets a boolean indicating that the plugin is compatible with a given shader language.
+   * @returns true if the plugin is compatible with the shader language
+   */
+  isCompatible() {
+    return !0;
+  }
+  constructor(e, i = !0) {
+    super(e, "PBRSubSurface", 130, new we(), i), this._isRefractionEnabled = !1, this.isRefractionEnabled = !1, this._isTranslucencyEnabled = !1, this.isTranslucencyEnabled = !1, this._isDispersionEnabled = !1, this.isDispersionEnabled = !1, this._isScatteringEnabled = !1, this.isScatteringEnabled = !1, this._scatteringDiffusionProfileIndex = 0, this.refractionIntensity = 1, this.translucencyIntensity = 1, this._useAlbedoToTintRefraction = !1, this.useAlbedoToTintRefraction = !1, this._useAlbedoToTintTranslucency = !1, this.useAlbedoToTintTranslucency = !1, this._thicknessTexture = null, this.thicknessTexture = null, this._refractionTexture = null, this.refractionTexture = null, this._indexOfRefraction = 1.5, this.indexOfRefraction = 1.5, this._volumeIndexOfRefraction = -1, this._invertRefractionY = !1, this.invertRefractionY = !1, this._linkRefractionWithTransparency = !1, this.linkRefractionWithTransparency = !1, this.minimumThickness = 0, this.maximumThickness = 1, this.useThicknessAsDepth = !1, this.tintColor = d.White(), this.tintColorAtDistance = 1, this.dispersion = 0, this.diffusionDistance = d.White(), this._useMaskFromThicknessTexture = !1, this.useMaskFromThicknessTexture = !1, this._refractionIntensityTexture = null, this.refractionIntensityTexture = null, this._translucencyIntensityTexture = null, this.translucencyIntensityTexture = null, this.translucencyColor = null, this._translucencyColorTexture = null, this.translucencyColorTexture = null, this._useGltfStyleTextures = !0, this.useGltfStyleTextures = !0, this.applyAlbedoAfterSubSurface = E.DEFAULT_APPLY_ALBEDO_AFTERSUBSURFACE, this.legacyTranslucency = E.DEFAULT_LEGACY_TRANSLUCENCY, this._scene = e.getScene(), this.registerForExtraEvents = !0, this._internalMarkAllSubMeshesAsTexturesDirty = e._dirtyCallbacks[1], this._internalMarkScenePrePassDirty = e._dirtyCallbacks[32];
+  }
+  isReadyForSubMesh(e, i) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled)
+      return !0;
+    if (e._areTexturesDirty && i.texturesEnabled) {
+      if (this._thicknessTexture && l.ThicknessTextureEnabled && !this._thicknessTexture.isReadyOrNotBlocking() || this._refractionIntensityTexture && l.RefractionIntensityTextureEnabled && !this._refractionIntensityTexture.isReadyOrNotBlocking() || this._translucencyColorTexture && l.TranslucencyColorTextureEnabled && !this._translucencyColorTexture.isReadyOrNotBlocking() || this._translucencyIntensityTexture && l.TranslucencyIntensityTextureEnabled && !this._translucencyIntensityTexture.isReadyOrNotBlocking())
+        return !1;
+      const t = this._getRefractionTexture(i);
+      if (t && l.RefractionTextureEnabled && !t.isReadyOrNotBlocking())
+        return !1;
+    }
+    return !0;
+  }
+  prepareDefinesBeforeAttributes(e, i) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled) {
+      e.SUBSURFACE = !1, e.SS_DISPERSION = !1, e.SS_TRANSLUCENCY = !1, e.SS_SCATTERING = !1, e.SS_REFRACTION = !1, e.SS_REFRACTION_USE_INTENSITY_FROM_THICKNESS = !1, e.SS_TRANSLUCENCY_USE_INTENSITY_FROM_THICKNESS = !1, e.SS_THICKNESSANDMASK_TEXTURE = !1, e.SS_THICKNESSANDMASK_TEXTUREDIRECTUV = 0, e.SS_HAS_THICKNESS = !1, e.SS_REFRACTIONINTENSITY_TEXTURE = !1, e.SS_REFRACTIONINTENSITY_TEXTUREDIRECTUV = 0, e.SS_TRANSLUCENCYINTENSITY_TEXTURE = !1, e.SS_TRANSLUCENCYINTENSITY_TEXTUREDIRECTUV = 0, e.SS_REFRACTIONMAP_3D = !1, e.SS_REFRACTIONMAP_OPPOSITEZ = !1, e.SS_LODINREFRACTIONALPHA = !1, e.SS_GAMMAREFRACTION = !1, e.SS_RGBDREFRACTION = !1, e.SS_LINEARSPECULARREFRACTION = !1, e.SS_LINKREFRACTIONTOTRANSPARENCY = !1, e.SS_ALBEDOFORREFRACTIONTINT = !1, e.SS_ALBEDOFORTRANSLUCENCYTINT = !1, e.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = !1, e.SS_USE_THICKNESS_AS_DEPTH = !1, e.SS_USE_GLTF_TEXTURES = !1, e.SS_TRANSLUCENCYCOLOR_TEXTURE = !1, e.SS_TRANSLUCENCYCOLOR_TEXTUREDIRECTUV = 0, e.SS_TRANSLUCENCYCOLOR_TEXTURE_GAMMA = !1, e.SS_APPLY_ALBEDO_AFTER_SUBSURFACE = !1;
+      return;
+    }
+    if (e._areTexturesDirty) {
+      if (e.SUBSURFACE = !0, e.SS_DISPERSION = this._isDispersionEnabled, e.SS_TRANSLUCENCY = this._isTranslucencyEnabled, e.SS_TRANSLUCENCY_USE_INTENSITY_FROM_THICKNESS = !1, e.SS_TRANSLUCENCY_LEGACY = this.legacyTranslucency, e.SS_SCATTERING = this._isScatteringEnabled, e.SS_THICKNESSANDMASK_TEXTURE = !1, e.SS_REFRACTIONINTENSITY_TEXTURE = !1, e.SS_TRANSLUCENCYINTENSITY_TEXTURE = !1, e.SS_HAS_THICKNESS = !1, e.SS_USE_GLTF_TEXTURES = !1, e.SS_REFRACTION = !1, e.SS_REFRACTION_USE_INTENSITY_FROM_THICKNESS = !1, e.SS_REFRACTIONMAP_3D = !1, e.SS_GAMMAREFRACTION = !1, e.SS_RGBDREFRACTION = !1, e.SS_LINEARSPECULARREFRACTION = !1, e.SS_REFRACTIONMAP_OPPOSITEZ = !1, e.SS_LODINREFRACTIONALPHA = !1, e.SS_LINKREFRACTIONTOTRANSPARENCY = !1, e.SS_ALBEDOFORREFRACTIONTINT = !1, e.SS_ALBEDOFORTRANSLUCENCYTINT = !1, e.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = !1, e.SS_USE_THICKNESS_AS_DEPTH = !1, e.SS_TRANSLUCENCYCOLOR_TEXTURE = !1, e.SS_APPLY_ALBEDO_AFTER_SUBSURFACE = this.applyAlbedoAfterSubSurface, e._areTexturesDirty && i.texturesEnabled && (this._thicknessTexture && l.ThicknessTextureEnabled && p(this._thicknessTexture, e, "SS_THICKNESSANDMASK_TEXTURE"), this._refractionIntensityTexture && l.RefractionIntensityTextureEnabled && p(this._refractionIntensityTexture, e, "SS_REFRACTIONINTENSITY_TEXTURE"), this._translucencyIntensityTexture && l.TranslucencyIntensityTextureEnabled && p(this._translucencyIntensityTexture, e, "SS_TRANSLUCENCYINTENSITY_TEXTURE"), this._translucencyColorTexture && l.TranslucencyColorTextureEnabled && (p(this._translucencyColorTexture, e, "SS_TRANSLUCENCYCOLOR_TEXTURE"), e.SS_TRANSLUCENCYCOLOR_TEXTURE_GAMMA = this._translucencyColorTexture.gammaSpace)), e.SS_HAS_THICKNESS = this.maximumThickness - this.minimumThickness !== 0, e.SS_USE_GLTF_TEXTURES = this._useGltfStyleTextures, e.SS_REFRACTION_USE_INTENSITY_FROM_THICKNESS = this._useMaskFromThicknessTexture && !this._refractionIntensityTexture, e.SS_TRANSLUCENCY_USE_INTENSITY_FROM_THICKNESS = this._useMaskFromThicknessTexture && !this._translucencyIntensityTexture, this._isRefractionEnabled && i.texturesEnabled) {
+        const t = this._getRefractionTexture(i);
+        t && l.RefractionTextureEnabled && (e.SS_REFRACTION = !0, e.SS_REFRACTIONMAP_3D = t.isCube, e.SS_GAMMAREFRACTION = t.gammaSpace, e.SS_RGBDREFRACTION = t.isRGBD, e.SS_LINEARSPECULARREFRACTION = t.linearSpecularLOD, e.SS_REFRACTIONMAP_OPPOSITEZ = this._scene.useRightHandedSystem && t.isCube ? !t.invertZ : t.invertZ, e.SS_LODINREFRACTIONALPHA = t.lodLevelInAlpha, e.SS_LINKREFRACTIONTOTRANSPARENCY = this._linkRefractionWithTransparency, e.SS_ALBEDOFORREFRACTIONTINT = this._useAlbedoToTintRefraction, e.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = t.isCube && t.boundingBoxSize, e.SS_USE_THICKNESS_AS_DEPTH = this.useThicknessAsDepth);
+      }
+      this._isTranslucencyEnabled && (e.SS_ALBEDOFORTRANSLUCENCYTINT = this._useAlbedoToTintTranslucency);
+    }
+  }
+  /**
+   * 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
+   */
+  hardBindForSubMesh(e, i, t, o) {
+    if (!(!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled))
+      if (this.maximumThickness === 0 && this.minimumThickness === 0)
+        e.updateFloat2("vThicknessParam", 0, 0);
+      else {
+        o.getRenderingMesh().getWorldMatrix().decompose(V.Vector3[0]);
+        const h = Math.max(Math.abs(V.Vector3[0].x), Math.abs(V.Vector3[0].y), Math.abs(V.Vector3[0].z));
+        e.updateFloat2("vThicknessParam", this.minimumThickness * h, (this.maximumThickness - this.minimumThickness) * h);
+      }
+  }
+  bindForSubMesh(e, i, t, o) {
+    if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled)
+      return;
+    const h = o.materialDefines, R = this._material.isFrozen, S = this._material.realTimeFiltering, C = h.LODBASEDMICROSFURACE, A = this._getRefractionTexture(i);
+    if (!e.useUbo || !R || !e.isSync) {
+      if (this._thicknessTexture && l.ThicknessTextureEnabled && (e.updateFloat2("vThicknessInfos", this._thicknessTexture.coordinatesIndex, this._thicknessTexture.level), I(this._thicknessTexture, e, "thickness")), this._refractionIntensityTexture && l.RefractionIntensityTextureEnabled && h.SS_REFRACTIONINTENSITY_TEXTURE && (e.updateFloat2("vRefractionIntensityInfos", this._refractionIntensityTexture.coordinatesIndex, this._refractionIntensityTexture.level), I(this._refractionIntensityTexture, e, "refractionIntensity")), this._translucencyColorTexture && l.TranslucencyColorTextureEnabled && h.SS_TRANSLUCENCYCOLOR_TEXTURE && (e.updateFloat2("vTranslucencyColorInfos", this._translucencyColorTexture.coordinatesIndex, this._translucencyColorTexture.level), I(this._translucencyColorTexture, e, "translucencyColor")), this._translucencyIntensityTexture && l.TranslucencyIntensityTextureEnabled && h.SS_TRANSLUCENCYINTENSITY_TEXTURE && (e.updateFloat2("vTranslucencyIntensityInfos", this._translucencyIntensityTexture.coordinatesIndex, this._translucencyIntensityTexture.level), I(this._translucencyIntensityTexture, e, "translucencyIntensity")), A && l.RefractionTextureEnabled) {
+        e.updateMatrix("refractionMatrix", A.getRefractionTextureMatrix());
+        let T = 1;
+        A.isCube || A.depth && (T = A.depth);
+        const _ = A.getSize().width, n = this.volumeIndexOfRefraction;
+        if (e.updateFloat4("vRefractionInfos", A.level, 1 / n, T, this._invertRefractionY ? -1 : 1), e.updateFloat4("vRefractionMicrosurfaceInfos", _, A.lodGenerationScale, A.lodGenerationOffset, 1 / this.indexOfRefraction), S && e.updateFloat2("vRefractionFilteringInfo", _, Math.log2(_)), A.boundingBoxSize) {
+          const L = A;
+          e.updateVector3("vRefractionPosition", L.boundingBoxPosition), e.updateVector3("vRefractionSize", L.boundingBoxSize);
+        }
+      }
+      this._isScatteringEnabled && e.updateFloat("scatteringDiffusionProfile", this._scatteringDiffusionProfileIndex), e.updateColor3("vDiffusionDistance", this.diffusionDistance), e.updateFloat4("vTintColor", this.tintColor.r, this.tintColor.g, this.tintColor.b, Math.max(1e-5, this.tintColorAtDistance)), e.updateColor4("vTranslucencyColor", this.translucencyColor ?? this.tintColor, 0), e.updateFloat3("vSubSurfaceIntensity", this.refractionIntensity, this.translucencyIntensity, 0), e.updateFloat("dispersion", this.dispersion);
+    }
+    i.texturesEnabled && (this._thicknessTexture && l.ThicknessTextureEnabled && e.setTexture("thicknessSampler", this._thicknessTexture), this._refractionIntensityTexture && l.RefractionIntensityTextureEnabled && h.SS_REFRACTIONINTENSITY_TEXTURE && e.setTexture("refractionIntensitySampler", this._refractionIntensityTexture), this._translucencyIntensityTexture && l.TranslucencyIntensityTextureEnabled && h.SS_TRANSLUCENCYINTENSITY_TEXTURE && e.setTexture("translucencyIntensitySampler", this._translucencyIntensityTexture), this._translucencyColorTexture && l.TranslucencyColorTextureEnabled && h.SS_TRANSLUCENCYCOLOR_TEXTURE && e.setTexture("translucencyColorSampler", this._translucencyColorTexture), A && l.RefractionTextureEnabled && (C ? e.setTexture("refractionSampler", A) : (e.setTexture("refractionSampler", A._lodTextureMid || A), e.setTexture("refractionSamplerLow", A._lodTextureLow || A), e.setTexture("refractionSamplerHigh", A._lodTextureHigh || A))));
+  }
+  /**
+   * Returns the texture used for refraction or null if none is used.
+   * @param scene defines the scene the material belongs to.
+   * @returns - Refraction texture if present.  If no refraction texture and refraction
+   * is linked with transparency, returns environment texture.  Otherwise, returns null.
+   */
+  _getRefractionTexture(e) {
+    return this._refractionTexture ? this._refractionTexture : this._isRefractionEnabled ? e.environmentTexture : null;
+  }
+  /**
+   * Returns true if alpha blending should be disabled.
+   */
+  get disableAlphaBlending() {
+    return this._isRefractionEnabled && this._linkRefractionWithTransparency;
+  }
+  /**
+   * Fills the list of render target textures.
+   * @param renderTargets the list of render targets to update
+   */
+  fillRenderTargetTextures(e) {
+    l.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget && e.push(this._refractionTexture);
+  }
+  hasTexture(e) {
+    return this._thicknessTexture === e || this._refractionTexture === e || this._refractionIntensityTexture === e || this._translucencyIntensityTexture === e || this._translucencyColorTexture === e;
+  }
+  hasRenderTargetTextures() {
+    return !!(l.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget);
+  }
+  getActiveTextures(e) {
+    this._thicknessTexture && e.push(this._thicknessTexture), this._refractionTexture && e.push(this._refractionTexture), this._refractionIntensityTexture && e.push(this._refractionIntensityTexture), this._translucencyColorTexture && e.push(this._translucencyColorTexture), this._translucencyIntensityTexture && e.push(this._translucencyIntensityTexture);
+  }
+  getAnimatables(e) {
+    this._thicknessTexture && this._thicknessTexture.animations && this._thicknessTexture.animations.length > 0 && e.push(this._thicknessTexture), this._refractionTexture && this._refractionTexture.animations && this._refractionTexture.animations.length > 0 && e.push(this._refractionTexture), this._refractionIntensityTexture && this._refractionIntensityTexture.animations && this._refractionIntensityTexture.animations.length > 0 && e.push(this._refractionIntensityTexture), this._translucencyColorTexture && this._translucencyColorTexture.animations && this._translucencyColorTexture.animations.length > 0 && e.push(this._translucencyColorTexture), this._translucencyIntensityTexture && this._translucencyIntensityTexture.animations && this._translucencyIntensityTexture.animations.length > 0 && e.push(this._translucencyIntensityTexture);
+  }
+  dispose(e) {
+    e && (this._thicknessTexture && this._thicknessTexture.dispose(), this._refractionTexture && this._refractionTexture.dispose(), this._refractionIntensityTexture && this._refractionIntensityTexture.dispose(), this._translucencyColorTexture && this._translucencyColorTexture.dispose(), this._translucencyIntensityTexture && this._translucencyIntensityTexture.dispose());
+  }
+  getClassName() {
+    return "PBRSubSurfaceConfiguration";
+  }
+  addFallbacks(e, i, t) {
+    return e.SS_SCATTERING && i.addFallback(t++, "SS_SCATTERING"), e.SS_TRANSLUCENCY && i.addFallback(t++, "SS_TRANSLUCENCY"), t;
+  }
+  getSamplers(e) {
+    e.push("thicknessSampler", "refractionIntensitySampler", "translucencyIntensitySampler", "refractionSampler", "refractionSamplerLow", "refractionSamplerHigh", "translucencyColorSampler");
+  }
+  getUniforms() {
+    return {
+      ubo: [
+        { name: "vRefractionMicrosurfaceInfos", size: 4, type: "vec4" },
+        { name: "vRefractionFilteringInfo", size: 2, type: "vec2" },
+        { name: "vTranslucencyIntensityInfos", size: 2, type: "vec2" },
+        { name: "vRefractionInfos", size: 4, type: "vec4" },
+        { name: "refractionMatrix", size: 16, type: "mat4" },
+        { name: "vThicknessInfos", size: 2, type: "vec2" },
+        { name: "vRefractionIntensityInfos", size: 2, type: "vec2" },
+        { name: "thicknessMatrix", size: 16, type: "mat4" },
+        { name: "refractionIntensityMatrix", size: 16, type: "mat4" },
+        { name: "translucencyIntensityMatrix", size: 16, type: "mat4" },
+        { name: "vThicknessParam", size: 2, type: "vec2" },
+        { name: "vDiffusionDistance", size: 3, type: "vec3" },
+        { name: "vTintColor", size: 4, type: "vec4" },
+        { name: "vSubSurfaceIntensity", size: 3, type: "vec3" },
+        { name: "vRefractionPosition", size: 3, type: "vec3" },
+        { name: "vRefractionSize", size: 3, type: "vec3" },
+        { name: "scatteringDiffusionProfile", size: 1, type: "float" },
+        { name: "dispersion", size: 1, type: "float" },
+        { name: "vTranslucencyColor", size: 4, type: "vec4" },
+        { name: "vTranslucencyColorInfos", size: 2, type: "vec2" },
+        { name: "translucencyColorMatrix", size: 16, type: "mat4" }
+      ]
+    };
+  }
+}
+E.DEFAULT_APPLY_ALBEDO_AFTERSUBSURFACE = !1;
+E.DEFAULT_LEGACY_TRANSLUCENCY = !1;
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "isRefractionEnabled", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "isTranslucencyEnabled", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "isDispersionEnabled", void 0);
+s([
+  a(),
+  r("_markScenePrePassDirty")
+], E.prototype, "isScatteringEnabled", void 0);
+s([
+  a()
+], E.prototype, "_scatteringDiffusionProfileIndex", void 0);
+s([
+  a()
+], E.prototype, "refractionIntensity", void 0);
+s([
+  a()
+], E.prototype, "translucencyIntensity", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "useAlbedoToTintRefraction", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "useAlbedoToTintTranslucency", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "thicknessTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "refractionTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "indexOfRefraction", void 0);
+s([
+  a()
+], E.prototype, "_volumeIndexOfRefraction", void 0);
+s([
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "volumeIndexOfRefraction", null);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "invertRefractionY", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "linkRefractionWithTransparency", void 0);
+s([
+  a()
+], E.prototype, "minimumThickness", void 0);
+s([
+  a()
+], E.prototype, "maximumThickness", void 0);
+s([
+  a()
+], E.prototype, "useThicknessAsDepth", void 0);
+s([
+  M()
+], E.prototype, "tintColor", void 0);
+s([
+  a()
+], E.prototype, "tintColorAtDistance", void 0);
+s([
+  a()
+], E.prototype, "dispersion", void 0);
+s([
+  M()
+], E.prototype, "diffusionDistance", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "useMaskFromThicknessTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "refractionIntensityTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "translucencyIntensityTexture", void 0);
+s([
+  M()
+], E.prototype, "translucencyColor", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "translucencyColorTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], E.prototype, "useGltfStyleTextures", void 0);
+s([
+  a()
+], E.prototype, "applyAlbedoAfterSubSurface", void 0);
+s([
+  a()
+], E.prototype, "legacyTranslucency", void 0);
+const U = { effect: null, subMesh: null };
+class Ke extends He(Ge(v)) {
+}
+class Q extends ke(Ke) {
+  /**
+   * Initializes the PBR Material defines.
+   * @param externalProperties The external properties
+   */
+  constructor(e) {
+    super(e), this.PBR = !0, this.NUM_SAMPLES = "0", this.REALTIME_FILTERING = !1, this.IBL_CDF_FILTERING = !1, this.ALBEDO = !1, this.GAMMAALBEDO = !1, this.ALBEDODIRECTUV = 0, this.VERTEXCOLOR = !1, this.BASE_WEIGHT = !1, this.BASE_WEIGHTDIRECTUV = 0, this.BASE_DIFFUSE_ROUGHNESS = !1, this.BASE_DIFFUSE_ROUGHNESSDIRECTUV = 0, this.BAKED_VERTEX_ANIMATION_TEXTURE = !1, this.AMBIENT = !1, this.AMBIENTDIRECTUV = 0, this.AMBIENTINGRAYSCALE = !1, this.OPACITY = !1, this.VERTEXALPHA = !1, this.OPACITYDIRECTUV = 0, this.OPACITYRGB = !1, this.ALPHATEST = !1, this.DEPTHPREPASS = !1, this.ALPHABLEND = !1, this.ALPHAFROMALBEDO = !1, this.ALPHATESTVALUE = "0.5", this.SPECULAROVERALPHA = !1, this.RADIANCEOVERALPHA = !1, this.ALPHAFRESNEL = !1, this.LINEARALPHAFRESNEL = !1, this.PREMULTIPLYALPHA = !1, this.EMISSIVE = !1, this.EMISSIVEDIRECTUV = 0, this.GAMMAEMISSIVE = !1, this.REFLECTIVITY = !1, this.REFLECTIVITY_GAMMA = !1, this.REFLECTIVITYDIRECTUV = 0, this.SPECULARTERM = !1, this.MICROSURFACEFROMREFLECTIVITYMAP = !1, this.MICROSURFACEAUTOMATIC = !1, this.LODBASEDMICROSFURACE = !1, this.MICROSURFACEMAP = !1, this.MICROSURFACEMAPDIRECTUV = 0, this.METALLICWORKFLOW = !1, this.ROUGHNESSSTOREINMETALMAPALPHA = !1, this.ROUGHNESSSTOREINMETALMAPGREEN = !1, this.METALLNESSSTOREINMETALMAPBLUE = !1, this.AOSTOREINMETALMAPRED = !1, this.METALLIC_REFLECTANCE = !1, this.METALLIC_REFLECTANCE_GAMMA = !1, this.METALLIC_REFLECTANCEDIRECTUV = 0, this.METALLIC_REFLECTANCE_USE_ALPHA_ONLY = !1, this.REFLECTANCE = !1, this.REFLECTANCE_GAMMA = !1, this.REFLECTANCEDIRECTUV = 0, this.ENVIRONMENTBRDF = !1, this.ENVIRONMENTBRDF_RGBD = !1, this.NORMAL = !1, this.TANGENT = !1, this.BUMP = !1, this.BUMPDIRECTUV = 0, this.OBJECTSPACE_NORMALMAP = !1, this.PARALLAX = !1, this.PARALLAX_RHS = !1, this.PARALLAXOCCLUSION = !1, this.NORMALXYSCALE = !0, this.LIGHTMAP = !1, this.LIGHTMAPDIRECTUV = 0, this.USELIGHTMAPASSHADOWMAP = !1, this.GAMMALIGHTMAP = !1, this.RGBDLIGHTMAP = !1, 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, this.LINEARSPECULARREFLECTION = !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.MULTIVIEW = !1, this.ORDER_INDEPENDENT_TRANSPARENCY = !1, this.ORDER_INDEPENDENT_TRANSPARENCY_16BITS = !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.rebuild();
+  }
+  /**
+   * Resets the PBR Material defines.
+   */
+  reset() {
+    super.reset(), this.ALPHATESTVALUE = "0.5", this.PBR = !0, this.NORMALXYSCALE = !0;
+  }
+}
+class Qe extends Ue(Pe) {
+}
+class f extends Qe {
+  /**
+   * Enables realtime filtering on the texture.
+   */
+  get realTimeFiltering() {
+    return this._realTimeFiltering;
+  }
+  set realTimeFiltering(e) {
+    this._realTimeFiltering = e, this.markAsDirty(1);
+  }
+  /**
+   * Quality switch for realtime filtering
+   */
+  get realTimeFilteringQuality() {
+    return this._realTimeFilteringQuality;
+  }
+  set realTimeFilteringQuality(e) {
+    this._realTimeFilteringQuality = e, this.markAsDirty(1);
+  }
+  /**
+   * Can this material render to several textures at once
+   */
+  get canRenderToMRT() {
+    return !0;
+  }
+  /**
+   * Instantiates a new PBRMaterial 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(e, i, t = !1) {
+    super(e, i, void 0, t || f.ForceGLSL), this._directIntensity = 1, this._emissiveIntensity = 1, this._environmentIntensity = 1, this._specularIntensity = 1, this._lightingInfos = new te(this._directIntensity, this._emissiveIntensity, this._environmentIntensity, this._specularIntensity), this._disableBumpMap = !1, this._albedoTexture = null, this._baseWeightTexture = null, this._baseDiffuseRoughnessTexture = null, this._ambientTexture = null, this._ambientTextureStrength = 1, this._ambientTextureImpactOnAnalyticalLights = f.DEFAULT_AO_ON_ANALYTICAL_LIGHTS, this._opacityTexture = null, this._reflectionTexture = null, this._emissiveTexture = null, this._reflectivityTexture = null, this._metallicTexture = null, this._metallic = null, this._roughness = null, this._metallicF0Factor = 1, this._metallicReflectanceColor = d.White(), this._useOnlyMetallicFromMetallicReflectanceTexture = !1, this._metallicReflectanceTexture = null, this._reflectanceTexture = null, this._microSurfaceTexture = null, this._bumpTexture = null, this._lightmapTexture = null, this._ambientColor = new d(0, 0, 0), this._albedoColor = new d(1, 1, 1), this._baseWeight = 1, this._baseDiffuseRoughness = null, this._reflectivityColor = new d(1, 1, 1), this._reflectionColor = new d(1, 1, 1), this._emissiveColor = new d(0, 0, 0), this._microSurface = 0.9, this._useLightmapAsShadowmap = !1, this._useHorizonOcclusion = !0, this._useRadianceOcclusion = !0, this._useAlphaFromAlbedoTexture = !1, this._useSpecularOverAlpha = !0, this._useMicroSurfaceFromReflectivityMapAlpha = !1, this._useRoughnessFromMetallicTextureAlpha = !0, this._useRoughnessFromMetallicTextureGreen = !1, this._useMetallnessFromMetallicTextureBlue = !1, this._useAmbientOcclusionFromMetallicTextureRed = !1, this._useAmbientInGrayScale = !1, this._useAutoMicroSurfaceFromReflectivityMap = !1, this._lightFalloff = f.LIGHTFALLOFF_PHYSICAL, this._useRadianceOverAlpha = !0, 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._forceIrradianceInFragment = !1, this._realTimeFiltering = !1, this._realTimeFilteringQuality = 8, this._forceNormalForward = !1, this._enableSpecularAntiAliasing = !1, this._renderTargets = new se(16), this._globalAmbientColor = new d(0, 0, 0), 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.brdf = new c(this), this.clearCoat = new m(this), this.iridescence = new b(this), this.anisotropy = new k(this), this.sheen = new g(this), this.subSurface = new E(this), this.detailMap = new ie(this), this._attachImageProcessingConfiguration(null), this.getRenderTargetTextures = () => (this._renderTargets.reset(), l.ReflectionTextureEnabled && this._reflectionTexture && this._reflectionTexture.isRenderTarget && this._renderTargets.push(this._reflectionTexture), this._eventInfo.renderTargets = this._renderTargets, this._callbackPluginEventFillRenderTargetTextures(this._eventInfo), this._renderTargets), this._environmentBRDFTexture = Z(this.getScene()), this.prePassConfiguration = new w();
+  }
+  /**
+   * Gets a boolean indicating that current material needs to register RTT
+   */
+  get hasRenderTargetTextures() {
+    return l.ReflectionTextureEnabled && this._reflectionTexture && this._reflectionTexture.isRenderTarget ? !0 : this._cacheHasRenderTargetTextures;
+  }
+  /**
+   * Can this material render to prepass
+   */
+  get isPrePassCapable() {
+    return !this.disableDepthWrite;
+  }
+  /**
+   * @returns the name of the material class.
+   */
+  getClassName() {
+    return "PBRBaseMaterial";
+  }
+  /**
+   * Returns true if alpha blending should be disabled.
+   */
+  get _disableAlphaBlending() {
+    return this._transparencyMode === f.PBRMATERIAL_OPAQUE || this._transparencyMode === f.PBRMATERIAL_ALPHATEST || this.subSurface?.disableAlphaBlending;
+  }
+  /**
+   * @returns whether or not this material should be rendered in alpha blend mode.
+   */
+  needAlphaBlending() {
+    return this._hasTransparencyMode ? this._transparencyModeIsBlend : this._disableAlphaBlending ? !1 : this.alpha < 1 || this._opacityTexture != null || this._shouldUseAlphaFromAlbedoTexture();
+  }
+  /**
+   * @returns whether or not this material should be rendered in alpha test mode.
+   */
+  needAlphaTesting() {
+    return this._hasTransparencyMode ? this._transparencyModeIsTest : this.subSurface?.disableAlphaBlending ? !1 : this._hasAlphaChannel() && (this._transparencyMode == null || this._transparencyMode === f.PBRMATERIAL_ALPHATEST);
+  }
+  /**
+   * @returns whether or not the alpha value of the albedo texture should be used for alpha blending.
+   */
+  _shouldUseAlphaFromAlbedoTexture() {
+    return this._albedoTexture != null && this._albedoTexture.hasAlpha && this._useAlphaFromAlbedoTexture && this._transparencyMode !== f.PBRMATERIAL_OPAQUE;
+  }
+  /**
+   * @returns whether or not there is a usable alpha channel for transparency.
+   */
+  _hasAlphaChannel() {
+    return this._albedoTexture != null && this._albedoTexture.hasAlpha || this._opacityTexture != null;
+  }
+  /**
+   * @returns the texture used for the alpha test.
+   */
+  getAlphaTestTexture() {
+    return this._albedoTexture;
+  }
+  /**
+   * 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(e, i, t) {
+    this._uniformBufferLayoutBuilt || this.buildUniformLayout();
+    const o = i._drawWrapper;
+    if (o.effect && this.isFrozen && o._wasPreviouslyReady && o._wasPreviouslyUsingInstances === t)
+      return !0;
+    i.materialDefines || (this._callbackPluginEventGeneric(4, this._eventInfo), i.materialDefines = new Q(this._eventInfo.defineNames));
+    const h = i.materialDefines;
+    if (this._isReadyForSubMesh(i))
+      return !0;
+    const R = this.getScene(), S = R.getEngine();
+    if (h._areTexturesDirty && (this._eventInfo.hasRenderTargetTextures = !1, this._callbackPluginEventHasRenderTargetTextures(this._eventInfo), this._cacheHasRenderTargetTextures = this._eventInfo.hasRenderTargetTextures, R.texturesEnabled)) {
+      if (this._albedoTexture && l.DiffuseTextureEnabled && !this._albedoTexture.isReadyOrNotBlocking() || this._baseWeightTexture && l.BaseWeightTextureEnabled && !this._baseWeightTexture.isReadyOrNotBlocking() || this._baseDiffuseRoughnessTexture && l.BaseDiffuseRoughnessTextureEnabled && !this._baseDiffuseRoughnessTexture.isReadyOrNotBlocking() || this._ambientTexture && l.AmbientTextureEnabled && !this._ambientTexture.isReadyOrNotBlocking() || this._opacityTexture && l.OpacityTextureEnabled && !this._opacityTexture.isReadyOrNotBlocking())
+        return !1;
+      const n = this._getReflectionTexture();
+      if (n && l.ReflectionTextureEnabled) {
+        if (!n.isReadyOrNotBlocking())
+          return !1;
+        if (n.irradianceTexture) {
+          if (!n.irradianceTexture.isReadyOrNotBlocking())
+            return !1;
+        } else if (!n.sphericalPolynomial && n.getInternalTexture()?._sphericalPolynomialPromise)
+          return !1;
+      }
+      if (this._lightmapTexture && l.LightmapTextureEnabled && !this._lightmapTexture.isReadyOrNotBlocking() || this._emissiveTexture && l.EmissiveTextureEnabled && !this._emissiveTexture.isReadyOrNotBlocking())
+        return !1;
+      if (l.SpecularTextureEnabled) {
+        if (this._metallicTexture) {
+          if (!this._metallicTexture.isReadyOrNotBlocking())
+            return !1;
+        } else if (this._reflectivityTexture && !this._reflectivityTexture.isReadyOrNotBlocking())
+          return !1;
+        if (this._metallicReflectanceTexture && !this._metallicReflectanceTexture.isReadyOrNotBlocking() || this._reflectanceTexture && !this._reflectanceTexture.isReadyOrNotBlocking() || this._microSurfaceTexture && !this._microSurfaceTexture.isReadyOrNotBlocking())
+          return !1;
+      }
+      if (S.getCaps().standardDerivatives && this._bumpTexture && l.BumpTextureEnabled && !this._disableBumpMap && !this._bumpTexture.isReady() || this._environmentBRDFTexture && l.ReflectionTextureEnabled && !this._environmentBRDFTexture.isReady())
+        return !1;
+    }
+    if (this._eventInfo.isReadyForSubMesh = !0, this._eventInfo.defines = h, this._eventInfo.subMesh = i, this._callbackPluginEventIsReadyForSubMesh(this._eventInfo), !this._eventInfo.isReadyForSubMesh || h._areImageProcessingDirty && this._imageProcessingConfiguration && !this._imageProcessingConfiguration.isReady())
+      return !1;
+    if (h.AREALIGHTUSED || h.CLUSTLIGHT_BATCH) {
+      for (let n = 0; n < e.lightSources.length; n++)
+        if (!e.lightSources[n]._isReady())
+          return !1;
+    }
+    if (!S.getCaps().standardDerivatives && !e.isVerticesDataPresent(F.NormalKind) && (e.createNormals(!0), re.Warn("PBRMaterial: Normals have been created for the mesh: " + e.name)), !ae(R, e, this._maxSimultaneousLights, this._disableLighting))
+      return !1;
+    const C = i.effect, A = h._areLightsDisposed, T = this._prepareEffect(e, i.getRenderingMesh(), h, this.onCompiled, this.onError, t, null);
+    let _ = !1;
+    if (T)
+      if (this._onEffectCreatedObservable && (U.effect = T, U.subMesh = i, this._onEffectCreatedObservable.notifyObservers(U)), this.allowShaderHotSwapping && C && !T.isReady()) {
+        if (h.markAsUnprocessed(), _ = this.isFrozen, A)
+          return h._areLightsDisposed = !0, !1;
+      } else
+        R.resetCachedMaterial(), i.setEffect(T, h, this._materialContext);
+    return !i.effect || !i.effect.isReady() ? !1 : (h._renderId = R.getRenderId(), o._wasPreviouslyReady = !_, o._wasPreviouslyUsingInstances = !!t, this._checkScenePerformancePriority(), !0);
+  }
+  /**
+   * Specifies if the material uses metallic roughness workflow.
+   * @returns boolean specifying if the material uses metallic roughness workflow.
+   */
+  isMetallicWorkflow() {
+    return !!(this._metallic != null || this._roughness != null || this._metallicTexture);
+  }
+  _prepareEffect(e, i, t, o = null, h = null, R = null, S = null) {
+    if (this._prepareDefines(e, i, t, R, S), !t.isDirty)
+      return null;
+    t.markAsProcessed();
+    const A = this.getScene().getEngine(), T = new le();
+    let _ = 0;
+    t.USESPHERICALINVERTEX && T.addFallback(_++, "USESPHERICALINVERTEX"), t.FOG && T.addFallback(_, "FOG"), t.SPECULARAA && T.addFallback(_, "SPECULARAA"), t.POINTSIZE && T.addFallback(_, "POINTSIZE"), t.LOGARITHMICDEPTH && T.addFallback(_, "LOGARITHMICDEPTH"), t.PARALLAX && T.addFallback(_, "PARALLAX"), t.PARALLAX_RHS && T.addFallback(_, "PARALLAX_RHS"), t.PARALLAXOCCLUSION && T.addFallback(_++, "PARALLAXOCCLUSION"), t.ENVIRONMENTBRDF && T.addFallback(_++, "ENVIRONMENTBRDF"), t.TANGENT && T.addFallback(_++, "TANGENT"), t.BUMP && T.addFallback(_++, "BUMP"), _ = ne(t, T, this._maxSimultaneousLights, _), t.SPECULARTERM && T.addFallback(_++, "SPECULARTERM"), t.USESPHERICALFROMREFLECTIONMAP && T.addFallback(_++, "USESPHERICALFROMREFLECTIONMAP"), t.USEIRRADIANCEMAP && T.addFallback(_++, "USEIRRADIANCEMAP"), t.LIGHTMAP && T.addFallback(_++, "LIGHTMAP"), t.NORMAL && T.addFallback(_++, "NORMAL"), t.AMBIENT && T.addFallback(_++, "AMBIENT"), t.EMISSIVE && T.addFallback(_++, "EMISSIVE"), t.VERTEXCOLOR && T.addFallback(_++, "VERTEXCOLOR"), t.MORPHTARGETS && T.addFallback(_++, "MORPHTARGETS"), t.MULTIVIEW && T.addFallback(0, "MULTIVIEW");
+    const n = [F.PositionKind];
+    t.NORMAL && n.push(F.NormalKind), t.TANGENT && n.push(F.TangentKind);
+    for (let D = 1; D <= 6; ++D)
+      t["UV" + D] && n.push(`uv${D === 1 ? "" : D}`);
+    t.VERTEXCOLOR && n.push(F.ColorKind), ue(n, e, t, T), oe(n, t), he(n, e, t), Te(n, e, t);
+    let L = "pbr";
+    const y = [
+      "world",
+      "view",
+      "viewProjection",
+      "vEyePosition",
+      "vLightsType",
+      "vAmbientColor",
+      "vAlbedoColor",
+      "baseWeight",
+      "baseDiffuseRoughness",
+      "vReflectivityColor",
+      "vMetallicReflectanceFactors",
+      "vEmissiveColor",
+      "visibility",
+      "vFogInfos",
+      "vFogColor",
+      "pointSize",
+      "vAlbedoInfos",
+      "vBaseWeightInfos",
+      "vBaseDiffuseRoughnessInfos",
+      "vAmbientInfos",
+      "vOpacityInfos",
+      "vEmissiveInfos",
+      "vReflectivityInfos",
+      "vMetallicReflectanceInfos",
+      "vReflectanceInfos",
+      "vMicroSurfaceSamplerInfos",
+      "vBumpInfos",
+      "vLightmapInfos",
+      "mBones",
+      "albedoMatrix",
+      "baseWeightMatrix",
+      "baseDiffuseRoughnessMatrix",
+      "ambientMatrix",
+      "opacityMatrix",
+      "emissiveMatrix",
+      "reflectivityMatrix",
+      "normalMatrix",
+      "microSurfaceSamplerMatrix",
+      "bumpMatrix",
+      "lightmapMatrix",
+      "metallicReflectanceMatrix",
+      "reflectanceMatrix",
+      "vLightingIntensity",
+      "logarithmicDepthConstant",
+      "vTangentSpaceParams",
+      "boneTextureInfo",
+      "vDebugMode",
+      "morphTargetTextureInfo",
+      "morphTargetTextureIndices",
+      "cameraInfo",
+      "vTextureRepetitionHexTilingParams"
+    ], O = [
+      "albedoSampler",
+      "baseWeightSampler",
+      "baseDiffuseRoughnessSampler",
+      "reflectivitySampler",
+      "ambientSampler",
+      "emissiveSampler",
+      "bumpSampler",
+      "lightmapSampler",
+      "opacitySampler",
+      "microSurfaceSampler",
+      "environmentBrdfSampler",
+      "boneSampler",
+      "metallicReflectanceSampler",
+      "reflectanceSampler",
+      "morphTargets",
+      "oitDepthSampler",
+      "oitFrontColorSampler",
+      "areaLightsLTC1Sampler",
+      "areaLightsLTC2Sampler"
+    ];
+    _e(y, O, !0);
+    const B = ["Material", "Scene", "Mesh"], W = { maxSimultaneousLights: this._maxSimultaneousLights, maxSimultaneousMorphTargets: t.NUM_MORPH_INFLUENCERS };
+    if (this._eventInfo.fallbacks = T, this._eventInfo.fallbackRank = _, this._eventInfo.defines = t, this._eventInfo.uniforms = y, this._eventInfo.attributes = n, this._eventInfo.samplers = O, this._eventInfo.uniformBuffersNames = B, this._eventInfo.customCode = void 0, this._eventInfo.mesh = e, this._eventInfo.indexParameters = W, this._callbackPluginEventGeneric(128, this._eventInfo), X.AddUniformsAndSamplers(y, O), w.AddUniforms(y), ce(y), this._useVertexPulling) {
+      const D = i?.geometry;
+      D && (this._vertexPullingMetadata = Ee(D), this._vertexPullingMetadata && this._vertexPullingMetadata.forEach((Ze, $) => {
+        y.push(`vp_${$}_info`);
+      }));
+    } else
+      this._vertexPullingMetadata = null;
+    Y && (Y.PrepareUniforms(y, t), Y.PrepareSamplers(O, t)), Ae({
+      uniformsNames: y,
+      uniformBuffersNames: B,
+      samplers: O,
+      defines: t,
+      maxSimultaneousLights: this._maxSimultaneousLights,
+      shaderLanguage: this._shaderLanguage
+    });
+    const z = {};
+    this.customShaderNameResolve && (L = this.customShaderNameResolve(L, y, B, O, t, n, z));
+    const j = t.toString(), J = A.createEffect(L, {
+      attributes: n,
+      uniformsNames: y,
+      uniformBuffersNames: B,
+      samplers: O,
+      defines: j,
+      fallbacks: T,
+      onCompiled: o,
+      onError: h,
+      indexParameters: W,
+      processFinalCode: z.processFinalCode,
+      processCodeAfterIncludes: this._eventInfo.customCode,
+      multiTarget: t.PREPASS,
+      shaderLanguage: this._shaderLanguage,
+      extraInitializationsAsync: this._shadersLoaded ? void 0 : async () => {
+        this.shaderLanguage === 1 ? await Promise.all([import("./pbr.vertex-DJMAkDxs.js"), import("./pbr.fragment-CYZk_EGU.js")]) : await Promise.all([import("./pbr.vertex-CyvdCw91.js"), import("./pbr.fragment-BnaAAGxb.js")]), this._shadersLoaded = !0;
+      }
+    }, A);
+    return this._eventInfo.customCode = void 0, J;
+  }
+  _prepareDefines(e, i, t, o = null, h = null) {
+    const R = i.hasThinInstances, S = this.getScene(), C = S.getEngine();
+    fe(S, e, t, !0, this._maxSimultaneousLights, this._disableLighting), t._needNormals = !0, Se(S, t);
+    const A = this.needAlphaBlendingForMesh(e) && this.getScene().useOrderIndependentTransparency;
+    if (Re(S, t, this.canRenderToMRT && !A), xe(S, t, A), X.PrepareDefines(C.currentRenderPassId, e, t), t.METALLICWORKFLOW = this.isMetallicWorkflow(), t._areTexturesDirty) {
+      t._needUVs = !1;
+      for (let T = 1; T <= 6; ++T)
+        t["MAINUV" + T] = !1;
+      if (S.texturesEnabled) {
+        t.ALBEDODIRECTUV = 0, t.BASE_WEIGHTDIRECTUV = 0, t.BASE_DIFFUSE_ROUGHNESSDIRECTUV = 0, t.AMBIENTDIRECTUV = 0, t.OPACITYDIRECTUV = 0, t.EMISSIVEDIRECTUV = 0, t.REFLECTIVITYDIRECTUV = 0, t.MICROSURFACEMAPDIRECTUV = 0, t.METALLIC_REFLECTANCEDIRECTUV = 0, t.REFLECTANCEDIRECTUV = 0, t.BUMPDIRECTUV = 0, t.LIGHTMAPDIRECTUV = 0, C.getCaps().textureLOD && (t.LODBASEDMICROSFURACE = !0), this._albedoTexture && l.DiffuseTextureEnabled ? (p(this._albedoTexture, t, "ALBEDO"), t.GAMMAALBEDO = this._albedoTexture.gammaSpace) : t.ALBEDO = !1, this._baseWeightTexture && l.BaseWeightTextureEnabled ? p(this._baseWeightTexture, t, "BASE_WEIGHT") : t.BASE_WEIGHT = !1, this._baseDiffuseRoughnessTexture && l.BaseDiffuseRoughnessTextureEnabled ? p(this._baseDiffuseRoughnessTexture, t, "BASE_DIFFUSE_ROUGHNESS") : t.BASE_DIFFUSE_ROUGHNESS = !1, this._ambientTexture && l.AmbientTextureEnabled ? (p(this._ambientTexture, t, "AMBIENT"), t.AMBIENTINGRAYSCALE = this._useAmbientInGrayScale) : t.AMBIENT = !1, this._opacityTexture && l.OpacityTextureEnabled ? (p(this._opacityTexture, t, "OPACITY"), t.OPACITYRGB = this._opacityTexture.getAlphaFromRGB) : t.OPACITY = !1;
+        const T = this._getReflectionTexture(), _ = this._forceIrradianceInFragment || this.realTimeFiltering || this._twoSidedLighting || C.getCaps().maxVaryingVectors <= 8 || this._baseDiffuseRoughnessTexture != null;
+        pe(S, T, t, this.realTimeFiltering, this.realTimeFilteringQuality, !_), this._lightmapTexture && l.LightmapTextureEnabled ? (p(this._lightmapTexture, t, "LIGHTMAP"), t.USELIGHTMAPASSHADOWMAP = this._useLightmapAsShadowmap, t.GAMMALIGHTMAP = this._lightmapTexture.gammaSpace, t.RGBDLIGHTMAP = this._lightmapTexture.isRGBD) : t.LIGHTMAP = !1, this._emissiveTexture && l.EmissiveTextureEnabled ? (p(this._emissiveTexture, t, "EMISSIVE"), t.GAMMAEMISSIVE = this._emissiveTexture.gammaSpace) : t.EMISSIVE = !1, l.SpecularTextureEnabled ? (this._metallicTexture ? (p(this._metallicTexture, t, "REFLECTIVITY"), t.ROUGHNESSSTOREINMETALMAPALPHA = this._useRoughnessFromMetallicTextureAlpha, t.ROUGHNESSSTOREINMETALMAPGREEN = !this._useRoughnessFromMetallicTextureAlpha && this._useRoughnessFromMetallicTextureGreen, t.METALLNESSSTOREINMETALMAPBLUE = this._useMetallnessFromMetallicTextureBlue, t.AOSTOREINMETALMAPRED = this._useAmbientOcclusionFromMetallicTextureRed, t.REFLECTIVITY_GAMMA = !1) : this._reflectivityTexture ? (p(this._reflectivityTexture, t, "REFLECTIVITY"), t.MICROSURFACEFROMREFLECTIVITYMAP = this._useMicroSurfaceFromReflectivityMapAlpha, t.MICROSURFACEAUTOMATIC = this._useAutoMicroSurfaceFromReflectivityMap, t.REFLECTIVITY_GAMMA = this._reflectivityTexture.gammaSpace) : t.REFLECTIVITY = !1, this._metallicReflectanceTexture || this._reflectanceTexture ? (t.METALLIC_REFLECTANCE_USE_ALPHA_ONLY = this._useOnlyMetallicFromMetallicReflectanceTexture, this._metallicReflectanceTexture ? (p(this._metallicReflectanceTexture, t, "METALLIC_REFLECTANCE"), t.METALLIC_REFLECTANCE_GAMMA = this._metallicReflectanceTexture.gammaSpace) : t.METALLIC_REFLECTANCE = !1, this._reflectanceTexture && (!this._metallicReflectanceTexture || this._metallicReflectanceTexture && this._useOnlyMetallicFromMetallicReflectanceTexture) ? (p(this._reflectanceTexture, t, "REFLECTANCE"), t.REFLECTANCE_GAMMA = this._reflectanceTexture.gammaSpace) : t.REFLECTANCE = !1) : (t.METALLIC_REFLECTANCE = !1, t.REFLECTANCE = !1), this._microSurfaceTexture ? p(this._microSurfaceTexture, t, "MICROSURFACEMAP") : t.MICROSURFACEMAP = !1) : (t.REFLECTIVITY = !1, t.MICROSURFACEMAP = !1), C.getCaps().standardDerivatives && this._bumpTexture && l.BumpTextureEnabled && !this._disableBumpMap ? (p(this._bumpTexture, t, "BUMP"), this._useParallax && this._albedoTexture && l.DiffuseTextureEnabled ? (t.PARALLAX = !0, t.PARALLAX_RHS = S.useRightHandedSystem, t.PARALLAXOCCLUSION = !!this._useParallaxOcclusion) : t.PARALLAX = !1, t.OBJECTSPACE_NORMALMAP = this._useObjectSpaceNormalMap) : (t.BUMP = !1, t.PARALLAX = !1, t.PARALLAX_RHS = !1, t.PARALLAXOCCLUSION = !1, t.OBJECTSPACE_NORMALMAP = !1), this._environmentBRDFTexture && l.ReflectionTextureEnabled ? (t.ENVIRONMENTBRDF = !0, t.ENVIRONMENTBRDF_RGBD = this._environmentBRDFTexture.isRGBD) : (t.ENVIRONMENTBRDF = !1, t.ENVIRONMENTBRDF_RGBD = !1), this._shouldUseAlphaFromAlbedoTexture() ? t.ALPHAFROMALBEDO = !0 : t.ALPHAFROMALBEDO = !1;
+      }
+      t.SPECULAROVERALPHA = this._useSpecularOverAlpha, this._lightFalloff === f.LIGHTFALLOFF_STANDARD ? (t.USEPHYSICALLIGHTFALLOFF = !1, t.USEGLTFLIGHTFALLOFF = !1) : this._lightFalloff === f.LIGHTFALLOFF_GLTF ? (t.USEPHYSICALLIGHTFALLOFF = !1, t.USEGLTFLIGHTFALLOFF = !0) : (t.USEPHYSICALLIGHTFALLOFF = !0, t.USEGLTFLIGHTFALLOFF = !1), t.RADIANCEOVERALPHA = this._useRadianceOverAlpha, !this.backFaceCulling && this._twoSidedLighting ? t.TWOSIDEDLIGHTING = !0 : t.TWOSIDEDLIGHTING = !1, t.MIRRORED = !!S._mirroredCameraPosition, t.SPECULARAA = C.getCaps().standardDerivatives && this._enableSpecularAntiAliasing;
+    }
+    (t._areTexturesDirty || t._areMiscDirty) && (t.ALPHATESTVALUE = `${this._alphaCutOff}${this._alphaCutOff % 1 === 0 ? "." : ""}`, t.PREMULTIPLYALPHA = this.alphaMode === 7 || this.alphaMode === 8, t.ALPHABLEND = this.needAlphaBlendingForMesh(e), t.ALPHAFRESNEL = this._useAlphaFresnel || this._useLinearAlphaFresnel, t.LINEARALPHAFRESNEL = this._useLinearAlphaFresnel), t._areTexturesDirty && (t.TEXTURE_REPETITION_MODE = C.version > 1 || C.isWebGPU ? this.textureRepetitionMode : 0), t._areImageProcessingDirty && this._imageProcessingConfiguration && this._imageProcessingConfiguration.prepareDefines(t), t.FORCENORMALFORWARD = this._forceNormalForward, t.RADIANCEOCCLUSION = this._useRadianceOcclusion, t.HORIZONOCCLUSION = this._useHorizonOcclusion, t._areMiscDirty && (Ie(e, S, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(e), t, this._applyDecalMapAfterDetailMap, this._useVertexPulling, i, this._isVertexOutputInvariant), t.UNLIT = this._unlit || (this.pointsCloud || this.wireframe) && !e.isVerticesDataPresent(F.NormalKind), t.DEBUGMODE = this._debugMode), Ce(S, C, this, t, !!o, h, R), this._eventInfo.defines = t, this._eventInfo.mesh = e, this._callbackPluginEventPrepareDefinesBeforeAttributes(this._eventInfo), me(e, t, !0, !0, !0, this._transparencyMode !== f.PBRMATERIAL_OPAQUE), this._callbackPluginEventPrepareDefines(this._eventInfo);
+  }
+  /**
+   * 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(e, i, t) {
+    const o = {
+      clipPlane: !1,
+      useInstances: !1,
+      ...t
+    };
+    this._uniformBufferLayoutBuilt || this.buildUniformLayout(), this._callbackPluginEventGeneric(4, this._eventInfo), (() => {
+      if (this._breakShaderLoadedCheck)
+        return;
+      const R = new Q(this._eventInfo.defineNames), S = this._prepareEffect(e, e, R, void 0, void 0, o.useInstances, o.clipPlane);
+      this._onEffectCreatedObservable && (U.effect = S, U.subMesh = null, this._onEffectCreatedObservable.notifyObservers(U)), S.isReady() ? i && i(this) : S.onCompileObservable.add(() => {
+        i && i(this);
+      });
+    })();
+  }
+  /**
+   * Initializes the uniform buffer layout for the shader.
+   */
+  buildUniformLayout() {
+    const e = this._uniformBuffer;
+    e.addUniform("vAlbedoInfos", 2), e.addUniform("vBaseWeightInfos", 2), e.addUniform("vBaseDiffuseRoughnessInfos", 2), e.addUniform("vAmbientInfos", 4), e.addUniform("vOpacityInfos", 2), e.addUniform("vEmissiveInfos", 2), e.addUniform("vLightmapInfos", 2), e.addUniform("vReflectivityInfos", 3), e.addUniform("vMicroSurfaceSamplerInfos", 2), e.addUniform("vBumpInfos", 3), e.addUniform("albedoMatrix", 16), e.addUniform("baseWeightMatrix", 16), e.addUniform("baseDiffuseRoughnessMatrix", 16), e.addUniform("ambientMatrix", 16), e.addUniform("opacityMatrix", 16), e.addUniform("emissiveMatrix", 16), e.addUniform("lightmapMatrix", 16), e.addUniform("reflectivityMatrix", 16), e.addUniform("microSurfaceSamplerMatrix", 16), e.addUniform("bumpMatrix", 16), e.addUniform("vTangentSpaceParams", 2), e.addUniform("vAlbedoColor", 4), e.addUniform("baseWeight", 1), e.addUniform("baseDiffuseRoughness", 1), e.addUniform("vLightingIntensity", 4), e.addUniform("pointSize", 1), e.addUniform("vReflectivityColor", 4), e.addUniform("vEmissiveColor", 3), e.addUniform("vAmbientColor", 3), e.addUniform("vDebugMode", 2), e.addUniform("vMetallicReflectanceFactors", 4), e.addUniform("vMetallicReflectanceInfos", 2), e.addUniform("metallicReflectanceMatrix", 16), e.addUniform("vReflectanceInfos", 2), e.addUniform("reflectanceMatrix", 16), e.addUniform("cameraInfo", 4), e.addUniform("vTextureRepetitionHexTilingParams", 4), de(e, !0, !0, !0, !0, !0), super.buildUniformLayout();
+  }
+  /**
+   * Binds the submesh data.
+   * @param world - The world matrix.
+   * @param mesh - The BJS mesh.
+   * @param subMesh - A submesh of the BJS mesh.
+   */
+  bindForSubMesh(e, i, t) {
+    const o = this.getScene(), h = t.materialDefines;
+    if (!h)
+      return;
+    const R = t.effect;
+    if (!R)
+      return;
+    this._activeEffect = R, i.getMeshUniformBuffer().bindToEffect(R, "Mesh"), i.transferToEffect(e);
+    const S = o.getEngine();
+    this._uniformBuffer.bindToEffect(R, "Material"), this.prePassConfiguration.bindForSubMesh(this._activeEffect, o, i, e, this.isFrozen), X.Bind(S.currentRenderPassId, this._activeEffect, i, e, this);
+    const C = o.activeCamera;
+    C ? this._uniformBuffer.updateFloat4("cameraInfo", C.minZ, C.maxZ, 0, 0) : this._uniformBuffer.updateFloat4("cameraInfo", 0, 0, 0, 0);
+    const A = this.textureRepetitionHexTilingParams;
+    this._uniformBuffer.updateFloat4("vTextureRepetitionHexTilingParams", A[0], A[1], A[2], A[3]), this._eventInfo.subMesh = t, this._callbackPluginEventHardBindForSubMesh(this._eventInfo), h.OBJECTSPACE_NORMALMAP && (e.toNormalMatrix(this._normalMatrix), this.bindOnlyNormalMatrix(this._normalMatrix));
+    const T = this._mustRebind(o, R, t, i.visibility);
+    be(i, this._activeEffect, this.prePassConfiguration), this._vertexPullingMetadata && ye(this._activeEffect, this._vertexPullingMetadata);
+    let _ = null;
+    const n = this._uniformBuffer;
+    if (T) {
+      if (this.bindViewProjection(R), _ = this._getReflectionTexture(), !n.useUbo || !this.isFrozen || !n.isSync || t._drawWrapper._forceRebindOnNextCall) {
+        if (o.texturesEnabled && (this._albedoTexture && l.DiffuseTextureEnabled && (n.updateFloat2("vAlbedoInfos", this._albedoTexture.coordinatesIndex, this._albedoTexture.level), I(this._albedoTexture, n, "albedo")), this._baseWeightTexture && l.BaseWeightTextureEnabled && (n.updateFloat2("vBaseWeightInfos", this._baseWeightTexture.coordinatesIndex, this._baseWeightTexture.level), I(this._baseWeightTexture, n, "baseWeight")), this._baseDiffuseRoughnessTexture && l.BaseDiffuseRoughnessTextureEnabled && (n.updateFloat2("vBaseDiffuseRoughnessInfos", this._baseDiffuseRoughnessTexture.coordinatesIndex, this._baseDiffuseRoughnessTexture.level), I(this._baseDiffuseRoughnessTexture, n, "baseDiffuseRoughness")), this._ambientTexture && l.AmbientTextureEnabled && (n.updateFloat4("vAmbientInfos", this._ambientTexture.coordinatesIndex, this._ambientTexture.level, this._ambientTextureStrength, this._ambientTextureImpactOnAnalyticalLights), I(this._ambientTexture, n, "ambient")), this._opacityTexture && l.OpacityTextureEnabled && (n.updateFloat2("vOpacityInfos", this._opacityTexture.coordinatesIndex, this._opacityTexture.level), I(this._opacityTexture, n, "opacity")), this._emissiveTexture && l.EmissiveTextureEnabled && (n.updateFloat2("vEmissiveInfos", this._emissiveTexture.coordinatesIndex, this._emissiveTexture.level), I(this._emissiveTexture, n, "emissive")), this._lightmapTexture && l.LightmapTextureEnabled && (n.updateFloat2("vLightmapInfos", this._lightmapTexture.coordinatesIndex, this._lightmapTexture.level), I(this._lightmapTexture, n, "lightmap")), l.SpecularTextureEnabled && (this._metallicTexture ? (n.updateFloat3("vReflectivityInfos", this._metallicTexture.coordinatesIndex, this._metallicTexture.level, this._ambientTextureStrength), I(this._metallicTexture, n, "reflectivity")) : this._reflectivityTexture && (n.updateFloat3("vReflectivityInfos", this._reflectivityTexture.coordinatesIndex, this._reflectivityTexture.level, 1), I(this._reflectivityTexture, n, "reflectivity")), this._metallicReflectanceTexture && (n.updateFloat2("vMetallicReflectanceInfos", this._metallicReflectanceTexture.coordinatesIndex, this._metallicReflectanceTexture.level), I(this._metallicReflectanceTexture, n, "metallicReflectance")), this._reflectanceTexture && h.REFLECTANCE && (n.updateFloat2("vReflectanceInfos", this._reflectanceTexture.coordinatesIndex, this._reflectanceTexture.level), I(this._reflectanceTexture, n, "reflectance")), this._microSurfaceTexture && (n.updateFloat2("vMicroSurfaceSamplerInfos", this._microSurfaceTexture.coordinatesIndex, this._microSurfaceTexture.level), I(this._microSurfaceTexture, n, "microSurfaceSampler"))), this._bumpTexture && S.getCaps().standardDerivatives && l.BumpTextureEnabled && !this._disableBumpMap && (n.updateFloat3("vBumpInfos", this._bumpTexture.coordinatesIndex, this._bumpTexture.level, this._parallaxScaleBias), I(this._bumpTexture, n, "bump"), o._mirroredCameraPosition ? n.updateFloat2("vTangentSpaceParams", this._invertNormalMapX ? 1 : -1, this._invertNormalMapY ? 1 : -1) : n.updateFloat2("vTangentSpaceParams", this._invertNormalMapX ? -1 : 1, this._invertNormalMapY ? -1 : 1)), Le(o, h, n, this._reflectionColor, _, this.realTimeFiltering, !0, !0, !0, !0, !0)), this.pointsCloud && n.updateFloat("pointSize", this.pointSize), h.METALLICWORKFLOW) {
+          H.Color4[0].r = this._metallic === void 0 || this._metallic === null ? 1 : this._metallic, H.Color4[0].g = this._roughness === void 0 || this._roughness === null ? 1 : this._roughness;
+          const L = this.subSurface?._indexOfRefraction ?? 1.5, y = 1;
+          H.Color4[0].b = L;
+          const O = Math.pow((L - y) / (L + y), 2);
+          H.Color4[0].a = O, n.updateDirectColor4("vReflectivityColor", H.Color4[0]), n.updateColor4("vMetallicReflectanceFactors", this._metallicReflectanceColor, this._metallicF0Factor);
+        } else
+          n.updateColor4("vReflectivityColor", this._reflectivityColor, this._microSurface);
+        n.updateColor3("vEmissiveColor", l.EmissiveTextureEnabled ? this._emissiveColor : d.BlackReadOnly), !h.SS_REFRACTION && this.subSurface?._linkRefractionWithTransparency ? n.updateColor4("vAlbedoColor", this._albedoColor, 1) : n.updateColor4("vAlbedoColor", this._albedoColor, this.alpha), n.updateFloat("baseWeight", this._baseWeight), n.updateFloat("baseDiffuseRoughness", this._baseDiffuseRoughness || 0), this._lightingInfos.x = this._directIntensity, this._lightingInfos.y = this._emissiveIntensity, this._lightingInfos.z = this._environmentIntensity * o.environmentIntensity, this._lightingInfos.w = this._specularIntensity, n.updateVector4("vLightingIntensity", this._lightingInfos), o.ambientColor.multiplyToRef(this._ambientColor, this._globalAmbientColor), n.updateColor3("vAmbientColor", this._globalAmbientColor), n.updateFloat2("vDebugMode", this.debugLimit, this.debugFactor);
+      }
+      o.texturesEnabled && (this._albedoTexture && l.DiffuseTextureEnabled && n.setTexture("albedoSampler", this._albedoTexture), this._baseWeightTexture && l.BaseWeightTextureEnabled && n.setTexture("baseWeightSampler", this._baseWeightTexture), this._baseDiffuseRoughnessTexture && l.BaseDiffuseRoughnessTextureEnabled && n.setTexture("baseDiffuseRoughnessSampler", this._baseDiffuseRoughnessTexture), this._ambientTexture && l.AmbientTextureEnabled && n.setTexture("ambientSampler", this._ambientTexture), this._opacityTexture && l.OpacityTextureEnabled && n.setTexture("opacitySampler", this._opacityTexture), Me(o, h, n, _, this.realTimeFiltering), h.ENVIRONMENTBRDF && n.setTexture("environmentBrdfSampler", this._environmentBRDFTexture), this._emissiveTexture && l.EmissiveTextureEnabled && n.setTexture("emissiveSampler", this._emissiveTexture), this._lightmapTexture && l.LightmapTextureEnabled && n.setTexture("lightmapSampler", this._lightmapTexture), l.SpecularTextureEnabled && (this._metallicTexture ? n.setTexture("reflectivitySampler", this._metallicTexture) : this._reflectivityTexture && n.setTexture("reflectivitySampler", this._reflectivityTexture), this._metallicReflectanceTexture && n.setTexture("metallicReflectanceSampler", this._metallicReflectanceTexture), this._reflectanceTexture && h.REFLECTANCE && n.setTexture("reflectanceSampler", this._reflectanceTexture), this._microSurfaceTexture && n.setTexture("microSurfaceSampler", this._microSurfaceTexture)), this._bumpTexture && S.getCaps().standardDerivatives && l.BumpTextureEnabled && !this._disableBumpMap && n.setTexture("bumpSampler", this._bumpTexture)), this.getScene().useOrderIndependentTransparency && this.needAlphaBlendingForMesh(i) && this.getScene().depthPeelingRenderer.bind(R), this._eventInfo.subMesh = t, this._callbackPluginEventBindForSubMesh(this._eventInfo), Ne(this._activeEffect, this, o), this.bindEyePosition(R);
+    } else o.getEngine()._features.needToAlwaysBindUniformBuffers && (this._needToBindSceneUbo = !0);
+    (T || !this.isFrozen) && (o.lightsEnabled && !this._disableLighting && ge(o, i, this._activeEffect, h, this._maxSimultaneousLights), (o.fogEnabled && i.applyFog && o.fogMode !== Oe.FOGMODE_NONE || _ || this.subSurface.refractionTexture || i.receiveShadows || h.PREPASS || h.CLUSTLIGHT_BATCH) && this.bindView(R), De(o, i, this._activeEffect, !0), h.NUM_MORPH_INFLUENCERS && Fe(i, this._activeEffect), h.BAKED_VERTEX_ANIMATION_TEXTURE && i.bakedVertexAnimationManager?.bind(R, h.INSTANCES), this._imageProcessingConfiguration.bind(this._activeEffect), ve(h, this._activeEffect, o)), this._afterBind(i, this._activeEffect, t), n.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 e = super.getAnimatables();
+    return this._albedoTexture && this._albedoTexture.animations && this._albedoTexture.animations.length > 0 && e.push(this._albedoTexture), this._baseWeightTexture && this._baseWeightTexture.animations && this._baseWeightTexture.animations.length > 0 && e.push(this._baseWeightTexture), this._baseDiffuseRoughnessTexture && this._baseDiffuseRoughnessTexture.animations && this._baseDiffuseRoughnessTexture.animations.length > 0 && e.push(this._baseDiffuseRoughnessTexture), this._ambientTexture && this._ambientTexture.animations && this._ambientTexture.animations.length > 0 && e.push(this._ambientTexture), this._opacityTexture && this._opacityTexture.animations && this._opacityTexture.animations.length > 0 && e.push(this._opacityTexture), this._reflectionTexture && this._reflectionTexture.animations && this._reflectionTexture.animations.length > 0 && e.push(this._reflectionTexture), this._emissiveTexture && this._emissiveTexture.animations && this._emissiveTexture.animations.length > 0 && e.push(this._emissiveTexture), this._metallicTexture && this._metallicTexture.animations && this._metallicTexture.animations.length > 0 ? e.push(this._metallicTexture) : this._reflectivityTexture && this._reflectivityTexture.animations && this._reflectivityTexture.animations.length > 0 && e.push(this._reflectivityTexture), this._bumpTexture && this._bumpTexture.animations && this._bumpTexture.animations.length > 0 && e.push(this._bumpTexture), this._lightmapTexture && this._lightmapTexture.animations && this._lightmapTexture.animations.length > 0 && e.push(this._lightmapTexture), this._metallicReflectanceTexture && this._metallicReflectanceTexture.animations && this._metallicReflectanceTexture.animations.length > 0 && e.push(this._metallicReflectanceTexture), this._reflectanceTexture && this._reflectanceTexture.animations && this._reflectanceTexture.animations.length > 0 && e.push(this._reflectanceTexture), this._microSurfaceTexture && this._microSurfaceTexture.animations && this._microSurfaceTexture.animations.length > 0 && e.push(this._microSurfaceTexture), e;
+  }
+  /**
+   * Returns the texture used for reflections.
+   * @returns - Reflection texture if present.  Otherwise, returns the environment texture.
+   */
+  _getReflectionTexture() {
+    return this._reflectionTexture ? this._reflectionTexture : this.getScene().environmentTexture;
+  }
+  /**
+   * Returns an array of the actively used textures.
+   * @returns - Array of BaseTextures
+   */
+  getActiveTextures() {
+    const e = super.getActiveTextures();
+    return this._albedoTexture && e.push(this._albedoTexture), this._baseWeightTexture && e.push(this._baseWeightTexture), this._baseDiffuseRoughnessTexture && e.push(this._baseDiffuseRoughnessTexture), this._ambientTexture && e.push(this._ambientTexture), this._opacityTexture && e.push(this._opacityTexture), this._reflectionTexture && e.push(this._reflectionTexture), this._emissiveTexture && e.push(this._emissiveTexture), this._reflectivityTexture && e.push(this._reflectivityTexture), this._metallicTexture && e.push(this._metallicTexture), this._metallicReflectanceTexture && e.push(this._metallicReflectanceTexture), this._reflectanceTexture && e.push(this._reflectanceTexture), this._microSurfaceTexture && e.push(this._microSurfaceTexture), this._bumpTexture && e.push(this._bumpTexture), this._lightmapTexture && e.push(this._lightmapTexture), e;
+  }
+  /**
+   * 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(e) {
+    return !!(super.hasTexture(e) || this._albedoTexture === e || this._baseWeightTexture === e || this._baseDiffuseRoughnessTexture === e || this._ambientTexture === e || this._opacityTexture === e || this._reflectionTexture === e || this._emissiveTexture === e || this._reflectivityTexture === e || this._metallicTexture === e || this._metallicReflectanceTexture === e || this._reflectanceTexture === e || this._microSurfaceTexture === e || this._bumpTexture === e || this._lightmapTexture === e);
+  }
+  /**
+   * 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() {
+    if (!this.subSurface?.isScatteringEnabled)
+      return !1;
+    const e = this.getScene().enableSubSurfaceForPrePass();
+    return e && (e.enabled = !0), !0;
+  }
+  /**
+   * Disposes the resources of the material.
+   * @param forceDisposeEffect - Forces the disposal of effects.
+   * @param forceDisposeTextures - Forces the disposal of all textures.
+   */
+  dispose(e, i) {
+    this._breakShaderLoadedCheck = !0, i && (this._environmentBRDFTexture && this.getScene().environmentBRDFTexture !== this._environmentBRDFTexture && this._environmentBRDFTexture.dispose(), this._albedoTexture?.dispose(), this._baseWeightTexture?.dispose(), this._baseDiffuseRoughnessTexture?.dispose(), this._ambientTexture?.dispose(), this._opacityTexture?.dispose(), this._reflectionTexture?.dispose(), this._emissiveTexture?.dispose(), this._metallicTexture?.dispose(), this._reflectivityTexture?.dispose(), this._bumpTexture?.dispose(), this._lightmapTexture?.dispose(), this._metallicReflectanceTexture?.dispose(), this._reflectanceTexture?.dispose(), this._microSurfaceTexture?.dispose()), this._renderTargets.dispose(), this._imageProcessingConfiguration && this._imageProcessingObserver && this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver), super.dispose(e, i);
+  }
+}
+f.PBRMATERIAL_OPAQUE = G.MATERIAL_OPAQUE;
+f.PBRMATERIAL_ALPHATEST = G.MATERIAL_ALPHATEST;
+f.PBRMATERIAL_ALPHABLEND = G.MATERIAL_ALPHABLEND;
+f.PBRMATERIAL_ALPHATESTANDBLEND = G.MATERIAL_ALPHATESTANDBLEND;
+f.DEFAULT_AO_ON_ANALYTICAL_LIGHTS = 0;
+f.LIGHTFALLOFF_PHYSICAL = 0;
+f.LIGHTFALLOFF_GLTF = 1;
+f.LIGHTFALLOFF_STANDARD = 2;
+f.ForceGLSL = !1;
+s([
+  r("_markAllSubMeshesAsMiscDirty")
+], f.prototype, "debugMode", void 0);
+class u extends f {
+  /**
+   * Stores the refracted light information in a texture.
+   */
+  get refractionTexture() {
+    return this.subSurface.refractionTexture;
+  }
+  set refractionTexture(e) {
+    this.subSurface.refractionTexture = e, e ? this.subSurface.isRefractionEnabled = !0 : this.subSurface.linkRefractionWithTransparency || (this.subSurface.isRefractionEnabled = !1);
+  }
+  /**
+   * Index of refraction of the material base layer.
+   * https://en.wikipedia.org/wiki/List_of_refractive_indices
+   *
+   * This does not only impact refraction but also the Base F0 of Dielectric Materials.
+   *
+   * From dielectric fresnel rules: F0 = square((iorT - iorI) / (iorT + iorI))
+   */
+  get indexOfRefraction() {
+    return this.subSurface.indexOfRefraction;
+  }
+  set indexOfRefraction(e) {
+    this.subSurface.indexOfRefraction = e;
+  }
+  /**
+   * Controls if refraction needs to be inverted on Y. This could be useful for procedural texture.
+   */
+  get invertRefractionY() {
+    return this.subSurface.invertRefractionY;
+  }
+  set invertRefractionY(e) {
+    this.subSurface.invertRefractionY = e;
+  }
+  /**
+   * This parameters will make the material used its opacity to control how much it is refracting against not.
+   * Materials half opaque for instance using refraction could benefit from this control.
+   */
+  get linkRefractionWithTransparency() {
+    return this.subSurface.linkRefractionWithTransparency;
+  }
+  set linkRefractionWithTransparency(e) {
+    this.subSurface.linkRefractionWithTransparency = e, e && (this.subSurface.isRefractionEnabled = !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 === f.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(e) {
+    e !== this.usePhysicalLightFalloff && (this._markAllSubMeshesAsTexturesDirty(), e ? this._lightFalloff = f.LIGHTFALLOFF_PHYSICAL : this._lightFalloff = f.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 === f.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(e) {
+    e !== this.useGLTFLightFalloff && (this._markAllSubMeshesAsTexturesDirty(), e ? this._lightFalloff = f.LIGHTFALLOFF_GLTF : this._lightFalloff = f.LIGHTFALLOFF_STANDARD);
+  }
+  /**
+   * Instantiates a new PBRMaterial 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(e, i, t = !1) {
+    super(e, i, t), this.directIntensity = 1, this.emissiveIntensity = 1, this.environmentIntensity = 1, this.specularIntensity = 1, this.disableBumpMap = !1, this.ambientTextureStrength = 1, this.ambientTextureImpactOnAnalyticalLights = u.DEFAULT_AO_ON_ANALYTICAL_LIGHTS, this.metallicF0Factor = 1, this.metallicReflectanceColor = d.White(), this.useOnlyMetallicFromMetallicReflectanceTexture = !1, this.ambientColor = new d(0, 0, 0), this.albedoColor = new d(1, 1, 1), this.baseWeight = 1, this.reflectivityColor = new d(1, 1, 1), this.reflectionColor = new d(1, 1, 1), this.emissiveColor = new d(0, 0, 0), this.microSurface = 1, this.useLightmapAsShadowmap = !1, this.useAlphaFromAlbedoTexture = !1, this.forceAlphaTest = !1, this.alphaCutOff = 0.4, this.useSpecularOverAlpha = !0, this.useMicroSurfaceFromReflectivityMapAlpha = !1, this.useRoughnessFromMetallicTextureAlpha = !0, this.useRoughnessFromMetallicTextureGreen = !1, this.useMetallnessFromMetallicTextureBlue = !1, this.useAmbientOcclusionFromMetallicTextureRed = !1, this.useAmbientInGrayScale = !1, this.useAutoMicroSurfaceFromReflectivityMap = !1, this.useRadianceOverAlpha = !0, 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._environmentBRDFTexture = Z(this.getScene());
+  }
+  /**
+   * @returns the name of this material class.
+   */
+  getClassName() {
+    return "PBRMaterial";
+  }
+  /**
+   * 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 diffuse 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(e, i = !0, t = "") {
+    const o = K.Clone(() => new u(e, this.getScene()), this, { cloneTexturesOnlyOnce: i });
+    return o.id = e, o.name = e, this.stencil.copyTo(o.stencil), this._clonePlugins(o, t), o;
+  }
+  /**
+   * Serializes this PBR Material.
+   * @returns - An object with the serialized material.
+   */
+  serialize() {
+    const e = super.serialize();
+    return e.customType = "BABYLON.PBRMaterial", e;
+  }
+  // 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 - PBRMaterial
+   */
+  static Parse(e, i, t) {
+    const o = K.Parse(() => new u(e.name, i), e, i, t);
+    return e.stencil && o.stencil.parse(e.stencil, i, t), G._ParsePlugins(e, o, i, t), e.clearCoat && o.clearCoat.parse(e.clearCoat, i, t), e.anisotropy && o.anisotropy.parse(e.anisotropy, i, t), e.brdf && o.brdf.parse(e.brdf, i, t), e.sheen && o.sheen.parse(e.sheen, i, t), e.subSurface && o.subSurface.parse(e.subSurface, i, t), e.iridescence && o.iridescence.parse(e.iridescence, i, t), o;
+  }
+}
+u.PBRMATERIAL_OPAQUE = f.PBRMATERIAL_OPAQUE;
+u.PBRMATERIAL_ALPHATEST = f.PBRMATERIAL_ALPHATEST;
+u.PBRMATERIAL_ALPHABLEND = f.PBRMATERIAL_ALPHABLEND;
+u.PBRMATERIAL_ALPHATESTANDBLEND = f.PBRMATERIAL_ALPHATESTANDBLEND;
+u.DEFAULT_AO_ON_ANALYTICAL_LIGHTS = f.DEFAULT_AO_ON_ANALYTICAL_LIGHTS;
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "directIntensity", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "emissiveIntensity", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "environmentIntensity", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "specularIntensity", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "disableBumpMap", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "albedoTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "baseWeightTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "baseDiffuseRoughnessTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "ambientTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "ambientTextureStrength", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "ambientTextureImpactOnAnalyticalLights", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], u.prototype, "opacityTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "reflectionTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "emissiveTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "reflectivityTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "metallicTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "metallic", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "roughness", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "metallicF0Factor", void 0);
+s([
+  M(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "metallicReflectanceColor", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useOnlyMetallicFromMetallicReflectanceTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "metallicReflectanceTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "reflectanceTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "microSurfaceTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "bumpTexture", void 0);
+s([
+  x(),
+  r("_markAllSubMeshesAsTexturesDirty", null)
+], u.prototype, "lightmapTexture", void 0);
+s([
+  M("ambient"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "ambientColor", void 0);
+s([
+  M("albedo"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "albedoColor", void 0);
+s([
+  a("baseWeight"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "baseWeight", void 0);
+s([
+  a("baseDiffuseRoughness"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "baseDiffuseRoughness", void 0);
+s([
+  M("reflectivity"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "reflectivityColor", void 0);
+s([
+  M("reflection"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "reflectionColor", void 0);
+s([
+  M("emissive"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "emissiveColor", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "microSurface", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useLightmapAsShadowmap", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], u.prototype, "useAlphaFromAlbedoTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], u.prototype, "forceAlphaTest", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], u.prototype, "alphaCutOff", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useSpecularOverAlpha", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useMicroSurfaceFromReflectivityMapAlpha", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useRoughnessFromMetallicTextureAlpha", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useRoughnessFromMetallicTextureGreen", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useMetallnessFromMetallicTextureBlue", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useAmbientInGrayScale", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useAutoMicroSurfaceFromReflectivityMap", void 0);
+s([
+  a()
+], u.prototype, "usePhysicalLightFalloff", null);
+s([
+  a()
+], u.prototype, "useGLTFLightFalloff", null);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useRadianceOverAlpha", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useObjectSpaceNormalMap", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useParallax", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useParallaxOcclusion", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "parallaxScaleBias", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsLightsDirty")
+], u.prototype, "disableLighting", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "forceIrradianceInFragment", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsLightsDirty")
+], u.prototype, "maxSimultaneousLights", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "invertNormalMapX", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "invertNormalMapY", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "twoSidedLighting", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useAlphaFresnel", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useLinearAlphaFresnel", void 0);
+s([
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "environmentBRDFTexture", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "forceNormalForward", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "enableSpecularAntiAliasing", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useHorizonOcclusion", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], u.prototype, "useRadianceOcclusion", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], u.prototype, "unlit", void 0);
+s([
+  a(),
+  r("_markAllSubMeshesAsMiscDirty")
+], u.prototype, "applyDecalMapAfterDetailMap", void 0);
+Be("BABYLON.PBRMaterial", u);
+export {
+  u as PBRMaterial
+};