@babylonjs/core 8.46.2 → 8.47.1

package/Materials/PBR/openpbrMaterial.d.ts

@@ -1,9 +1,10 @@
 import type { Nullable } from "../../types.js";
-import { Scene } from "../../scene.js";
+import type { Scene } from "../../scene.js";
 import { Color3 } from "../../Maths/math.color.js";
 import { ImageProcessingConfiguration } from "../imageProcessingConfiguration.js";
 import type { BaseTexture } from "../../Materials/Textures/baseTexture.js";
 import { Material } from "../material.js";
+import type { Engine } from "../../Engines/engine.js";
 import type { AbstractMesh } from "../../Meshes/abstractMesh.js";
 import { MaterialDefines } from "../materialDefines.js";
 import { PrePassConfiguration } from "../prePassConfiguration.js";
@@ -14,6 +15,7 @@ import type { Matrix } from "../../Maths/math.vector.js";
 import type { Mesh } from "../../Meshes/mesh.js";
 import { PushMaterial } from "../pushMaterial.js";
 import type { IAnimatable } from "../../Animations/animatable.interface.js";
+import type { UniformBuffer } from "../../Materials/uniformBuffer.js";
 declare const OpenPBRMaterialDefinesBase_base: {
     new (...args: any[]): {
         MAINUV1: boolean;
@@ -72,10 +74,8 @@ export declare class OpenPBRMaterialDefines extends OpenPBRMaterialDefines_base
     REFLECTIVITYDIRECTUV: number;
     SPECULARTERM: boolean;
     LODBASEDMICROSFURACE: boolean;
-    METALLICWORKFLOW: boolean;
-    ROUGHNESSSTOREINMETALMAPALPHA: boolean;
-    ROUGHNESSSTOREINMETALMAPGREEN: boolean;
-    METALLNESSSTOREINMETALMAPBLUE: boolean;
+    SPECULAR_ROUGHNESS_FROM_METALNESS_TEXTURE_GREEN: boolean;
+    BASE_METALNESS_FROM_METALNESS_TEXTURE_BLUE: boolean;
     AOSTOREINMETALMAPRED: boolean;
     SPECULAR_WEIGHT_IN_ALPHA: boolean;
     SPECULAR_WEIGHT_FROM_SPECULAR_COLOR_TEXTURE: boolean;
@@ -85,6 +85,7 @@ export declare class OpenPBRMaterialDefines extends OpenPBRMaterialDefines_base
     USE_GLTF_STYLE_ANISOTROPY: boolean;
     THIN_FILM_THICKNESS_FROM_THIN_FILM_TEXTURE: boolean;
     FUZZ_ROUGHNESS_FROM_TEXTURE_ALPHA: boolean;
+    GEOMETRY_THICKNESS_FROM_GREEN_CHANNEL: boolean;
     ENVIRONMENTBRDF: boolean;
     ENVIRONMENTBRDF_RGBD: boolean;
     FUZZENVIRONMENTBRDF: boolean;
@@ -128,6 +129,28 @@ export declare class OpenPBRMaterialDefines extends OpenPBRMaterialDefines_base
      * Iridescence is the name of thin film interference in the PBR material.
      */
     IRIDESCENCE: boolean;
+    /**
+     * Tells the shader to enable dispersion in refraction
+     */
+    DISPERSION: boolean;
+    /**
+     * Enables subsurface scattering
+     */
+    SCATTERING: boolean;
+    /**
+     * Refraction of the 2D background texture. Might include the rest of the scene or just the background.
+     */
+    REFRACTED_BACKGROUND: boolean;
+    /**
+     * Refraction of direct lights.
+     */
+    REFRACTED_LIGHTS: boolean;
+    /**
+     * Refraction of the environment texture (IBL).
+     */
+    REFRACTED_ENVIRONMENT: boolean;
+    REFRACTED_ENVIRONMENT_OPPOSITEZ: boolean;
+    REFRACTED_ENVIRONMENT_LOCAL_CUBE: boolean;
     REFLECTION: boolean;
     REFLECTIONMAP_3D: boolean;
     REFLECTIONMAP_SPHERICAL: boolean;
@@ -379,6 +402,78 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      */
     specularIor: number;
     private _specularIor;
+    /**
+     * Transmission weight of the surface.
+     * See OpenPBR's specs for transmission_weight
+     */
+    transmissionWeight: number;
+    private _transmissionWeight;
+    /**
+     * Transmission weight texture.
+     * See OpenPBR's specs for transmission_weight
+     */
+    transmissionWeightTexture: Nullable<BaseTexture>;
+    private _transmissionWeightTexture;
+    /**
+     * Transmission color of the surface.
+     * See OpenPBR's specs for transmission_color
+     */
+    transmissionColor: Color3;
+    private _transmissionColor;
+    /**
+     * Transmission color texture.
+     * See OpenPBR's specs for transmission_color
+     */
+    transmissionColorTexture: Nullable<BaseTexture>;
+    private _transmissionColorTexture;
+    /**
+     * Transmission depth of the volume
+     * See OpenPBR's specs for transmission_depth
+     */
+    transmissionDepth: number;
+    private _transmissionDepth;
+    /**
+     * Transmission depth texture.
+     * See OpenPBR's specs for transmission_depth
+     */
+    transmissionDepthTexture: Nullable<BaseTexture>;
+    private _transmissionDepthTexture;
+    /**
+     * Transmission scatter of the surface.
+     * See OpenPBR's specs for transmission_scatter
+     */
+    transmissionScatter: Color3;
+    private _transmissionScatter;
+    /**
+     * Transmission scatter texture.
+     * See OpenPBR's specs for transmission_scatter
+     */
+    transmissionScatterTexture: Nullable<BaseTexture>;
+    private _transmissionScatterTexture;
+    /**
+     * Transmission scatter anisotropy
+     * See OpenPBR's specs for transmission_scatter_anisotropy
+     */
+    transmissionScatterAnisotropy: number;
+    private _transmissionScatterAnisotropy;
+    /**
+     * Transmission Dispersion Scale factor.
+     * See OpenPBR's specs for transmission_dispersion_scale
+     */
+    transmissionDispersionScale: number;
+    private _transmissionDispersionScale;
+    /**
+     * Transmission Dispersion Scale texture.
+     * See OpenPBR's specs for transmission_dispersion_scale
+     */
+    transmissionDispersionScaleTexture: Nullable<BaseTexture>;
+    private _transmissionDispersionScaleTexture;
+    /**
+     * Transmission Dispersion Abbe number.
+     * See OpenPBR's specs for transmission_dispersion_abbe_number
+     */
+    transmissionDispersionAbbeNumber: number;
+    private _transmissionDispersionAbbeNumber;
     /**
      * Defines the amount of clear coat on the surface.
      * See OpenPBR's specs for coat_weight
@@ -552,6 +647,18 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      */
     geometryOpacityTexture: Nullable<BaseTexture>;
     private _geometryOpacityTexture;
+    /**
+     * Defines the thickness of the material's geometry.
+     * Not part of OpenPBR's specs but useful for rasterization approximations of volume.
+     */
+    geometryThickness: number;
+    private _geometryThickness;
+    /**
+     * Defines the thickness of the material's geometry.
+     * Not part of OpenPBR's specs but useful for rasterization approximations of volume.
+     */
+    geometryThicknessTexture: Nullable<BaseTexture>;
+    private _geometryThicknessTexture;
     /**
      * Defines the luminance of the material's emission.
      * See OpenPBR's specs for emission_luminance
@@ -845,8 +952,16 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
     _useMetallicFromMetallicTextureBlue: boolean;
     /**
      * Specifies if the thin film thickness is stored in the green channel of the thin film thickness texture.
+     * This is for compatibility with glTF.
+     * @internal
      */
     _useThinFilmThicknessFromTextureGreen: boolean;
+    /**
+     * Specifies if the geometry thickness is stored in the green channel of the geometry thickness texture.
+     * This is for compatibility with glTF.
+     * @internal
+     */
+    _useGeometryThicknessFromGreenChannel: boolean;
     /**
      * Defines the  falloff type used in this material.
      * It by default is Physical.
@@ -929,6 +1044,13 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * @internal
      */
     _environmentFuzzBRDFTexture: Nullable<BaseTexture>;
+    private _backgroundRefractionTexture;
+    /**
+     * Set the texture used for refraction of the background of transparent materials
+     * @internal
+     */
+    get backgroundRefractionTexture(): Nullable<BaseTexture>;
+    set backgroundRefractionTexture(texture: Nullable<BaseTexture>);
     /**
      * Force the shader to compute irradiance in the fragment shader in order to take normal mapping into account.
      * @internal
@@ -1082,6 +1204,14 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Initializes the uniform buffer layout for the shader.
      */
     buildUniformLayout(): void;
+    /**
+     * Binds the material data (this function is called even if mustRebind() returns false)
+     * @param uniformBuffer defines the Uniform buffer to fill in.
+     * @param scene defines the scene the material belongs to.
+     * @param engine defines the engine the material belongs to.
+     * @param subMesh the submesh to bind data for
+     */
+    bindPropertiesForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: Engine, subMesh: SubMesh): void;
     /**
      * Binds the submesh data.
      * @param world - The world matrix.

package/Materials/PBR/openpbrMaterial.js

@@ -2,7 +2,6 @@ import { __decorate } from "../../tslib.es6.js";
 /* eslint-disable @typescript-eslint/naming-convention */
 import { serialize, expandToProperty, addAccessorsForMaterialProperty } from "../../Misc/decorators.js";
 import { GetEnvironmentBRDFTexture, GetEnvironmentFuzzBRDFTexture } from "../../Misc/brdfTextureTools.js";
-import { Scene } from "../../scene.js";
 import { Color3 } from "../../Maths/math.color.js";
 import { ImageProcessingConfiguration } from "../imageProcessingConfiguration.js";
 import { Texture } from "../Textures/texture.js";
@@ -169,10 +168,8 @@ export class OpenPBRMaterialDefines extends ImageProcessingDefinesMixin(OpenPBRM
         this.REFLECTIVITYDIRECTUV = 0;
         this.SPECULARTERM = false;
         this.LODBASEDMICROSFURACE = true;
-        this.METALLICWORKFLOW = true;
-        this.ROUGHNESSSTOREINMETALMAPALPHA = false;
-        this.ROUGHNESSSTOREINMETALMAPGREEN = false;
-        this.METALLNESSSTOREINMETALMAPBLUE = false;
+        this.SPECULAR_ROUGHNESS_FROM_METALNESS_TEXTURE_GREEN = false;
+        this.BASE_METALNESS_FROM_METALNESS_TEXTURE_BLUE = false;
         this.AOSTOREINMETALMAPRED = false;
         this.SPECULAR_WEIGHT_IN_ALPHA = false;
         this.SPECULAR_WEIGHT_FROM_SPECULAR_COLOR_TEXTURE = false;
@@ -182,6 +179,7 @@ export class OpenPBRMaterialDefines extends ImageProcessingDefinesMixin(OpenPBRM
         this.USE_GLTF_STYLE_ANISOTROPY = false;
         this.THIN_FILM_THICKNESS_FROM_THIN_FILM_TEXTURE = false;
         this.FUZZ_ROUGHNESS_FROM_TEXTURE_ALPHA = false;
+        this.GEOMETRY_THICKNESS_FROM_GREEN_CHANNEL = false;
         this.ENVIRONMENTBRDF = false;
         this.ENVIRONMENTBRDF_RGBD = false;
         this.FUZZENVIRONMENTBRDF = false;
@@ -225,6 +223,28 @@ export class OpenPBRMaterialDefines extends ImageProcessingDefinesMixin(OpenPBRM
          * Iridescence is the name of thin film interference in the PBR material.
          */
         this.IRIDESCENCE = false;
+        /**
+         * Tells the shader to enable dispersion in refraction
+         */
+        this.DISPERSION = false;
+        /**
+         * Enables subsurface scattering
+         */
+        this.SCATTERING = false;
+        /**
+         * Refraction of the 2D background texture. Might include the rest of the scene or just the background.
+         */
+        this.REFRACTED_BACKGROUND = false;
+        /**
+         * Refraction of direct lights.
+         */
+        this.REFRACTED_LIGHTS = false;
+        /**
+         * Refraction of the environment texture (IBL).
+         */
+        this.REFRACTED_ENVIRONMENT = false;
+        this.REFRACTED_ENVIRONMENT_OPPOSITEZ = false;
+        this.REFRACTED_ENVIRONMENT_LOCAL_CUBE = false;
         this.REFLECTION = false;
         this.REFLECTIONMAP_3D = false;
         this.REFLECTIONMAP_SPHERICAL = false;
@@ -426,6 +446,17 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
             }
         }
     }
+    /**
+     * Set the texture used for refraction of the background of transparent materials
+     * @internal
+     */
+    get backgroundRefractionTexture() {
+        return this._backgroundRefractionTexture;
+    }
+    set backgroundRefractionTexture(texture) {
+        this._backgroundRefractionTexture = texture;
+        this._markAllSubMeshesAsTexturesDirty();
+    }
     /**
      * Enables realtime filtering on the texture.
      */
@@ -488,6 +519,18 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         this._specularRoughnessAnisotropy = new Property("specular_roughness_anisotropy", 0, "vSpecularAnisotropy", 3, 2);
         this._specularRoughnessAnisotropyTexture = new Sampler("specular_roughness_anisotropy", "specularRoughnessAnisotropy", "SPECULAR_ROUGHNESS_ANISOTROPY");
         this._specularIor = new Property("specular_ior", 1.5, "vReflectanceInfo", 4, 2);
+        this._transmissionWeight = new Property("transmission_weight", 0.0, "vTransmissionWeight", 1);
+        this._transmissionWeightTexture = new Sampler("transmission_weight", "transmissionWeight", "TRANSMISSION_WEIGHT");
+        this._transmissionColor = new Property("transmission_color", Color3.White(), "vTransmissionColor", 3, 0);
+        this._transmissionColorTexture = new Sampler("transmission_color", "transmissionColor", "TRANSMISSION_COLOR");
+        this._transmissionDepth = new Property("transmission_depth", 0.0, "vTransmissionDepth", 1, 0);
+        this._transmissionDepthTexture = new Sampler("transmission_depth", "transmissionDepth", "TRANSMISSION_DEPTH");
+        this._transmissionScatter = new Property("transmission_scatter", Color3.Black(), "vTransmissionScatter", 3, 0);
+        this._transmissionScatterTexture = new Sampler("transmission_scatter", "transmissionScatter", "TRANSMISSION_SCATTER");
+        this._transmissionScatterAnisotropy = new Property("transmission_scatter_anisotropy", 0.0, "vTransmissionScatterAnisotropy", 1, 0);
+        this._transmissionDispersionScale = new Property("transmission_dispersion_scale", 0.0, "vTransmissionDispersionScale", 1, 0);
+        this._transmissionDispersionScaleTexture = new Sampler("transmission_dispersion_scale", "transmissionDispersionScale", "TRANSMISSION_DISPERSION_SCALE");
+        this._transmissionDispersionAbbeNumber = new Property("transmission_dispersion_abbe_number", 20.0, "vTransmissionDispersionAbbeNumber", 1, 0);
         this._coatWeight = new Property("coat_weight", 0.0, "vCoatWeight", 1, 0);
         this._coatWeightTexture = new Sampler("coat_weight", "coatWeight", "COAT_WEIGHT");
         this._coatColor = new Property("coat_color", Color3.White(), "vCoatColor", 3, 0);
@@ -518,6 +561,8 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         this._geometryCoatTangentTexture = new Sampler("geometry_coat_tangent", "geometryCoatTangent", "GEOMETRY_COAT_TANGENT");
         this._geometryOpacity = new Property("geometry_opacity", 1.0, "vBaseColor", 4, 3);
         this._geometryOpacityTexture = new Sampler("geometry_opacity", "geometryOpacity", "GEOMETRY_OPACITY");
+        this._geometryThickness = new Property("geometry_thickness", 0.0, "vGeometryThickness", 1, 0);
+        this._geometryThicknessTexture = new Sampler("geometry_thickness", "geometryThickness", "GEOMETRY_THICKNESS");
         this._emissionLuminance = new Property("emission_luminance", 1.0, "vLightingIntensity", 4, 1);
         this._emissionColor = new Property("emission_color", Color3.Black(), "vEmissionColor", 3);
         this._emissionColorTexture = new Sampler("emission_color", "emissionColor", "EMISSION_COLOR");
@@ -737,8 +782,16 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         this._useMetallicFromMetallicTextureBlue = false;
         /**
          * Specifies if the thin film thickness is stored in the green channel of the thin film thickness texture.
+         * This is for compatibility with glTF.
+         * @internal
          */
         this._useThinFilmThicknessFromTextureGreen = false;
+        /**
+         * Specifies if the geometry thickness is stored in the green channel of the geometry thickness texture.
+         * This is for compatibility with glTF.
+         * @internal
+         */
+        this._useGeometryThicknessFromGreenChannel = false;
         /**
          * Defines the  falloff type used in this material.
          * It by default is Physical.
@@ -821,6 +874,7 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
          * @internal
          */
         this._environmentFuzzBRDFTexture = null;
+        this._backgroundRefractionTexture = null;
         /**
          * Force the shader to compute irradiance in the fragment shader in order to take normal mapping into account.
          * @internal
@@ -899,6 +953,9 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
             if (MaterialFlags.ReflectionTextureEnabled && this._radianceTexture && this._radianceTexture.isRenderTarget) {
                 this._renderTargets.push(this._radianceTexture);
             }
+            if (MaterialFlags.RefractionTextureEnabled && this._backgroundRefractionTexture && this._backgroundRefractionTexture.isRenderTarget) {
+                this._renderTargets.push(this._backgroundRefractionTexture);
+            }
             this._eventInfo.renderTargets = this._renderTargets;
             this._callbackPluginEventFillRenderTargetTextures(this._eventInfo);
             return this._renderTargets;
@@ -963,6 +1020,18 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         this._specularRoughnessTexture;
         this._specularRoughnessAnisotropy;
         this._specularRoughnessAnisotropyTexture;
+        this._transmissionWeight;
+        this._transmissionWeightTexture;
+        this._transmissionColor;
+        this._transmissionColorTexture;
+        this._transmissionDepth;
+        this._transmissionDepthTexture;
+        this._transmissionScatter;
+        this._transmissionScatterTexture;
+        this._transmissionScatterAnisotropy;
+        this._transmissionDispersionScale;
+        this._transmissionDispersionScaleTexture;
+        this._transmissionDispersionAbbeNumber;
         this._coatWeight;
         this._coatWeightTexture;
         this._coatColor;
@@ -988,6 +1057,8 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         this._geometryCoatTangentTexture;
         this._geometryOpacity;
         this._geometryOpacityTexture;
+        this._geometryThickness;
+        this._geometryThicknessTexture;
         this._thinFilmWeight;
         this._thinFilmWeightTexture;
         this._thinFilmThickness;
@@ -1006,6 +1077,9 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         if (MaterialFlags.ReflectionTextureEnabled && this._radianceTexture && this._radianceTexture.isRenderTarget) {
             return true;
         }
+        if (MaterialFlags.RefractionTextureEnabled && this._backgroundRefractionTexture && this._backgroundRefractionTexture.isRenderTarget) {
+            return true;
+        }
         return this._cacheHasRenderTargetTextures;
     }
     /**
@@ -1200,6 +1274,11 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                         return false;
                     }
                 }
+                if (this._backgroundRefractionTexture && MaterialFlags.RefractionTextureEnabled) {
+                    if (!this._backgroundRefractionTexture.isReadyOrNotBlocking()) {
+                        return false;
+                    }
+                }
                 if (OpenPBRMaterial._noiseTextures[scene.uniqueId]) {
                     if (!OpenPBRMaterial._noiseTextures[scene.uniqueId].isReady()) {
                         return false;
@@ -1277,6 +1356,8 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         ubo.addUniform("pointSize", 1);
         ubo.addUniform("vDebugMode", 2);
         ubo.addUniform("cameraInfo", 4);
+        ubo.addUniform("backgroundRefractionMatrix", 16);
+        ubo.addUniform("vBackgroundRefractionInfos", 3);
         PrepareUniformLayoutForIBL(ubo, true, true, true, true, true);
         Object.values(this._uniformsList).forEach((uniform) => {
             ubo.addUniform(uniform.name, uniform.numComponents);
@@ -1287,6 +1368,24 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         });
         super.buildUniformLayout();
     }
+    /**
+     * Binds the material data (this function is called even if mustRebind() returns false)
+     * @param uniformBuffer defines the Uniform buffer to fill in.
+     * @param scene defines the scene the material belongs to.
+     * @param engine defines the engine the material belongs to.
+     * @param subMesh the submesh to bind data for
+     */
+    bindPropertiesForSubMesh(uniformBuffer, scene, engine, subMesh) {
+        // If min/max thickness is 0, avoid decomposing to determine the scaled thickness (it's always zero).
+        if (this.geometryThickness === 0.0) {
+            uniformBuffer.updateFloat("vGeometryThickness", 0);
+        }
+        else {
+            subMesh.getRenderingMesh().getWorldMatrix().decompose(TmpVectors.Vector3[0]);
+            const thicknessScale = Math.max(Math.abs(TmpVectors.Vector3[0].x), Math.abs(TmpVectors.Vector3[0].y), Math.abs(TmpVectors.Vector3[0].z));
+            uniformBuffer.updateFloat("vGeometryThickness", this.geometryThickness * thicknessScale);
+        }
+    }
     /**
      * Binds the submesh data.
      * @param world - The world matrix.
@@ -1321,6 +1420,7 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         }
         this._eventInfo.subMesh = subMesh;
         this._callbackPluginEventHardBindForSubMesh(this._eventInfo);
+        this.bindPropertiesForSubMesh(this._uniformBuffer, scene, scene.getEngine(), subMesh);
         // Normal Matrix
         if (defines.OBJECTSPACE_NORMALMAP) {
             world.toNormalMatrix(this._normalMatrix);
@@ -1401,7 +1501,13 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                 if (defines.FUZZENVIRONMENTBRDF) {
                     ubo.setTexture("environmentFuzzBrdfSampler", this._environmentFuzzBRDFTexture);
                 }
-                if (defines.ANISOTROPIC || defines.FUZZ) {
+                if (defines.REFRACTED_BACKGROUND) {
+                    ubo.setTexture("backgroundRefractionSampler", this._backgroundRefractionTexture);
+                    ubo.updateMatrix("backgroundRefractionMatrix", this._backgroundRefractionTexture.getReflectionTextureMatrix());
+                    TmpVectors.Vector3[1].set(Math.log2(this._backgroundRefractionTexture.getSize().width), 0, 0);
+                    ubo.updateVector3("vBackgroundRefractionInfos", TmpVectors.Vector3[1]);
+                }
+                if (defines.ANISOTROPIC || defines.FUZZ || defines.REFRACTED_BACKGROUND) {
                     ubo.setTexture("blueNoiseSampler", OpenPBRMaterial._noiseTextures[this.getScene().uniqueId]);
                 }
             }
@@ -1424,9 +1530,9 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                 BindLights(scene, mesh, this._activeEffect, defines, this._maxSimultaneousLights);
             }
             // View
-            if ((scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) || radianceTexture || mesh.receiveShadows || defines.PREPASS) {
-                this.bindView(effect);
-            }
+            // if ((scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) || radianceTexture || mesh.receiveShadows || defines.PREPASS) {
+            this.bindView(effect);
+            // }
             // Fog
             BindFogParameters(scene, mesh, this._activeEffect, true);
             // Morph targets
@@ -1525,6 +1631,8 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
             if (this._environmentFuzzBRDFTexture && this.getScene().environmentFuzzBRDFTexture !== this._environmentFuzzBRDFTexture) {
                 this._environmentFuzzBRDFTexture.dispose();
             }
+            // The refraction texture will be cleaned up by the transmission helper.
+            this._backgroundRefractionTexture = null;
             // Loop through samplers and dispose the textures
             for (const key in this._samplersList) {
                 const sampler = this._samplersList[key];
@@ -1652,23 +1760,22 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
             "morphTargetTextureInfo",
             "morphTargetTextureIndices",
             "cameraInfo",
+            "backgroundRefractionMatrix",
+            "vBackgroundRefractionInfos",
         ];
         for (const uniformName in this._uniformsList) {
             uniforms.push(uniformName);
         }
-        const samplers = [
-            "environmentBrdfSampler",
-            "blueNoiseSampler",
-            "boneSampler",
-            "morphTargets",
-            "oitDepthSampler",
-            "oitFrontColorSampler",
-            "areaLightsLTC1Sampler",
-            "areaLightsLTC2Sampler",
-        ];
+        const samplers = ["environmentBrdfSampler", "boneSampler", "morphTargets", "oitDepthSampler", "oitFrontColorSampler", "areaLightsLTC1Sampler", "areaLightsLTC2Sampler"];
         if (defines.FUZZENVIRONMENTBRDF) {
             samplers.push("environmentFuzzBrdfSampler");
         }
+        if (defines.REFRACTED_BACKGROUND) {
+            samplers.push("backgroundRefractionSampler");
+        }
+        if (defines.ANISOTROPIC || defines.FUZZ || defines.REFRACTED_BACKGROUND) {
+            samplers.push("blueNoiseSampler");
+        }
         for (const key in this._samplersList) {
             const sampler = this._samplersList[key];
             samplers.push(sampler.samplerName);
@@ -1755,7 +1862,6 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         PrepareDefinesForOIT(scene, defines, oit);
         MaterialHelperGeometryRendering.PrepareDefines(engine.currentRenderPassId, mesh, defines);
         // Textures
-        defines.METALLICWORKFLOW = true;
         if (defines._areTexturesDirty) {
             defines._needUVs = false;
             for (let i = 1; i <= 6; ++i) {
@@ -1788,10 +1894,11 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                 defines.SPECULAR_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE = this._useSpecularRoughnessAnisotropyFromTangentTexture;
                 defines.COAT_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE = this._useCoatRoughnessAnisotropyFromTangentTexture;
                 defines.COAT_ROUGHNESS_FROM_GREEN_CHANNEL = this._useCoatRoughnessFromGreenChannel;
-                defines.ROUGHNESSSTOREINMETALMAPGREEN = this._useRoughnessFromMetallicTextureGreen;
+                defines.SPECULAR_ROUGHNESS_FROM_METALNESS_TEXTURE_GREEN = this._useRoughnessFromMetallicTextureGreen;
                 defines.FUZZ_ROUGHNESS_FROM_TEXTURE_ALPHA = this._useFuzzRoughnessFromTextureAlpha;
-                defines.METALLNESSSTOREINMETALMAPBLUE = this._useMetallicFromMetallicTextureBlue;
+                defines.BASE_METALNESS_FROM_METALNESS_TEXTURE_BLUE = this._useMetallicFromMetallicTextureBlue;
                 defines.THIN_FILM_THICKNESS_FROM_THIN_FILM_TEXTURE = this._useThinFilmThicknessFromTextureGreen;
+                defines.GEOMETRY_THICKNESS_FROM_GREEN_CHANNEL = this._useGeometryThicknessFromGreenChannel;
                 if (this.geometryNormalTexture) {
                     if (this._useParallax && this.baseColorTexture && MaterialFlags.DiffuseTextureEnabled) {
                         defines.PARALLAX = true;
@@ -1823,6 +1930,24 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                 else {
                     defines.FUZZENVIRONMENTBRDF = false;
                 }
+                if (this.transmissionWeight > 0) {
+                    defines.REFRACTED_BACKGROUND = !!this._backgroundRefractionTexture && MaterialFlags.RefractionTextureEnabled;
+                    defines.REFRACTED_LIGHTS = true;
+                    const radianceTexture = this._getRadianceTexture();
+                    if (radianceTexture) {
+                        defines.REFRACTED_ENVIRONMENT = MaterialFlags.RefractionTextureEnabled;
+                        defines.REFRACTED_ENVIRONMENT_OPPOSITEZ = this.getScene().useRightHandedSystem ? !radianceTexture.invertZ : radianceTexture.invertZ;
+                        defines.REFRACTED_ENVIRONMENT_LOCAL_CUBE = radianceTexture.isCube && radianceTexture.boundingBoxSize;
+                    }
+                    else {
+                        defines.REFRACTED_ENVIRONMENT = false;
+                    }
+                }
+                else {
+                    defines.REFRACTED_BACKGROUND = false;
+                    defines.REFRACTED_LIGHTS = false;
+                    defines.REFRACTED_ENVIRONMENT = false;
+                }
                 if (this._shouldUseAlphaFromBaseColorTexture()) {
                     defines.ALPHA_FROM_BASE_COLOR_TEXTURE = true;
                 }
@@ -1888,6 +2013,8 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
         }
         defines.THIN_FILM = this.thinFilmWeight > 0.0;
         defines.IRIDESCENCE = this.thinFilmWeight > 0.0;
+        defines.DISPERSION = this.transmissionDispersionScale > 0.0;
+        defines.SCATTERING = !this.transmissionScatter.equals(Color3.BlackReadOnly);
         defines.FUZZ = this.fuzzWeight > 0 && MaterialFlags.ReflectionTextureEnabled;
         if (defines.FUZZ) {
             if (!mesh.isVerticesDataPresent(VertexBuffer.TangentKind)) {
@@ -1994,6 +2121,54 @@ __decorate([
     addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "specularIor")
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
 ], OpenPBRMaterial.prototype, "_specularIor", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionWeight")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionWeight", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionWeightTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionWeightTexture", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionColor")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionColor", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionColorTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionColorTexture", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionDepth")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionDepth", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionDepthTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionDepthTexture", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionScatter")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionScatter", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionScatterTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionScatterTexture", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionScatterAnisotropy")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionScatterAnisotropy", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionDispersionScale")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionDispersionScale", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionDispersionScaleTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionDispersionScaleTexture", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "transmissionDispersionAbbeNumber")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_transmissionDispersionAbbeNumber", void 0);
 __decorate([
     addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "coatWeight")
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -2094,6 +2269,14 @@ __decorate([
     addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "geometryOpacityTexture")
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
 ], OpenPBRMaterial.prototype, "_geometryOpacityTexture", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "geometryThickness")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_geometryThickness", void 0);
+__decorate([
+    addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "geometryThicknessTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+], OpenPBRMaterial.prototype, "_geometryThicknessTexture", void 0);
 __decorate([
     addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "emissionLuminance")
     // eslint-disable-next-line @typescript-eslint/no-unused-vars