Replace GetViewShiftedNormal() with GetViewReflectedNormal()

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 #define HALF_PI     1.57079632679
 #define INV_HALF_PI 0.636619772367
 #define INFINITY    asfloat(0x7F800000)
+#define FLT_SMALL   0.0001
+// #define MIN_N_DOT_V FLT_SMALL               // The minimum value of 'NdotV'
 
 #define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
 #define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

 // Helper functions
 //-----------------------------------------------------------------------------
 
-// 'NdotV' can become negative for visible pixels due to the perspective projection, normal mapping and decals.
-// This can produce visible artifacts under specular lighting, both direct (overly dark/bright pixels) and indirect (incorrect cubemap direction).
-// One way of avoiding these artifacts is to limit the value of 'NdotV' to a small positive number,
-// and calculate the reflection vector for the cubemap fetch using a normal shifted into view.
-float3 GetViewShiftedNormal(float3 N, float3 V, float NdotV, float minNdotV)
-{
-    if (NdotV < minNdotV)
-    {
-        // We do not renormalize the normal to save a few clock cycles.
-        // The magnitude difference is typically negligible, and the normal is only used to compute
-        // the reflection vector for the IBL cube map fetch (which does not depend on the magnitude).
-        N += (-NdotV + minNdotV) * V;
-    }
-
-    return N;
-}
-
 // Inputs:    normalized normal and view vectors.
 // Outputs:   front-facing normal, and the new non-negative value of the cosine of the view angle.
 // Important: call Orthonormalize() on the tangent and recompute the bitangent afterwards.

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 float4 _TransmissionTints[SSS_N_PROFILES];  // RGB = 1/4 * color, A = unused
 CBUFFER_END
 
-// General constant
-#define MIN_N_DOT_V    0.0001               // The minimum value of 'NdotV'
-
 //-----------------------------------------------------------------------------
 // Helper for cheap screen space raycasting
 //-----------------------------------------------------------------------------
 struct PreLightData
 {
     // General
-    float NdotV;                         // Geometric version (could be negative)
+    float NdotV;
 
     // GGX
     float partLambdaV;
 {
     PreLightData preLightData;
 
+    float3 N;
+    float  NdotV;
+
+        N     = bsdfData.coatNormalWS;
+        NdotV = saturate(dot(N, V));
+        preLightData.coatNdotV = NdotV;
+
-
-        preLightData.coatNdotV = dot(bsdfData.coatNormalWS, V);
-
-        // In the case of IBL we want  shift a bit the normal that are not toward the viewver to reduce artifact
-        float3 coatIblNormalWS = GetViewShiftedNormal(bsdfData.coatNormalWS, V, preLightData.coatNdotV, MIN_N_DOT_V); // Use non-clamped NdotV
-        preLightData.coatIblDirWS = reflect(-V, coatIblNormalWS);
-
-        float coatNdotV = max(preLightData.coatNdotV, MIN_N_DOT_V); // Use the modified (clamped) version
+        preLightData.coatIblDirWS = reflect(-V, N);
-        float theta = FastACosPos(coatNdotV);
+        float theta = FastACosPos(NdotV);
         float2 uv = LTC_LUT_OFFSET + LTC_LUT_SCALE * float2(0.0, theta * INV_HALF_PI); // Use Roughness of 0.0 for clearCoat roughness
 
                                                                                        // Get the inverse LTC matrix for GGX
         preLightData.ltcClearCoatFresnelTerm = preLightData.coatFresnel0 * ltcClearCoatFresnelMagnitudeDiff + ltcClearCoatFresnelMagnitude;
 
         // TODO: Convert the area light with respect to Fresnel transmission
-        float3 N = bsdfData.coatNormalWS; // TODO : check with Laurentb
-        preLightData.refractV = ClearCoatTransform(V, bsdfData.coatNormalWS, ieta);
+        preLightData.refractV = ClearCoatTransform(V, N, ieta);
-    preLightData.NdotV = dot(bsdfData.normalWS, V); // Store the unaltered (geometric) version
+    N     = bsdfData.normalWS;
+    NdotV = saturate(dot(N, V));
+    preLightData.NdotV = NdotV;
-    // In the case of IBL we want  shift a bit the normal that are not toward the viewver to reduce artifact
-    float3 iblNormalWS = GetViewShiftedNormal(bsdfData.normalWS, V, preLightData.NdotV, MIN_N_DOT_V); // Use non-clamped NdotV
-
-    float NdotV = max(preLightData.NdotV, MIN_N_DOT_V); // Use the modified (clamped) version
 
     // GGX aniso
     if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
         float3 grainDirWS = (bsdfData.anisotropy >= 0) ? bsdfData.bitangentWS : bsdfData.tangentWS;
         // Reduce stretching for (perceptualRoughness < 0.2).
         float  stretch = abs(bsdfData.anisotropy) * saturate(5 * bsdfData.perceptualRoughness);
-        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV) and use iblNormalWS
+        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV) and use 'anisoIblNormalWS'
-        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(grainDirWS, iblNormalWS, V, stretch);
+        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(grainDirWS, N, V, stretch);
         iblR = reflect(-V, anisoIblNormalWS);
     }
     else // GGX iso
         preLightData.partLambdaV = GetSmithJointGGXPartLambdaV(NdotV, bsdfData.roughness);
