Add coat_darkening to OpenPBR

Author: Mike Bond

packages/dev/core/src/Materials/PBR/openPbrMaterial.ts

@@ -613,6 +613,28 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     private _coatIor: Property<number> = new Property<number>("coat_ior", 1.5, "vCoatIor", 1, 0);
 
+    /**
+     * Defines the amount that interreflections within the coat allow the underlying surface
+     * to be darkened. A value of 1.0 means that the physically correct amount of darkening
+     * is applied, while a value of 0.0 means that no darkening is applied.
+     * See OpenPBR's specs for coat_darkening
+     */
+    public coatDarkening: number;
+    @addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "coatDarkening")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    private _coatDarkening: Property<number> = new Property<number>("coat_darkening", 0.0, "vCoatDarkening", 1, 0);
+
+    /**
+     * Defines the amount that interreflections within the coat allow the underlying surface
+     * to be darkened. A value of 1.0 means that the physically correct amount of darkening
+     * is applied, while a value of 0.0 means that no darkening is applied.
+     * See OpenPBR's specs for coat_darkening
+     */
+    public coatDarkeningTexture: Nullable<BaseTexture>;
+    @addAccessorsForMaterialProperty("_markAllSubMeshesAsTexturesDirty", "coatDarkeningTexture")
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    private _coatDarkeningTexture: Sampler = new Sampler("coat_darkening", "coatDarkening", "COAT_DARKENING");
+
     /**
      * Specifies whether the coat roughness is taken from the
      * same texture as the coat_weight.

packages/dev/core/src/Shaders/ShadersInclude/openpbrCoatLayerData.fx

@@ -35,7 +35,7 @@ coat_weight = vCoatWeight;
 coat_roughness = vCoatRoughness;
 // coat_roughness_anisotropy = vCoatRoughnessAnisotropy;
 coat_ior = vCoatIor;
-// coat_darkening = vCoatDarkening;
+coat_darkening = vCoatDarkening;
 
 // Apply texture values to coat layer properties
 #ifdef COAT_WEIGHT

packages/dev/core/src/Shaders/ShadersInclude/openpbrDirectLighting.fx

@@ -82,12 +82,35 @@
         }
     #endif
 
+    vec3 coatAbsorption = vec3(1.0);
+    if (coat_weight > 0.0) {
+        // __________ Coat Darkening _____________
+        float cosTheta_view = max(preInfoCoat{X}.NdotV, 0.001);
+        float cosTheta_light = max(preInfoCoat{X}.NdotL, 0.001);
+        
+        // Fresnel reflectance for view direction
+        float fresnel_view = coatReflectance.F0 + (1.0 - coatReflectance.F0) * pow(1.0 - cosTheta_view, 5.0);
+
+        // Fresnel reflectance for light direction
+        float fresnel_light = coatReflectance.F0 + (1.0 - coatReflectance.F0) * pow(1.0 - cosTheta_light, 5.0);
+
+        // Average reflectance for the round trip (light in, view out)
+        float averageReflectance = (fresnel_view + fresnel_light) * 0.5;
+
+        // Calculate transmission through multiple internal reflections
+        // This uses the geometric series for infinite reflections:
+        // T = (1-R) / (1 + R + R² + R³ + ...) = (1-R) / (1/(1-R)) = (1-R)²
+        float effectiveReflectance = averageReflectance * coat_weight;
+        float transmission = (1.0 - effectiveReflectance) / (1.0 + effectiveReflectance);
+        coatAbsorption = coat_color * mix(1.0, transmission, coat_darkening);
+    }
+
     slab_diffuse *= base_color.rgb;
     vec3 material_opaque_base = mix(slab_diffuse, slab_subsurface, subsurface_weight);
     vec3 material_dielectric_base = mix(material_opaque_base, slab_translucent, transmission_weight);
     vec3 material_dielectric_gloss = layer(material_dielectric_base, slab_glossy, specularFresnel, vec3(1.0), specular_color);
     vec3 material_base_substrate = mix(material_dielectric_gloss, slab_metal, base_metalness);
-    vec3 material_coated_base = layer(material_base_substrate, slab_coat, coatFresnel, coat_color, vec3(1.0));
+    vec3 material_coated_base = layer(material_base_substrate, slab_coat, coatFresnel, coatAbsorption, vec3(1.0));
     material_surface_direct += mix(material_coated_base, slab_fuzz, fuzz_weight);
 }
 #endif

packages/dev/core/src/Shaders/ShadersInclude/openpbrEnvironmentLighting.fx

@@ -104,8 +104,28 @@
     slab_metal_ibl = baseSpecularEnvironmentLight * conductorIblFresnel * vLightingIntensity.z;
 
     // _____________________________ Coat Layer IBL _____________________________
+    // We will use this absorption value to darken the underlying layers. It includes both the
+    // abosorption of the coat layer and the darkening due to internal reflections.
+    vec3 coatAbsorption = vec3(1.0);
     if (coat_weight > 0.0) {
         slab_coat_ibl = coatEnvironmentLight * vLightingIntensity.z;
+        
+        // __________ Coat Darkening _____________
+        // Hemisphere-averaged Fresnel (empirical approximation)
+        float hemisphere_avg_fresnel = coatReflectance.F0 + 0.5 * (1.0 - coatReflectance.F0);
+        float averageReflectance = (coatIblFresnel + hemisphere_avg_fresnel) * 0.5;
+        
+        // Account for roughness - rougher surfaces have more diffuse internal reflections
+        // This reduces the darkening effect as roughness increases
+        float roughnessFactor = 1.0 - coat_roughness * 0.5;
+        averageReflectance *= roughnessFactor;
+
+        // Calculate transmission through multiple internal reflections
+        // This uses the geometric series for infinite reflections:
+        // T = (1-R) / (1 + R + R² + R³ + ...) = (1-R) / (1/(1-R)) = (1-R)²
+        float effectiveReflectance = averageReflectance * coat_weight;
+        float transmission = (1.0 - effectiveReflectance) / (1.0 + effectiveReflectance);
+        coatAbsorption = coat_color * mix(1.0, transmission, coat_darkening);
     }
 
     // TEMP
@@ -121,7 +141,7 @@
     vec3 material_dielectric_base_ibl = mix(material_opaque_base_ibl, slab_translucent_base_ibl, transmission_weight);
     vec3 material_dielectric_gloss_ibl = layer(material_dielectric_base_ibl, slab_glossy_ibl, dielectricIblFresnel, vec3(1.0), specular_color);
     vec3 material_base_substrate_ibl = mix(material_dielectric_gloss_ibl, slab_metal_ibl, base_metalness);
-    vec3 material_coated_base_ibl = layer(material_base_substrate_ibl, slab_coat_ibl, coatIblFresnel, coat_color, vec3(1.0));
+    vec3 material_coated_base_ibl = layer(material_base_substrate_ibl, slab_coat_ibl, coatIblFresnel, coatAbsorption, vec3(1.0));
     material_surface_ibl = mix(material_coated_base_ibl, slab_fuzz_ibl, fuzz_weight);
 
 #endif

packages/dev/core/src/Shaders/ShadersInclude/openpbrFragmentDeclaration.fx

@@ -9,6 +9,7 @@ uniform float vCoatWeight;
 uniform vec3 vCoatColor;
 uniform float vCoatRoughness;
 uniform float vCoatIor;
+uniform float vCoatDarkening;
 uniform vec3 vEmissionColor;
 
 // CUSTOM CONTROLS
@@ -57,6 +58,10 @@ uniform vec2 vBaseMetalRoughInfos;
 uniform vec2 vCoatWeightInfos;
 #endif
 
+#ifdef COAT_DARKENING
+uniform vec2 vCoatDarkeningInfos;
+#endif
+
 // Refraction Reflection
 #if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(SS_REFRACTION) || defined(PREPASS)
 uniform mat4 view;

packages/dev/core/src/Shaders/ShadersInclude/openpbrFragmentSamplersDeclaration.fx

@@ -7,6 +7,8 @@
 #include<samplerFragmentDeclaration>(_DEFINENAME_,COAT_WEIGHT,_VARYINGNAME_,CoatWeight,_SAMPLERNAME_,coatWeight)
 #include<samplerFragmentDeclaration>(_DEFINENAME_,COAT_COLOR,_VARYINGNAME_,CoatColor,_SAMPLERNAME_,coatColor)
 #include<samplerFragmentDeclaration>(_DEFINENAME_,COAT_ROUGHNESS,_VARYINGNAME_,CoatRoughness,_SAMPLERNAME_,coatRoughness)
+// #include<samplerFragmentDeclaration>(_DEFINENAME_,COAT_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,CoatRoughnessAnisotropy,_SAMPLERNAME_,coatRoughnessAnisotropy)
+#include <samplerFragmentDeclaration>(_DEFINENAME_,COAT_DARKENING,_VARYINGNAME_,CoatDarkening,_SAMPLERNAME_,coatDarkening)
 #include<samplerFragmentDeclaration>(_DEFINENAME_,GEOMETRY_OPACITY,_VARYINGNAME_,GeometryOpacity,_SAMPLERNAME_,geometryOpacity)
 #include<samplerFragmentDeclaration>(_DEFINENAME_,EMISSION_COLOR,_VARYINGNAME_,EmissionColor,_SAMPLERNAME_,emissionColor)
 

packages/dev/core/src/Shaders/ShadersInclude/openpbrUboDeclaration.fx

@@ -69,6 +69,7 @@ uniform Material {
     vec3 vCoatColor;
     float vCoatRoughness;
     float vCoatIor;
+    float vCoatDarkening;
     vec3 vEmissionColor;
 
     vec2 vBaseWeightInfos;
@@ -89,6 +90,8 @@ uniform Material {
     mat4 coatColorMatrix;
     vec2 vCoatRoughnessInfos;
     mat4 coatRoughnessMatrix;
+    vec2 vCoatDarkeningInfos;
+    mat4 coatDarkeningMatrix;
     vec2 vGeometryNormalInfos;
     mat4 geometryNormalMatrix;
     vec2 vGeometryCoatNormalInfos;

packages/dev/core/src/Shaders/ShadersInclude/openpbrVertexDeclaration.fx

@@ -21,11 +21,6 @@ uniform mat4 baseDiffuseRoughnessMatrix;
 uniform vec2 vBaseDiffuseRoughnessInfos;
 #endif
 
-#ifdef GEOMETRY_OPACITY
-uniform mat4 geometryOpacityMatrix;
-uniform vec2 vGeometryOpacityInfos;
-#endif
-
 #ifdef AMBIENT_OCCLUSION
 uniform vec2 vAmbientOcclusionInfos;
 uniform mat4 ambientOcclusionMatrix;
@@ -56,6 +51,36 @@ uniform vec2 vSpecularColorInfos;
 uniform mat4 specularColorMatrix;
 #endif
 
+#ifdef COAT_WEIGHT
+uniform vec2 vCoatWeightInfos;
+uniform mat4 coatWeightMatrix;
+#endif
+
+#ifdef COAT_COLOR
+uniform vec2 vCoatColorInfos;
+uniform mat4 coatColorMatrix;
+#endif
+
+#ifdef COAT_ROUGHNESS
+uniform vec2 vCoatRoughnessInfos;
+uniform mat4 coatRoughnessMatrix;
+#endif
+
+#ifdef COAT_ROUGHNESS_ANISOTROPY
+uniform vec2 vCoatRoughnessAnisotropyInfos;
+uniform mat4 coatRoughnessAnisotropyMatrix;
+#endif
+
+#ifdef COAT_IOR
+uniform vec2 vCoatIorInfos;
+uniform mat4 coatIorMatrix;
+#endif
+
+#ifdef COAT_DARKENING
+uniform vec2 vCoatDarkeningInfos;
+uniform mat4 coatDarkeningMatrix;
+#endif
+
 #ifdef GEOMETRY_NORMAL
 uniform vec2 vGeometryNormalInfos;
 uniform mat4 geometryNormalMatrix;
@@ -66,6 +91,11 @@ uniform vec2 vGeometryCoatNormalInfos;
 uniform mat4 geometryCoatNormalMatrix;
 #endif
 
+#ifdef GEOMETRY_OPACITY
+uniform mat4 geometryOpacityMatrix;
+uniform vec2 vGeometryOpacityInfos;
+#endif
+
 #ifdef POINTSIZE
 uniform float pointSize;
 #endif

packages/dev/core/src/Shaders/openpbr.vertex.fx

@@ -42,6 +42,8 @@ attribute vec4 color;
 #include<samplerVertexDeclaration>(_DEFINENAME_,COAT_WEIGHT,_VARYINGNAME_,CoatWeight)
 #include<samplerVertexDeclaration>(_DEFINENAME_,COAT_COLOR,_VARYINGNAME_,CoatColor)
 #include<samplerVertexDeclaration>(_DEFINENAME_,COAT_ROUGHNESS,_VARYINGNAME_,CoatRoughness)
+// #include<samplerVertexDeclaration>(_DEFINENAME_,COAT_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,CoatRoughnessAnisotropy)
+#include<samplerVertexDeclaration>(_DEFINENAME_,COAT_DARKENING,_VARYINGNAME_,CoatDarkening)
 #include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_NORMAL,_VARYINGNAME_,GeometryNormal)
 #include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_COAT_NORMAL,_VARYINGNAME_,GeometryCoatNormal)
 #include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_OPACITY,_VARYINGNAME_,GeometryOpacity)
@@ -224,6 +226,8 @@ void main(void) {
     #include<samplerVertexImplementation>(_DEFINENAME_,COAT_WEIGHT,_VARYINGNAME_,CoatWeight,_MATRIXNAME_,coatWeight,_INFONAME_,CoatWeightInfos.x)
     #include<samplerVertexImplementation>(_DEFINENAME_,COAT_COLOR,_VARYINGNAME_,CoatColor,_MATRIXNAME_,coatColor,_INFONAME_,CoatColorInfos.x)
     #include<samplerVertexImplementation>(_DEFINENAME_,COAT_ROUGHNESS,_VARYINGNAME_,CoatRoughness,_MATRIXNAME_,coatRoughness,_INFONAME_,CoatRoughnessInfos.x)
+    // #include<samplerVertexImplementation>(_DEFINENAME_,COAT_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,CoatRoughnessAnisotropy,_MATRIXNAME_,coatRoughnessAnisotropy,_INFONAME_,CoatRoughnessAnisotropyInfos.x)
+    #include<samplerVertexImplementation>(_DEFINENAME_,COAT_DARKENING,_VARYINGNAME_,CoatDarkening,_MATRIXNAME_,coatDarkening,_INFONAME_,CoatDarkeningInfos.x)
     #include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_NORMAL,_VARYINGNAME_,GeometryNormal,_MATRIXNAME_,geometryNormal,_INFONAME_,GeometryNormalInfos.x)
     #include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_COAT_NORMAL,_VARYINGNAME_,GeometryCoatNormal,_MATRIXNAME_,geometryCoatNormal,_INFONAME_,GeometryCoatNormalInfos.x)
     #include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_OPACITY,_VARYINGNAME_,GeometryOpacity,_MATRIXNAME_,geometryOpacity,_INFONAME_,GeometryOpacityInfos.x)

packages/dev/core/src/ShadersWGSL/ShadersInclude/openpbrCoatLayerData.fx

@@ -35,7 +35,7 @@ coat_weight = uniforms.vCoatWeight;
 coat_roughness = uniforms.vCoatRoughness;
 // coat_roughness_anisotropy = uniforms.vCoatRoughnessAnisotropy;
 coat_ior = uniforms.vCoatIor;
-// coat_darkening = uniforms.vCoatDarkening;
+coat_darkening = uniforms.vCoatDarkening;
 
 // Apply texture values to coat layer properties
 #ifdef COAT_WEIGHT