HDRenderPipeline: Remove sampleDirectionDiscardWS in reflection (not used)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/BSDF.hlsl

 
 real F_Schlick(real f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return (f90 - f0) * x5 + f0;                // sub mul mul mul sub mad
 
 real3 F_Schlick(real3 f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return f0 * (1.0 - x5) + (f90 * x5);        // sub mul mul mul sub mul mad*3
 // Does not handle TIR.
 real F_Transm_Schlick(real f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return (1.0 - f90 * x5) - f0 * (1.0 - x5);  // sub mul mul mul mad sub mad
 // Does not handle TIR.
 real3 F_Transm_Schlick(real3 f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return (1.0 - f90 * x5) - f0 * (1.0 - x5);  // sub mul mul mul mad sub mad*3
 }
 
 // Fresnel dieletric / conductor
-real3 F_FresnelConductor(real3 eta, real3 etak, real cosTheta)
+// Note: etak2 = etak * etak (optimization for Artist Friendly Metallic Fresnel below)
+// eta = eta_t / eta_i and etak = k_t / n_i
+real3 F_FresnelConductor(real3 eta, real3 etak2, real cosTheta)
-    real3 etak2 = etak * etak;
 
     real3 t0 = eta2 - etak2 - sinTheta2;
     real3 a2plusb2 = sqrt(t0 * t0 + 4.0 * eta2 * etak2);
     return 0.5 * (Rp + Rs);
 }
 
+// Conversion FO/IOR
+
+// ior is a value between 1.0 and 3.0. 1.0 is air interface
+real IorToFresnel0(real transmittedIor, real incidentIor = 1.0)
+{
+    return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
+}
+
+// Assume air interface for top
+// Note: Don't handle the case fresnel0 == 1
+real Fresnel0ToIor(real fresnel0)
+{
+    real sqrtF0 = sqrt(fresnel0);
+    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
+}
+
+// This function is a coarse approximation of computing fresnel0 for a different top than air (here clear coat of IOR 1.5) when we only have fresnel0 with air interface
+// This function is equivalent to IorToFresnel0(Fresnel0ToIor(fresnel0), 1.5)
+// mean
+// real sqrtF0 = sqrt(fresnel0);
+// return Sq(1.0 - 5.0 * sqrtF0) / Sq(5.0 - sqrtF0);
+// Optimization: Fit of the function (3 mad) for range [0.04 (should return 0), 1 (should return 1)]
+TEMPLATE_1_REAL(ConvertF0ForAirInterfaceToF0ForClearCoat15, fresnel0, return saturate(-0.0256868 + fresnel0 * (0.326846 + (0.978946 - 0.283835 * fresnel0) * fresnel0)))
+
+// Artist Friendly Metallic Fresnel Ref: http://jcgt.org/published/0003/04/03/paper.pdf
+
+real3 GetIorN(real3 f0, real3 edgeTint)
+{
+    real3 sqrtF0 = sqrt(f0);
+    return lerp((1.0 - f0) / (1.0 + f0), (1.0 + sqrtF0) / (1.0 - sqrt(f0)), edgeTint);
+}
+
+real3 getIorK2(real3 f0, real3 n)
+{
+    real3 nf0 = Sq(n + 1.0) * f0 - Sq(f0 - 1.0);
+    return nf0 / (1.0 - f0);
+}
+
 //-----------------------------------------------------------------------------
 // Specular BRDF
 //-----------------------------------------------------------------------------
     real a2 = Sq(roughness);
-    real s  = (NdotH * a2 - NdotH) * NdotH + 1.0;
+    real s = (NdotH * a2 - NdotH) * NdotH + 1.0;
     return a2 / (s * s);
 }
 
 real DV_SmithJointGGX(real NdotH, real NdotL, real NdotV, real roughness, real partLambdaV)
 {
     real a2 = Sq(roughness);
-    real s  = (NdotH * a2 - NdotH) * NdotH + 1.0;
+    real s = (NdotH * a2 - NdotH) * NdotH + 1.0;
 
     real lambdaV = NdotL * partLambdaV;
     real lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
 
 // Inline D_GGXAniso() * V_SmithJointGGXAniso() together for better code generation.
 real DV_SmithJointGGXAniso(real TdotH, real BdotH, real NdotH, real NdotV,
-                           real TdotL, real BdotL, real NdotL,
-                           real roughnessT, real roughnessB, real partLambdaV)
+    real TdotL, real BdotL, real NdotL,
+    real roughnessT, real roughnessB, real partLambdaV)
 {
     real a2 = roughnessT * roughnessB;
     real3 v = real3(roughnessB * TdotH, roughnessT * BdotH, a2 * NdotH);
 }
 
 real DV_SmithJointGGXAniso(real TdotH, real BdotH, real NdotH,
-                           real TdotV, real BdotV, real NdotV,
-                           real TdotL, real BdotL, real NdotL,
-                           real roughnessT, real roughnessB)
+    real TdotV, real BdotV, real NdotV,
+    real TdotL, real BdotL, real NdotL,
+    real roughnessT, real roughnessB)
-                                 roughnessT, roughnessB, partLambdaV);
+        roughnessT, roughnessB, partLambdaV);
 }
 
 //-----------------------------------------------------------------------------
     real fd90 = 0.5 + (perceptualRoughness + perceptualRoughness * LdotV);
     // Two schlick fresnel term
     real lightScatter = F_Schlick(1.0, fd90, NdotL);
