Adding prefiltered specular reflections

res/shaders/EnvironmentMapping.slang

@@ -192,4 +192,68 @@ float4 computePrefilteredCubemap(float3 localPos : LOCALPOS) : SV_Target
     prefilteredColor = prefilteredColor / totalWeight;
 
     return float4(prefilteredColor, 1.0);
+}
+
+// TODO: this is basically duplicate of Cook-Torrance BRDF
+float GeometrySchlickGGX(float NdotV, float roughness)
+{
+    float a = roughness;
+    float k = (a * a) / 2.0;
+
+    float nom = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+
+    return nom / denom;
+}
+// ----------------------------------------------------------------------------
+float GeometrySmith(float3 N, float3 V, float3 L, float roughness)
+{
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+
+    return ggx1 * ggx2;
+}
+
+float2 integrateBRDF(float nDotV, float roughness) {
+    float3 V;
+    V.x = sqrt(1.0 - nDotV * nDotV);
+    V.y = 0.0f;
+    V.z = nDotV;
+    float A = 0.0;
+    float B = 0.0;
+
+    float3 N = float3(0.0, 0.0, 1.0);
+
+    const uint SAMPLE_COUNT = 1024u;
+    for (uint i = 0u; i < SAMPLE_COUNT; ++i)
+    {
+        float2 Xi = Hammersley(i, SAMPLE_COUNT);
+        float3 H = ImportanceSampleGGX(Xi, N, roughness);
+        float3 L = normalize(2.0 * dot(V, H) * H - V);
+
+        float nDotL = max(L.z, 0.0);
+        float nDotH = max(H.z, 0.0);
+        float vDotH = max(dot(V, H), 0.0);
+
+        if (nDotL > 0.0)
+        {
+            float G = GeometrySmith(N, V, L, roughness);
+            float G_Vis = (G * vDotH) / (nDotH * nDotV);
+            float Fc = pow(1.0 - vDotH, 5.0);
+
+            A += (1.0 - Fc) * G_Vis;
+            B += Fc * G_Vis;
+        }
+    }
+    A /= float(SAMPLE_COUNT);
+    B /= float(SAMPLE_COUNT);
+    return float2(A, B);
+}
+
+[shader("pixel")]
+float2 precomputeBRDF(float2 texCoords) : SV_Target
+{
+    return integrateBRDF(texCoords.x, texCoords.y);
 }

res/shaders/lib/LightEnv.slang

@@ -70,8 +70,8 @@ struct LightEnv
     TextureCube irradianceMap;
     SamplerState irradianceSampler;
     TextureCube prefilteredMap;
-    SamplerState prefilteredSampler;
     Texture2D brdfLUT;
+    SamplerState lutSampler;
 };
 layout(set=3)
 ParameterBlock<LightEnv> pLightEnv;
@@ -314,15 +314,15 @@ struct CookTorrance : IBRDF
         float G = Smith(n, viewDir_WS, lightDir_WS);
         float3 F = FresnelSchlickRoughness(max(dot(h, viewDir_WS), 0.0), F0, roughness);
 
-        float3 num = NDF * G * F;
-        float denom = 4.0 * max(dot(n, viewDir_WS), 0.0) * max(dot(n, lightDir_WS), 0.0) + 0.000001;
-        float3 specular = num / denom;
-
         float3 k_s = F;
         float3 k_d = float3(1.0) - k_s;
 
         k_d *= 1.0 - metallic;
 
+        float3 num = NDF * G * F;
+        float denom = 4.0 * max(dot(n, viewDir_WS), 0.0) * max(dot(n, lightDir_WS), 0.0) + 0.000001;
+        float3 specular = num / denom;
+
         float nDotL = max(dot(n, lightDir_WS), 0.0);
 
         float3 result = (k_d * baseColor / PI + specular) * nDotL * lightColor;
@@ -340,12 +340,24 @@ struct CookTorrance : IBRDF
     {
         float3 F0 = float3(0.04);
         F0 = lerp(F0, baseColor, metallic);
-        float3 k_s = FresnelSchlickRoughness(max(dot(normal, viewDir_WS), 0.0), F0, roughness);
+        float3 F = FresnelSchlickRoughness(max(dot(normal, viewDir_WS), 0.0), F0, roughness);
+
+        float3 k_s = F;
         float3 k_d = 1 - k_s;
         k_d *= 1 - metallic;
+        
         float3 irradiance = pLightEnv.irradianceMap.SampleLevel(pLightEnv.irradianceSampler, normal, 4).rgb;
         float3 diffuse = irradiance * baseColor;
-        return (k_d * diffuse) * ambientOcclusion;
+
+        float3 r = reflect(-viewDir_WS, normal);
+
+        const float MAX_REFLECTION_LOD = 4;
+        float3 prefilteredColor = pLightEnv.prefilteredMap.SampleLevel(pLightEnv.irradianceSampler, r, roughness * MAX_REFLECTION_LOD).xyz;
+
+        float2 envBRDF = pLightEnv.brdfLUT.Sample(pLightEnv.lutSampler, float2(max(dot(normal, viewDir_WS), 0), roughness)).rg;
+        float3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y);
+
+        return (k_d * diffuse + specular) * ambientOcclusion;
     }
     float getAlpha()
     {