-        iblR                     = reflect(-V, iblNormalWS);
+        iblR                     = reflect(-V, N);
     }
 
     float reflectivity;
         float roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
         float shininess = Sqr(preLightData.ieta) * (2.0 / Sqr(roughness) - 2.0);
         roughness = sqrt(2.0 / (shininess + 2.0));
-        preLightData.iblDirWS = GetSpecularDominantDir(iblNormalWS, iblR, roughness, NdotV);
+        preLightData.iblDirWS = GetSpecularDominantDir(N, iblR, roughness, NdotV);
         preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(RoughnessToPerceptualRoughness(roughness));
     }
     else
             iblPerceptualRoughness = bsdfData.perceptualRoughness;
         }
 
-        preLightData.iblDirWS    = GetSpecularDominantDir(iblNormalWS, iblR, iblRoughness, NdotV);
+        preLightData.iblDirWS    = GetSpecularDominantDir(N, iblR, iblRoughness, NdotV);
         preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(iblPerceptualRoughness);
     }
 
     preLightData.ltcTransformSpecular._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, s_linear_clamp_sampler, uv, LTC_GGX_MATRIX_INDEX, 0);
 
     // Construct a right-handed view-dependent orthogonal basis around the normal
-    preLightData.orthoBasisViewNormal[0] = normalize(V - bsdfData.normalWS * preLightData.NdotV);
-    preLightData.orthoBasisViewNormal[2] = bsdfData.normalWS;
+    preLightData.orthoBasisViewNormal[0] = normalize(V - N * NdotV);
+    preLightData.orthoBasisViewNormal[2] = N;
     preLightData.orthoBasisViewNormal[1] = normalize(cross(preLightData.orthoBasisViewNormal[2], preLightData.orthoBasisViewNormal[0]));
 
     float3 ltcMagnitude = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, s_linear_clamp_sampler, uv, LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX, 0).rgb;
         float NdotL = saturate(dot(bsdfData.coatNormalWS, L));
         float NdotV = preLightData.coatNdotV;
         float LdotV = dot(L, V);
-        float invLenLV = rsqrt(abs(2 * LdotV + 2));
+        float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_SMALL));
         float NdotH = saturate((NdotL + NdotV) * invLenLV);
         float LdotH = saturate(invLenLV * LdotV + invLenLV);
 
     float invLenLV = rsqrt(abs(2 * LdotV + 2));           // invLenLV = rcp(length(L + V))
     float NdotH    = saturate((NdotL + NdotV) * invLenLV);
     float LdotH    = saturate(invLenLV * LdotV + invLenLV);
-
-    NdotV          = max(NdotV, MIN_N_DOT_V);             // Use the modified (clamped) version
 
     F *= F_Schlick(bsdfData.fresnel0, LdotH);
 
         illuminance  = Lambert() * wrappedNdotL;
     #else
         float tNdotL = saturate(-NdotL);
-        float  NdotV = max(preLightData.NdotV, MIN_N_DOT_V);
+        float  NdotV = preLightData.NdotV;
         illuminance  = INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, tNdotL) * wrappedNdotL;
     #endif
 
         illuminance  = Lambert() * wrappedNdotL;
     #else
         float tNdotL = saturate(-NdotL);
-        float  NdotV = max(preLightData.NdotV, MIN_N_DOT_V);
+        float  NdotV = preLightData.NdotV;
         illuminance  = INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, tNdotL) * wrappedNdotL;
     #endif
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

     float3 bentNormalWS;
     float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS);
     GetNormalWS(input, V, normalTS, surfaceData.normalWS);
+
+    // Ensure that the normal is front-facing.
+    float NdotV;
+    surfaceData.normalWS = GetViewReflectedNormal(surfaceData.normalWS, V, NdotV);
+
     // Use bent normal to sample GI if available
 #ifdef _BENTNORMALMAP
     GetNormalWS(input, V, bentNormalTS, bentNormalWS);
     // If we have bent normal and ambient occlusion, process a specular occlusion
     surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData);
 #elif defined(_MASKMAP)
-    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(dot(surfaceData.normalWS, V), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(NdotV, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
 #else
     surfaceData.specularOcclusion = 1.0;
 #endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitReference.hlsl

                                     uint sampleCount = 4096)
 {
     float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
-    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
+    float    NdotV        = preLightData.NdotV;
     float3   acc          = float3(0.0, 0.0, 0.0);
 
     // Add some jittering on Hammersley2d
         localToWorld = GetLocalFrame(bsdfData.normalWS);
     }
 
-    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
-    float3   acc          = float3(0.0, 0.0, 0.0);
+    float  NdotV = preLightData.NdotV;
+    float3 acc   = float3(0.0, 0.0, 0.0);
 
     // Add some jittering on Hammersley2d
     float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);