-    real viewScatter  = F_Schlick(1.0, fd90, NdotV);
+    real viewScatter = F_Schlick(1.0, fd90, NdotV);
 
     // Normalize the BRDF for polar view angles of up to (Pi/4).
     // We use the worst case of (roughness = albedo = 1), and, for each view angle,
 // Ref: Diffuse Lighting for GGX + Smith Microsurfaces, p. 113.
 real3 DiffuseGGXNoPI(real3 albedo, real NdotV, real NdotL, real NdotH, real LdotV, real roughness)
 {
-    real facing    = 0.5 + 0.5 * LdotV;              // (LdotH)^2
-    real rough     = facing * (0.9 - 0.4 * facing) * (0.5 / NdotH + 1);
+    real facing = 0.5 + 0.5 * LdotV;              // (LdotH)^2
+    real rough = facing * (0.9 - 0.4 * facing) * (0.5 / NdotH + 1);
-    real smooth    = transmitL * transmitV * 1.05;   // Normalize F_t over the hemisphere
-    real single    = lerp(smooth, rough, roughness); // Rescaled by PI
-    real multiple  = roughness * (0.1159 * PI);      // Rescaled by PI
+    real smooth = transmitL * transmitV * 1.05;   // Normalize F_t over the hemisphere
+    real single = lerp(smooth, rough, roughness); // Rescaled by PI
+    real multiple = roughness * (0.1159 * PI);      // Rescaled by PI
 
     return single + albedo * multiple;
 }
     // Note that we could save 2 cycles by inlining the multiplication by INV_PI.
     return INV_PI * DiffuseGGXNoPI(albedo, NdotV, NdotL, NdotH, LdotV, roughness);
 }
-
-//-----------------------------------------------------------------------------
-// Conversion FO/IOR
-//-----------------------------------------------------------------------------
-
-// ior is a value between 1.0 and 3.0. 1.0 is air interface
-real IorToFresnel0(real transmittedIor, real incidentIor = 1.0)
-{
-    return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
-}
-
-// Assume air interface for top
-// Note: Don't handle the case fresnel0 == 1
-real Fresnel0ToIor(real fresnel0)
-{
-    real sqrtF0 = sqrt(fresnel0);
-    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
-}
-
-// This function is a coarse approximation of computing fresnel0 for a different top than air (here clear coat of IOR 1.5) when we only have fresnel0 with air interface
-// This function is equivalent to IorToFresnel0(Fresnel0ToIor(fresnel0), 1.5)
-// mean
-// real sqrtF0 = sqrt(fresnel0);
-// return Sq(1.0 - 5.0 * sqrtF0) / Sq(5.0 - sqrtF0);
-// Optimization: Fit of the function (3 mad) for range [0.04 (should return 0), 1 (should return 1)]
-TEMPLATE_1_REAL(ConvertF0ForAirInterfaceToF0ForClearCoat15, fresnel0, return saturate(-0.0256868 + fresnel0 * (0.326846 + (0.978946 - 0.283835 * fresnel0) * fresnel0)))
 
 //-----------------------------------------------------------------------------
 // Iridescence

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs

         public float weight;
         public float multiplier;
 
-        public Vector3 sampleDirectionDiscardWS;
         // Sampling properties
         public int envIndex;
     };

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs.hlsl

     float3 boxSideFadeNegative;
     float weight;
     float multiplier;
