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

package/dist/node_modules/@babylonjs/core/Materials/PBR/pbrMaterial.esm.js

@@ -0,0 +1,496 @@
+import { __decorate as t } from "../../tslib.es6.esm.js";
+import { SerializationHelper as h, serialize as i, expandToProperty as r, serializeAsTexture as u, serializeAsColor3 as p } from "../../Misc/decorators.esm.js";
+import { GetEnvironmentBRDFTexture as c } from "../../Misc/brdfTextureTools.esm.js";
+import { Color3 as A } from "../../Maths/math.color.esm.js";
+import { PBRBaseMaterial as l } from "./pbrBaseMaterial.esm.js";
+import { RegisterClass as m } from "../../Misc/typeStore.esm.js";
+import { Material as f } from "../material.esm.js";
+class e extends l {
+  /**
+   * Stores the refracted light information in a texture.
+   */
+  get refractionTexture() {
+    return this.subSurface.refractionTexture;
+  }
+  set refractionTexture(s) {
+    this.subSurface.refractionTexture = s, s ? 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(s) {
+    this.subSurface.indexOfRefraction = s;
+  }
+  /**
+   * Controls if refraction needs to be inverted on Y. This could be useful for procedural texture.
+   */
+  get invertRefractionY() {
+    return this.subSurface.invertRefractionY;
+  }
+  set invertRefractionY(s) {
+    this.subSurface.invertRefractionY = s;
+  }
+  /**
+   * 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(s) {
+    this.subSurface.linkRefractionWithTransparency = s, s && (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 === l.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(s) {
+    s !== this.usePhysicalLightFalloff && (this._markAllSubMeshesAsTexturesDirty(), s ? this._lightFalloff = l.LIGHTFALLOFF_PHYSICAL : this._lightFalloff = l.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 === l.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(s) {
+    s !== this.useGLTFLightFalloff && (this._markAllSubMeshesAsTexturesDirty(), s ? this._lightFalloff = l.LIGHTFALLOFF_GLTF : this._lightFalloff = l.LIGHTFALLOFF_STANDARD);
+  }
+  /**
+   * Gets the image processing configuration used either in this material.
+   */
+  get imageProcessingConfiguration() {
+    return this._imageProcessingConfiguration;
+  }
+  /**
+   * Sets the Default image processing configuration used either in the this material.
+   *
+   * If sets to null, the scene one is in use.
+   */
+  set imageProcessingConfiguration(s) {
+    this._attachImageProcessingConfiguration(s), this._markAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * Gets whether the color curves effect is enabled.
+   */
+  get cameraColorCurvesEnabled() {
+    return this.imageProcessingConfiguration.colorCurvesEnabled;
+  }
+  /**
+   * Sets whether the color curves effect is enabled.
+   */
+  set cameraColorCurvesEnabled(s) {
+    this.imageProcessingConfiguration.colorCurvesEnabled = s;
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  get cameraColorGradingEnabled() {
+    return this.imageProcessingConfiguration.colorGradingEnabled;
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  set cameraColorGradingEnabled(s) {
+    this.imageProcessingConfiguration.colorGradingEnabled = s;
+  }
+  /**
+   * Gets whether tonemapping is enabled or not.
+   */
+  get cameraToneMappingEnabled() {
+    return this._imageProcessingConfiguration.toneMappingEnabled;
+  }
+  /**
+   * Sets whether tonemapping is enabled or not
+   */
+  set cameraToneMappingEnabled(s) {
+    this._imageProcessingConfiguration.toneMappingEnabled = s;
+  }
+  /**
+   * The camera exposure used on this material.
+   * This property is here and not in the camera to allow controlling exposure without full screen post process.
+   * This corresponds to a photographic exposure.
+   */
+  get cameraExposure() {
+    return this._imageProcessingConfiguration.exposure;
+  }
+  /**
+   * The camera exposure used on this material.
+   * This property is here and not in the camera to allow controlling exposure without full screen post process.
+   * This corresponds to a photographic exposure.
+   */
+  set cameraExposure(s) {
+    this._imageProcessingConfiguration.exposure = s;
+  }
+  /**
+   * Gets The camera contrast used on this material.
+   */
+  get cameraContrast() {
+    return this._imageProcessingConfiguration.contrast;
+  }
+  /**
+   * Sets The camera contrast used on this material.
+   */
+  set cameraContrast(s) {
+    this._imageProcessingConfiguration.contrast = s;
+  }
+  /**
+   * Gets the Color Grading 2D Lookup Texture.
+   */
+  get cameraColorGradingTexture() {
+    return this._imageProcessingConfiguration.colorGradingTexture;
+  }
+  /**
+   * Sets the Color Grading 2D Lookup Texture.
+   */
+  set cameraColorGradingTexture(s) {
+    this._imageProcessingConfiguration.colorGradingTexture = s;
+  }
+  /**
+   * The color grading curves provide additional color adjustment that is applied after any color grading transform (3D LUT).
+   * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
+   * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
+   * corresponding to low luminance, medium luminance, and high luminance areas respectively.
+   */
+  get cameraColorCurves() {
+    return this._imageProcessingConfiguration.colorCurves;
+  }
+  /**
+   * The color grading curves provide additional color adjustment that is applied after any color grading transform (3D LUT).
+   * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
+   * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
+   * corresponding to low luminance, medium luminance, and high luminance areas respectively.
+   */
+  set cameraColorCurves(s) {
+    this._imageProcessingConfiguration.colorCurves = s;
+  }
+  /**
+   * Instantiates a new PBRMaterial instance.
+   *
+   * @param name The material name
+   * @param scene The scene the material will be use in.
+   */
+  constructor(s, o) {
+    super(s, o), this.directIntensity = 1, this.emissiveIntensity = 1, this.environmentIntensity = 1, this.specularIntensity = 1, this.disableBumpMap = !1, this.ambientTextureStrength = 1, this.ambientTextureImpactOnAnalyticalLights = e.DEFAULT_AO_ON_ANALYTICAL_LIGHTS, this.metallicF0Factor = 1, this.metallicReflectanceColor = A.White(), this.useOnlyMetallicFromMetallicReflectanceTexture = !1, this.ambientColor = new A(0, 0, 0), this.albedoColor = new A(1, 1, 1), this.reflectivityColor = new A(1, 1, 1), this.reflectionColor = new A(1, 1, 1), this.emissiveColor = new A(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 = c(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
+   */
+  clone(s, o = !0, n = "") {
+    const a = h.Clone(() => new e(s, this.getScene()), this, { cloneTexturesOnlyOnce: o });
+    return a.id = s, a.name = s, this.stencil.copyTo(a.stencil), this._clonePlugins(a, n), a;
+  }
+  /**
+   * Serializes this PBR Material.
+   * @returns - An object with the serialized material.
+   */
+  serialize() {
+    const s = super.serialize();
+    return s.customType = "BABYLON.PBRMaterial", s;
+  }
+  // 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(s, o, n) {
+    const a = h.Parse(() => new e(s.name, o), s, o, n);
+    return s.stencil && a.stencil.parse(s.stencil, o, n), f._parsePlugins(s, a, o, n), s.clearCoat && a.clearCoat.parse(s.clearCoat, o, n), s.anisotropy && a.anisotropy.parse(s.anisotropy, o, n), s.brdf && a.brdf.parse(s.brdf, o, n), s.sheen && a.sheen.parse(s.sheen, o, n), s.subSurface && a.subSurface.parse(s.subSurface, o, n), s.iridescence && a.iridescence.parse(s.iridescence, o, n), a;
+  }
+}
+e.PBRMATERIAL_OPAQUE = l.PBRMATERIAL_OPAQUE;
+e.PBRMATERIAL_ALPHATEST = l.PBRMATERIAL_ALPHATEST;
+e.PBRMATERIAL_ALPHABLEND = l.PBRMATERIAL_ALPHABLEND;
+e.PBRMATERIAL_ALPHATESTANDBLEND = l.PBRMATERIAL_ALPHATESTANDBLEND;
+e.DEFAULT_AO_ON_ANALYTICAL_LIGHTS = l.DEFAULT_AO_ON_ANALYTICAL_LIGHTS;
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "directIntensity", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "emissiveIntensity", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "environmentIntensity", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "specularIntensity", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "disableBumpMap", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "albedoTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "ambientTexture", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "ambientTextureStrength", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "ambientTextureImpactOnAnalyticalLights", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], e.prototype, "opacityTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "reflectionTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "emissiveTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "reflectivityTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "metallicTexture", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "metallic", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "roughness", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "metallicF0Factor", void 0);
+t([
+  p(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "metallicReflectanceColor", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useOnlyMetallicFromMetallicReflectanceTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "metallicReflectanceTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "reflectanceTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "microSurfaceTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "bumpTexture", void 0);
+t([
+  u(),
+  r("_markAllSubMeshesAsTexturesDirty", null)
+], e.prototype, "lightmapTexture", void 0);
+t([
+  p("ambient"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "ambientColor", void 0);
+t([
+  p("albedo"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "albedoColor", void 0);
+t([
+  p("reflectivity"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "reflectivityColor", void 0);
+t([
+  p("reflection"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "reflectionColor", void 0);
+t([
+  p("emissive"),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "emissiveColor", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "microSurface", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useLightmapAsShadowmap", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], e.prototype, "useAlphaFromAlbedoTexture", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], e.prototype, "forceAlphaTest", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesAndMiscDirty")
+], e.prototype, "alphaCutOff", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useSpecularOverAlpha", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useMicroSurfaceFromReflectivityMapAlpha", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useRoughnessFromMetallicTextureAlpha", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useRoughnessFromMetallicTextureGreen", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useMetallnessFromMetallicTextureBlue", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useAmbientInGrayScale", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useAutoMicroSurfaceFromReflectivityMap", void 0);
+t([
+  i()
+], e.prototype, "usePhysicalLightFalloff", null);
+t([
+  i()
+], e.prototype, "useGLTFLightFalloff", null);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useRadianceOverAlpha", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useObjectSpaceNormalMap", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useParallax", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useParallaxOcclusion", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "parallaxScaleBias", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsLightsDirty")
+], e.prototype, "disableLighting", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "forceIrradianceInFragment", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsLightsDirty")
+], e.prototype, "maxSimultaneousLights", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "invertNormalMapX", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "invertNormalMapY", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "twoSidedLighting", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useAlphaFresnel", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useLinearAlphaFresnel", void 0);
+t([
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "environmentBRDFTexture", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "forceNormalForward", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "enableSpecularAntiAliasing", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useHorizonOcclusion", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsTexturesDirty")
+], e.prototype, "useRadianceOcclusion", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsMiscDirty")
+], e.prototype, "unlit", void 0);
+t([
+  i(),
+  r("_markAllSubMeshesAsMiscDirty")
+], e.prototype, "applyDecalMapAfterDetailMap", void 0);
+m("BABYLON.PBRMaterial", e);
+export {
+  e as PBRMaterial
+};

package/dist/node_modules/@babylonjs/core/Materials/PBR/pbrSheenConfiguration.esm.js

@@ -0,0 +1,106 @@
+import { __decorate as i } from "../../tslib.es6.esm.js";
+import { serialize as l, expandToProperty as u, serializeAsColor3 as A, serializeAsTexture as g } from "../../Misc/decorators.esm.js";
+import { Color3 as b } from "../../Maths/math.color.esm.js";
+import { MaterialFlags as h } from "../materialFlags.esm.js";
+import { MaterialHelper as E } from "../materialHelper.esm.js";
+import { MaterialPluginBase as M } from "../materialPluginBase.esm.js";
+import { MaterialDefines as v } from "../materialDefines.esm.js";
+class m 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, this.SHEEN_TEXTURE_ROUGHNESS_IDENTICAL = !1;
+  }
+}
+class r extends M {
+  /** @internal */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._enable(this._isEnabled), this._internalMarkAllSubMeshesAsTexturesDirty();
+  }
+  constructor(e, t = !0) {
+    super(e, "Sheen", 120, new m(), t), this._isEnabled = !1, this.isEnabled = !1, this._linkSheenWithAlbedo = !1, this.linkSheenWithAlbedo = !1, this.intensity = 1, this.color = b.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, t) {
+    return this._isEnabled ? !(e._areTexturesDirty && t.texturesEnabled && (this._texture && h.SheenTextureEnabled && !this._texture.isReadyOrNotBlocking() || this._textureRoughness && h.SheenTextureEnabled && !this._textureRoughness.isReadyOrNotBlocking())) : !0;
+  }
+  prepareDefinesBeforeAttributes(e, t) {
+    var s;
+    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.SHEEN_TEXTURE_ROUGHNESS_IDENTICAL = this._texture !== null && this._texture._texture === ((s = this._textureRoughness) === null || s === void 0 ? void 0 : s._texture) && this._texture.checkTransformsAreIdentical(this._textureRoughness), e._areTexturesDirty && t.texturesEnabled && (this._texture && h.SheenTextureEnabled ? (E.PrepareDefinesForMergedUV(this._texture, e, "SHEEN_TEXTURE"), e.SHEEN_GAMMATEXTURE = this._texture.gammaSpace) : e.SHEEN_TEXTURE = !1, this._textureRoughness && h.SheenTextureEnabled ? E.PrepareDefinesForMergedUV(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_TEXTURE_ROUGHNESS_IDENTICAL = !1, e.SHEEN_GAMMATEXTURE = !1, e.SHEEN_TEXTUREDIRECTUV = 0, e.SHEEN_TEXTURE_ROUGHNESSDIRECTUV = 0);
+  }
+  bindForSubMesh(e, t, s, p) {
+    var n, o, a, _, S, x, T, R;
+    if (!this._isEnabled)
+      return;
+    const N = p.materialDefines, U = this._material.isFrozen, d = N.SHEEN_TEXTURE_ROUGHNESS_IDENTICAL;
+    (!e.useUbo || !U || !e.isSync) && (d && h.SheenTextureEnabled ? (e.updateFloat4("vSheenInfos", this._texture.coordinatesIndex, this._texture.level, -1, -1), E.BindTextureMatrix(this._texture, e, "sheen")) : (this._texture || this._textureRoughness) && h.SheenTextureEnabled && (e.updateFloat4("vSheenInfos", (o = (n = this._texture) === null || n === void 0 ? void 0 : n.coordinatesIndex) !== null && o !== void 0 ? o : 0, (_ = (a = this._texture) === null || a === void 0 ? void 0 : a.level) !== null && _ !== void 0 ? _ : 0, (x = (S = this._textureRoughness) === null || S === void 0 ? void 0 : S.coordinatesIndex) !== null && x !== void 0 ? x : 0, (R = (T = this._textureRoughness) === null || T === void 0 ? void 0 : T.level) !== null && R !== void 0 ? R : 0), this._texture && E.BindTextureMatrix(this._texture, e, "sheen"), this._textureRoughness && !d && !N.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE && E.BindTextureMatrix(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)), t.texturesEnabled && (this._texture && h.SheenTextureEnabled && e.setTexture("sheenSampler", this._texture), this._textureRoughness && !d && !N.SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE && h.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) {
+    var t, s;
+    e && ((t = this._texture) === null || t === void 0 || t.dispose(), (s = this._textureRoughness) === null || s === void 0 || s.dispose());
+  }
+  getClassName() {
+    return "PBRSheenConfiguration";
+  }
+  addFallbacks(e, t, s) {
+    return e.SHEEN && t.addFallback(s++, "SHEEN"), s;
+  }
+  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" }
+      ]
+    };
+  }
+}
+i([
+  l(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "isEnabled", void 0);
+i([
+  l(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "linkSheenWithAlbedo", void 0);
+i([
+  l()
+], r.prototype, "intensity", void 0);
+i([
+  A()
+], r.prototype, "color", void 0);
+i([
+  g(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "texture", void 0);
+i([
+  l(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "useRoughnessFromMainTexture", void 0);
+i([
+  l(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "roughness", void 0);
+i([
+  g(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "textureRoughness", void 0);
+i([
+  l(),
+  u("_markAllSubMeshesAsTexturesDirty")
+], r.prototype, "albedoScaling", void 0);
+export {
+  m as MaterialSheenDefines,
+  r as PBRSheenConfiguration
+};