WIP OpenPBR anisotropy for IBL

Author: Mike Bond

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

@@ -63,6 +63,7 @@ import { PushMaterial } from "../pushMaterial";
 import { SmartArray } from "../../Misc/smartArray";
 import type { RenderTargetTexture } from "../Textures/renderTargetTexture";
 import type { IAnimatable } from "../../Animations/animatable.interface";
+import { Texture } from "../Textures";
 
 const onCreatedEffectParameters = { effect: null as unknown as Effect, subMesh: null as unknown as Nullable<SubMesh> };
 
@@ -778,6 +779,8 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
     private _samplersList: { [name: string]: Sampler } = {};
     private _samplerDefines: { [name: string]: { type: string; default: any } } = {};
 
+    private static _noiseTexture: Nullable<BaseTexture> = null;
+
     /**
      * Intensity of the direct lights e.g. the four lights available in your scene.
      * This impacts both the direct diffuse and specular highlights.
@@ -1352,6 +1355,16 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
             Logger.Error("OpenPBRMaterial: WebGL 2.0 or above is required for this material.");
         }
 
+        if (OpenPBRMaterial._noiseTexture === null || OpenPBRMaterial._noiseTexture.getScene()?.getEngine() !== scene?.getEngine()) {
+            OpenPBRMaterial._noiseTexture = new Texture(
+                "https://assets.babylonjs.com/textures/blue_noise/blue_noise_rgb.png",
+                scene,
+                false,
+                true,
+                Constants.TEXTURE_NEAREST_SAMPLINGMODE
+            );
+        }
+
         // Setup the default processing configuration to the scene.
         this._attachImageProcessingConfiguration(null);
 
@@ -1370,7 +1383,6 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
 
         this._environmentBRDFTexture = GetEnvironmentBRDFTexture(this.getScene());
         this.prePassConfiguration = new PrePassConfiguration();
-        this._environmentBRDFTexture = GetEnvironmentBRDFTexture(this.getScene());
 
         // Build the internal property list that can be used to generate and update the uniform buffer
         this._propertyList = {};
@@ -1697,6 +1709,12 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                         return false;
                     }
                 }
+
+                if (OpenPBRMaterial._noiseTexture) {
+                    if (!OpenPBRMaterial._noiseTexture.isReady()) {
+                        return false;
+                    }
+                }
             }
         }
 
@@ -1933,6 +1951,10 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
                 if (defines.ENVIRONMENTBRDF) {
                     ubo.setTexture("environmentBrdfSampler", this._environmentBRDFTexture);
                 }
+
+                if (defines.ANISOTROPIC) {
+                    ubo.setTexture("blueNoiseSampler", OpenPBRMaterial._noiseTexture);
+                }
             }
 
             // OIT with depth peeling
@@ -2249,7 +2271,16 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
             uniforms.push(uniformName);
         }
 
-        const samplers = ["environmentBrdfSampler", "boneSampler", "morphTargets", "oitDepthSampler", "oitFrontColorSampler", "areaLightsLTC1Sampler", "areaLightsLTC2Sampler"];
+        const samplers = [
+            "environmentBrdfSampler",
+            "blueNoiseSampler",
+            "boneSampler",
+            "morphTargets",
+            "oitDepthSampler",
+            "oitFrontColorSampler",
+            "areaLightsLTC1Sampler",
+            "areaLightsLTC2Sampler",
+        ];
 
         for (const key in this._samplersList) {
             const sampler = this._samplersList[key];
@@ -2474,7 +2505,7 @@ export class OpenPBRMaterial extends OpenPBRMaterialBase {
 
         defines.HORIZONOCCLUSION = this._useHorizonOcclusion;
 
-        if (this.specularRoughnessAnisotropy > 0.0) {
+        if (this.specularRoughnessAnisotropy > 0.0 && OpenPBRMaterial._noiseTexture) {
             defines.ANISOTROPIC = true;
             if (!mesh.isVerticesDataPresent(VertexBuffer.TangentKind)) {
                 defines._needUVs = true;

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

@@ -71,6 +71,10 @@ vec2 geometry_tangent = vec2(1.0, 0.0);
     #endif
 #endif
 
+#ifdef ANISOTROPIC
+    vec3 noise = texture2D(blueNoiseSampler, gl_FragCoord.xy / 256.0).xyz;
+#endif
+
 // Initalize base layer properties from uniforms
 base_color = vBaseColor.rgb;
 #if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)

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

@@ -34,20 +34,38 @@
     #else
         vec2 reflectionCoords = vec2(0., 0.);
     #endif
-    reflectionCoords = createReflectionCoords(vPositionW, normalW);
+
     float specularAlphaG = specular_roughness * specular_roughness;
-    vec3 baseSpecularEnvironmentLight = sampleRadiance(specularAlphaG, vReflectionMicrosurfaceInfos.rgb, vReflectionInfos
-        #if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
-            , baseGeoInfo.NdotVUnclamped
-        #endif
-        , reflectionSampler
-        , reflectionCoords
-        #ifdef REALTIME_FILTERING
-            , vReflectionFilteringInfo
-        #endif
-    );
+    #ifdef ANISOTROPIC
+        vec3 baseSpecularEnvironmentLight = sampleRadianceAnisotropic(specularAlphaG, vReflectionMicrosurfaceInfos.rgb, vReflectionInfos
+            , baseGeoInfo
+            , normalW
+            , viewDirectionW
+            , vPositionW
+            , noise
+            , reflectionSampler
+            #ifdef REALTIME_FILTERING
+                , vReflectionFilteringInfo
+            #endif
+        );
+    #else
+        reflectionCoords = createReflectionCoords(vPositionW, normalW);
+        vec3 baseSpecularEnvironmentLight = sampleRadiance(specularAlphaG, vReflectionMicrosurfaceInfos.rgb, vReflectionInfos
+            , baseGeoInfo
+            , reflectionSampler
+            , reflectionCoords
+            #ifdef REALTIME_FILTERING
+                , vReflectionFilteringInfo
+            #endif
+        );
+    #endif
 
-    baseSpecularEnvironmentLight = mix(baseSpecularEnvironmentLight.rgb, baseDiffuseEnvironmentLight, specularAlphaG);
+    // Purely empirical blend between diffuse and specular lobes when roughness gets very high.
+    #ifdef ANISOTROPIC
+        baseSpecularEnvironmentLight = mix(baseSpecularEnvironmentLight.rgb, baseDiffuseEnvironmentLight, min(specularAlphaG * specularAlphaG, 0.5));
+    #else
+        baseSpecularEnvironmentLight = mix(baseSpecularEnvironmentLight.rgb, baseDiffuseEnvironmentLight, specularAlphaG);
+    #endif
 
     vec3 coatEnvironmentLight = vec3(0., 0., 0.);
     if (coat_weight > 0.0) {
@@ -59,9 +77,7 @@
         reflectionCoords = createReflectionCoords(vPositionW, coatNormalW);
         float coatAlphaG = coat_roughness * coat_roughness;
         coatEnvironmentLight = sampleRadiance(coatAlphaG, vReflectionMicrosurfaceInfos.rgb, vReflectionInfos
-            #if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
-                , coatGeoInfo.NdotVUnclamped
-            #endif
+            , coatGeoInfo
             , reflectionSampler
             , reflectionCoords
             #ifdef REALTIME_FILTERING

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

@@ -66,6 +66,10 @@
     uniform sampler2D environmentBrdfSampler;
 #endif
 
+#ifdef ANISOTROPIC
+    uniform sampler2D blueNoiseSampler;
+#endif
+
 #ifdef IBL_CDF_FILTERING
     uniform sampler2D icdfSampler;
 #endif

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

@@ -8,6 +8,7 @@ struct geometryInfoOutParams
         float anisotropy;
         vec3 anisotropicTangent;
         vec3 anisotropicBitangent;
+        mat3 TBN;
     #endif
 };
 
@@ -52,7 +53,7 @@ geometryInfoOutParams geometryInfo(
         outParams.anisotropy = anisotropy;
         outParams.anisotropicTangent = anisotropicTangent;
         outParams.anisotropicBitangent = anisotropicBitangent;
-        
+        outParams.TBN = TBN;
     #endif
 
     return outParams;

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

@@ -120,16 +120,9 @@
     #endif
         in vec3 vPositionW
         , in vec3 normalW
-    #ifdef ANISOTROPIC
-        , in anisotropicOutParams anisotropicOut
-    #endif
     )
     {
-        #ifdef ANISOTROPIC
-            vec3 reflectionVector = computeReflectionCoords(vec4(vPositionW, 1.0), anisotropicOut.anisotropicNormal);
-        #else
-            vec3 reflectionVector = computeReflectionCoords(vec4(vPositionW, 1.0), normalW);
-        #endif
+        vec3 reflectionVector = computeReflectionCoords(vec4(vPositionW, 1.0), normalW);
 
         #ifdef REFLECTIONMAP_OPPOSITEZ
             reflectionVector.z *= -1.0;
@@ -154,9 +147,7 @@
         in float alphaG
         , in vec3 vReflectionMicrosurfaceInfos
         , in vec2 vReflectionInfos
-    #if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
-        , in float NdotVUnclamped
-    #endif
+        , in geometryInfoOutParams geoInfo
     #ifdef REFLECTIONMAP_3D
         , in samplerCube reflectionSampler
         , const vec3 reflectionCoords
@@ -172,7 +163,7 @@
         vec4 environmentRadiance = vec4(0., 0., 0., 0.);
         // _____________________________ 2D vs 3D Maps ________________________________
         #if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
-            float reflectionLOD = getLodFromAlphaG(vReflectionMicrosurfaceInfos.x, alphaG, NdotVUnclamped);
+            float reflectionLOD = getLodFromAlphaG(vReflectionMicrosurfaceInfos.x, alphaG, geoInfo.NdotVUnclamped);
         #elif defined(LINEARSPECULARREFLECTION)
             float reflectionLOD = getLinearLodFromRoughness(vReflectionMicrosurfaceInfos.x, roughness);
         #else
@@ -184,6 +175,19 @@
 
         #ifdef REALTIME_FILTERING
             environmentRadiance = vec4(radiance(alphaG, reflectionSampler, reflectionCoords, vReflectionFilteringInfo), 1.0);
+        // #elif defined(ANISOTROPIC)
+        //     vec4 radianceSample = vec4(0.0);
+        //     const int samples = 16;
+        //     for (int i = 0; i < samples; ++i) {
+        //         float t = (float(i) * (1.0f / float(max(samples - 1, 1))) - 0.5f) * 3.14159 * alphaT;
+        //         vec3 perturbed_N = geoInfo.anisotropicTangent * t;
+        //         // Add noise (mostly in the tangent direction) to smooth out sampling
+        //         // perturbed_N.xy += new_noise.xy;
+                
+        //         vec3 newCoords = normalize(reflectionCoords + perturbed_N);
+        //         radianceSample += sampleReflectionLod(reflectionSampler, newCoords, reflectionLOD);
+        //     }
+        //     environmentRadiance = vec4(radianceSample.xyz / float(samples), 1.0);
         #else
             environmentRadiance = sampleReflectionLod(reflectionSampler, reflectionCoords, reflectionLOD);
         #endif
@@ -201,6 +205,136 @@
         return environmentRadiance.rgb;
     }
 
+#if defined(ANISOTROPIC)
+    #define pbr_inline
+    #define inline
+    vec3 sampleRadianceAnisotropic(
+        in float alphaG
+        , in vec3 vReflectionMicrosurfaceInfos
+        , in vec2 vReflectionInfos
+        , in geometryInfoOutParams geoInfo
+        , const vec3 normalW
+        , const vec3 viewDirectionW
+        , const vec3 positionW
+        , const vec3 noise
+    #ifdef REFLECTIONMAP_3D
+        , in samplerCube reflectionSampler
+    #else
+        , in sampler2D reflectionSampler
+    #endif
+    #ifdef REALTIME_FILTERING
+        , in vec2 vReflectionFilteringInfo
+    #endif
+    )
+    {
+        vec4 environmentRadiance = vec4(0., 0., 0., 0.);
+
+        // Calculate alpha along tangent and bitangent according to equation 21 in the OpenPBR spec.
+        float alphaT = alphaG * sqrt(2.0 / (1.0 + (1.0 - geoInfo.anisotropy) * (1.0 - geoInfo.anisotropy)));
+        float alphaB = (1.0 - geoInfo.anisotropy) * alphaT;
+        alphaG = mix(alphaG, alphaB, 0.95);
+
+        // _____________________________ 2D vs 3D Maps ________________________________
+        #if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+            float reflectionLOD = getLodFromAlphaG(vReflectionMicrosurfaceInfos.x, alphaG, geoInfo.NdotVUnclamped);
+        #elif defined(LINEARSPECULARREFLECTION)
+            float reflectionLOD = getLinearLodFromRoughness(vReflectionMicrosurfaceInfos.x, roughness);
+        #else
+            float reflectionLOD = getLodFromAlphaG(vReflectionMicrosurfaceInfos.x, alphaG);
+        #endif
+
+        // Apply environment convolution scale/offset filter tuning parameters to the mipmap LOD selection
+        reflectionLOD = reflectionLOD * vReflectionMicrosurfaceInfos.y + vReflectionMicrosurfaceInfos.z;
+
+        #ifdef REALTIME_FILTERING
+            environmentRadiance = vec4(radiance(alphaG, reflectionSampler, reflectionCoords, vReflectionFilteringInfo), 1.0);
+        #else
+            // We will sample multiple reflections using interpolated surface normals along
+            // the tangent direction from -tangent to +tangent.
+            // We don't want to waste samples where the view direction is back-facing so
+            // we'll compress samples into the valid range.
+            const int samples = 16;
+            // Find the maximum safe interpolation range
+            float normalDot = dot(viewDirectionW, normalW);
+            float tangentDot = dot(viewDirectionW, geoInfo.anisotropicTangent);
+            float negTangentDot = dot(viewDirectionW, -geoInfo.anisotropicTangent);
+        
+            // Find the valid interpolation range on each side of the normal
+            float maxPositiveT = 1.0;  // Default: sample all the way to +tangent
+            float maxNegativeT = -1.0; // Default: sample all the way to -tangent
+        
+            // If +tangent is back-facing, find where the interpolation becomes back-facing
+            if (tangentDot <= 0.0) {
+                // Find t where mix(normalW, tangentW, t) becomes perpendicular to view
+                if (abs(tangentDot - normalDot) > 0.001) {
+                    maxPositiveT = clamp(-normalDot / (tangentDot - normalDot), 0.0, 1.0);
+                } else {
+                    maxPositiveT = 0.0; // Can't sample towards tangent
+                }
+            }
+        
+            // If -tangent is back-facing, find where the interpolation becomes back-facing  
+            if (negTangentDot <= 0.0) {
+                // Find t where mix(-tangentW, normalW, blend) becomes perpendicular to view
+                // This is equivalent to mix(normalW, -tangentW, -t) for t < 0
+                if (abs(negTangentDot - normalDot) > 0.001) {
+                    float negT = -normalDot / (negTangentDot - normalDot);
+                    maxNegativeT = clamp(-negT, -1.0, 0.0);
+                } else {
+                    maxNegativeT = 0.0; // Can't sample towards -tangent
+                }
+            }
+
+            // Further compress the sampling range based on the level of anisotropic roughness
+            float tangentRange = clamp(sqrt(sqrt(alphaT)) * geoInfo.anisotropy, 0.0, 1.0) * (0.25 * noise.x + 0.75);
+            maxPositiveT *= maxPositiveT * tangentRange;
+            maxNegativeT = -(maxNegativeT * maxNegativeT) * tangentRange;
+        
+            vec4 radianceSample = vec4(0.0);
+            vec3 reflectionCoords = vec3(0.0);
+            float sample_weight = 0.0;
+            float total_weight = 0.0;
+            for (int i = 0; i < samples; ++i) {
+                // Find interpolation parameter in our valid range
+                float t = mix(maxNegativeT, maxPositiveT, float(i) / float(max(samples - 1, 1)));
+                
+                // Generate sample direction
+                vec3 sampleDirection;
+                if (t < 0.0) {
+                    // Interpolate from -tangent towards normal
+                    float blend = t + 1.0;
+                    sampleDirection = normalize(mix(-geoInfo.anisotropicTangent, normalW, blend));
+                } else if (t > 0.0) {
+                    // Interpolate from normal towards +tangent
+                    float blend = t;
+                    sampleDirection = normalize(mix(normalW, geoInfo.anisotropicTangent, blend));
+                } else {
+                    // t = 0, sample the normal
+                    sampleDirection = normalW;
+                }
+                
+                // Empirical approximation of geometry masking.
+                sample_weight = pow(clamp(dot(normalW, sampleDirection), 0.0, 1.0), 16.0);
+                reflectionCoords = createReflectionCoords(positionW, sampleDirection);
+                radianceSample = sampleReflectionLod(reflectionSampler, reflectionCoords, reflectionLOD);
+                #ifdef RGBDREFLECTION
+                    environmentRadiance.rgb += sample_weight * fromRGBD(radianceSample);
+                #elif defined(GAMMAREFLECTION)
+                    environmentRadiance.rgb += sample_weight * toLinearSpace(radianceSample.rgb);
+                #else
+                    environmentRadiance.rgb += sample_weight * radianceSample.rgb;
+                #endif
+                total_weight += sample_weight;
+            }
+            environmentRadiance = vec4(environmentRadiance.xyz / float(total_weight), 1.0);
+        #endif
+
+        // _____________________________ Levels _____________________________________
+        environmentRadiance.rgb *= vec3(vReflectionInfos.x);
+        return environmentRadiance.rgb;
+    }
+#endif
+
     #define pbr_inline
     vec3 conductorIblFresnel(in ReflectanceParams reflectance, in float NdotV, in float roughness, in vec3 environmentBrdf)
     {

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

@@ -64,8 +64,8 @@ precision highp float;
 #include<openpbrConductorReflectance>
 
 #include<openpbrBlockAmbientOcclusion>
-#include<openpbrIblFunctions>
 #include<openpbrGeometryInfo>
+#include<openpbrIblFunctions>
 
 // Do a mix between layers with additional multipliers for each layer.
 vec3 layer(vec3 slab_bottom, vec3 slab_top, float lerp_factor, vec3 bottom_multiplier, vec3 top_multiplier) {