-    float3 sampleDirectionDiscardWS;
     int envIndex;
 };
 
 float GetMultiplier(EnvLightData value)
 {
 	return value.multiplier;
-}
-float3 GetSampleDirectionDiscardWS(EnvLightData value)
-{
-	return value.sampleDirectionDiscardWS;
 }
 int GetEnvIndex(EnvLightData value)
 {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

             var capturePosition = Vector3.zero;
             var influenceToWorld = probe.influenceToWorld;
 
-            var sampleDirectionDiscardWS = Vector3.zero;
-
             // 31 bits index, 1 bit cache type
             var envIndex = -1;
             if (probe.planarReflectionProbe != null)
                 // We transform it to object space by translating the capturePosition
                 var vp = gpuProj * gpuView * Matrix4x4.Translate(capturePosition);
                 m_Env2DCaptureVP[fetchIndex] = vp;
-                sampleDirectionDiscardWS = captureRotation * Vector3.forward;
             }
             else if (probe.reflectionProbe != null)
             {
             envLightData.blendDistanceNegative = probe.blendDistanceNegative;
             envLightData.boxSideFadePositive = probe.boxSideFadePositive;
             envLightData.boxSideFadeNegative = probe.boxSideFadeNegative;
-            envLightData.sampleDirectionDiscardWS = sampleDirectionDiscardWS;
 
             envLightData.influenceRight = influenceToWorld.GetColumn(0).normalized;
             envLightData.influenceUp = influenceToWorld.GetColumn(1).normalized;
                     m_lightList.bounds.AddRange(m_lightList.rightEyeBounds);
                     m_lightList.lightVolumes.AddRange(m_lightList.rightEyeLightVolumes);
                 }
-                
+
                 UpdateDataBuffers();
 
                 return m_enableBakeShadowMask;
                 // XRTODO: If possible, we could generate a non-oblique stereo projection
                 // matrix.  It's ok if it's not the exact same matrix, as long as it encompasses
                 // the same FOV as the original projection matrix (which would mean padding each half
-                // of the frustum with the max half-angle). We don't need the light information in 
+                // of the frustum with the max half-angle). We don't need the light information in
                 // real projection space.  We just use screen space to figure out what is proximal
                 // to a cluster or tile.
                 // Once we generate this non-oblique projection matrix, it can be shared across both eyes (un-array)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

     float roughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness);
     R = lerp(R, preLightData.iblR, saturate(smoothstep(0, 1, roughness * roughness)));
 
-    float3 sampleDirectionDiscardWS = lightData.sampleDirectionDiscardWS;
-    if (dot(sampleDirectionDiscardWS, R) < 0) // Use by planar reflection to early reject opposite plan reflection, neutral for reflection probe
-        return lighting;
-
     float3 F = preLightData.specularFGD;
     float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.hlsl

 //#include "../SubsurfaceScattering/SubsurfaceScattering.hlsl"
 //#include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
 
-//NEWLITTODO : wireup CBUFFERs for ambientocclusion, and other uniforms and samplers used: 
+//NEWLITTODO : wireup CBUFFERs for ambientocclusion, and other uniforms and samplers used:
 //
 // We need this for AO, Depth/Color pyramids, LTC lights data, FGD pre-integrated data.
 //
 
 // This function is similar to ApplyDebugToSurfaceData but for BSDFData
 //
-// NOTE: 
+// NOTE:
-// This will be available and used in ShaderPassForward.hlsl since in StackLit.shader, 
-// just before including the core code of the pass (ShaderPassForward.hlsl) we include 
-// Material.hlsl (or Lighting.hlsl which includes it) which in turn includes us, 
+// This will be available and used in ShaderPassForward.hlsl since in StackLit.shader,
+// just before including the core code of the pass (ShaderPassForward.hlsl) we include
+// Material.hlsl (or Lighting.hlsl which includes it) which in turn includes us,
 // StackLit.shader, via the #if defined(UNITY_MATERIAL_*) glue mechanism.
 //
 void ApplyDebugToBSDFData(inout BSDFData bsdfData)
     // this can be use also in case of debug lighting mode like specular only
-    
+
     //NEWLITTODO
     //bool overrideSpecularColor = _DebugLightingSpecularColor.x != 0.0;
 
 
 
 //-----------------------------------------------------------------------------
-// PreLightData 
-// 
+// PreLightData
+//
 // Make sure we respect naming conventions to reuse ShaderPassForward as is,
 // ie struct (even if opaque to the ShaderPassForward) name is PreLightData,
 // GetPreLightData prototype.
 
     float NdotV = ClampNdotV(preLightData.NdotV);
 
-    float3 iblN[2], iblR[2]; 
+    float3 iblN[2], iblR[2];
     // We will need two hacked N for the stretch anisotropic hack later.
     // (Could use a UNITY_UNROLL loop, but not much code to dupe)
 
 
     // Note: that this also assumes all specular comes from GGX BSDFs.
     // (That's the FGD we use above to get integral[BSDF/F (N.w) dw] )
-    // In our case, since this compensation term is already an average 
-    // applied to a sum (akin to a "split sum" approximation) we will 
+    // In our case, since this compensation term is already an average
+    // applied to a sum (akin to a "split sum" approximation) we will
     // just lerp our two "specularReflectivities"
     preLightData.energyCompensation = 1.0 / lerp(specularReflectivity[0], specularReflectivity[1], bsdfData.lobeMix) - 1.0;
 #else
     float  NdotL = dot(N, L);
     //float  LdotV = dot(L, V);
 
-    // color and attenuation are outputted  by EvaluateLight: 
+    // color and attenuation are outputted  by EvaluateLight:
     float3 color;
     float attenuation;
     EvaluateLight_Directional(lightLoopContext, posInput, lightData, bakeLightingData, N, L, color, attenuation);
     return lighting;
 }
 
-// NEWLITTODO: For a refence rendering option for area light, like LIT_DISPLAY_REFERENCE_AREA option in eg EvaluateBSDF_<area light type> : 
+// NEWLITTODO: For a refence rendering option for area light, like LIT_DISPLAY_REFERENCE_AREA option in eg EvaluateBSDF_<area light type> :
 //#include "LitReference.hlsl"
 
 //-----------------------------------------------------------------------------
     // Steps are:
 
     // -Calculate influence weights from intersection with the proxies.
-    // Since the weights are influence blending weights, we can correctly 
+    // Since the weights are influence blending weights, we can correctly
-    // -Fetch 2 samples of preintegrated environment lighting 
+    // -Fetch 2 samples of preintegrated environment lighting
-    // -Use the 2 BSDF preintegration terms we pre-fetched in preLightData 
+    // -Use the 2 BSDF preintegration terms we pre-fetched in preLightData
-    // -Multiply the two split sum terms together for each lobe 
+    // -Multiply the two split sum terms together for each lobe
     // and linearly combine the results.
 
     // Note: using influenceShapeType and projectionShapeType instead of (lightData|proxyData).shapeType allow to make compiler optimization in case the type is know (like for sky)
     weight = lerp(tempWeight[0], tempWeight[1], bsdfData.lobeMix);
 
-    // TODO: reflections + coating 
+    // TODO: reflections + coating
 
     // When we are rough, we tend to see outward shifting of the reflection when at the boundary of the projection volume
     // Also it appear like more sharp. To avoid these artifact and at the same time get better match to reference we lerp to original unmodified reflection.
     roughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness[1]);
     R[1] = lerp(R[1], preLightData.iblR[1], saturate(smoothstep(0, 1, roughness * roughness)));
 
-    float3 sampleDirectionDiscardWS = lightData.sampleDirectionDiscardWS;
-    // Use by planar reflection to early reject opposite plan reflection, neutral for reflection probe
-    if ( (dot(sampleDirectionDiscardWS, R[0]) < 0) && (dot(sampleDirectionDiscardWS, R[1]) < 0))
-        return lighting;
-
-    float4 preLD[2]; 
+    float4 preLD[2];
 
     float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness[0]);
     preLD[0] = SampleEnv(lightLoopContext, lightData.envIndex, R[0], iblMipLevel);
     specularLighting = lighting.direct.specular + lighting.indirect.specularReflected;
     // Apply the fudge factor (boost) to compensate for multiple scattering not accounted for in BSDF.
     // This assumes all spec comes from a GGX BSDF.
-    // Note: The multiply with fresnel0 is to apply it only for metallic 
+    // Note: The multiply with fresnel0 is to apply it only for metallic
     specularLighting *= 1.0 + bsdfData.fresnel0 * preLightData.energyCompensation;
 
 #ifdef DEBUG_DISPLAY