HDRenderPipeline: Fix-point-light-shadow

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs

         // Include scale and bias for shadow atlas if any
         public Matrix4x4 worldToShadow;
 
-        public GPULightType lightType;
+        public float unused2;
         public Vector4 invResolution;
     };
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

 struct ShadowData
 {
 	float4x4 worldToShadow;
-	int lightType;
+	float unused2;
 	float4 invResolution;
 };
 
 {
 	return value.worldToShadow;
 }
-int GetLightType(ShadowData value)
-{
-	return value.lightType;
-}
 float GetBias(ShadowData value)
 {
 	return value.bias;
 float GetUnused(ShadowData value)
 {
 	return value.unused;
+}
+float GetUnused2(ShadowData value)
+{
+	return value.unused2;
 }
 float4 GetInvResolution(ShadowData value)
 {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 // Shadow sampling function
 // ----------------------------------------------------------------------------
 
-float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
+float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, uint lightType, float3 positionWS, int index, float3 L, float2 unPositionSS)
-    if (_ShadowDatas[index].lightType == GPULIGHTTYPE_POINT)
+    if (lightType == GPULIGHTTYPE_POINT)
     {
         GetCubeFaceID(L, faceIndex);
     }

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.hlsl

     float3 specularFGD; // Store preconvole BRDF for both specular and diffuse
     float diffuseFGD;
 
-    // TODO: if we want we can store ambient occlusion here from SSAO pass for example that can be use for IBL specular occlusion
-    // float ambientOcclusion; // Feed from an ambient occlusion buffer
-
     // area light
     float3x3 ltcXformGGX;                // TODO: make sure the compiler not wasting VGPRs on constants
     float3x3 ltcXformDisneyDiffuse;      // TODO: make sure the compiler not wasting VGPRs on constants
-
-    // Shadow (sampling rotation disc)
-    float2 unPositionSS;
 };
 
 PreLightData GetPreLightData(float3 V, PositionInputs posInput, BSDFData bsdfData)
     float3 iblR = reflect(-V, iblNormalWS);
     preLightData.iblDirWS = GetSpecularDominantDir(bsdfData.normalWS, iblR, bsdfData.roughness);
 
-    // #if SHADERPASS == SHADERPASS_GBUFFER
-    // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, posInput.unPositionSS).x;
-    // #endif
-
     // Area light specific
     // UVs for sampling the LUTs
     float theta = FastACos(dot(bsdfData.normalWS, V));
     preLightData.ltcGGXFresnelMagnitude     = ltcMagnitude.g;
     preLightData.ltcDisneyDiffuseMagnitude  = ltcMagnitude.b;
 
-    // Shadow
-    preLightData.unPositionSS = posInput.unPositionSS;
-
     return preLightData;
 }
 
 
     [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
     {
-        float shadowAttenuation = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, preLightData.unPositionSS);
+        float shadowAttenuation = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
 
         illuminance *= shadowAttenuation;
     }
 
     // TODO: measure impact of having all these dynamic branch here and the gain (or not) of testing illuminace > 0
 
+    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
+    {
+        float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
+        float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
+        illuminance *= SampleIES(lightLoopContext, lightData.IESIndex, sphericalCoord, 0).r;
+    }
+
+    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+    {
+        float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
+        float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadowAttenuation = lerp(1.0, shadowAttenuation, lightData.shadowDimmer);
+
+        illuminance *= shadowAttenuation;
+    }
+
     [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
     {
         float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
 
         cookieColor  = cookie.rgb;
         illuminance *= cookie.a;
-    }
-
-    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
-    {
-        float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
-        float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
-        illuminance *= SampleIES(lightLoopContext, lightData.IESIndex, sphericalCoord, 0).r;
-    }
-
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-    {
-        float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
-        float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, positionWS + offset, lightData.shadowIndex, L, preLightData.unPositionSS);
-        shadowAttenuation = lerp(1.0, shadowAttenuation, lightData.shadowDimmer);
-
-        illuminance *= shadowAttenuation;
     }
 
     [branch] if (illuminance > 0.0)

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

     float4 t = a; a = b; b = t;
 }
 
+#define CUBEMAPFACE_POSITIVE_X 0
+#define CUBEMAPFACE_NEGATIVE_X 1
+#define CUBEMAPFACE_POSITIVE_Y 2
+#define CUBEMAPFACE_NEGATIVE_Y 3
+#define CUBEMAPFACE_POSITIVE_Z 4
+#define CUBEMAPFACE_NEGATIVE_Z 5
+
 #ifndef INTRINSIC_CUBEMAP_FACE_ID
 // TODO: implement this. Is the reference implementation of cubemapID provide by AMD the reverse of our ?
 /*
     return faceID;
 }
 */
-#endif // INTRINSIC_CUBEMAP_FACE_ID
-
-#define CUBEMAPFACE_POSITIVE_X 0
-#define CUBEMAPFACE_NEGATIVE_X 1
-#define CUBEMAPFACE_POSITIVE_Y 2
-#define CUBEMAPFACE_NEGATIVE_Y 3
-#define CUBEMAPFACE_POSITIVE_Z 4
-#define CUBEMAPFACE_NEGATIVE_Z 5
 
 void GetCubeFaceID(float3 dir, out int faceIndex)
 {
         faceIndex = dir.y > 0.0 ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
     }
 }
+
+#endif // INTRINSIC_CUBEMAP_FACE_ID
 
 // ----------------------------------------------------------------------------
 // Common math definition and fastmath function
 // World position reconstruction / transformation
 // ----------------------------------------------------------------------------
 
-// Z buffer to linear 0..1 depth
+// Z buffer to linear 0..1 depth (0 at near plane, 1 at far plane)
+float Linear01DepthFromNear(float depth, float4 zBufferParam)
+{
+    return 1.0 / (zBufferParam.x + zBufferParam.y / depth);
+}
+
+// Z buffer to linear 0..1 depth (0 at camera position, 1 at far plane)
 float Linear01Depth(float depth, float4 zBufferParam)
 {
     return 1.0 / (zBufferParam.x * depth + zBufferParam.y);

Assets/ScriptableRenderLoop/ShaderLibrary/ImageBasedLighting.hlsl

 // Ref: Listing 18 in "Moving Frostbite to PBR" + https://knarkowicz.wordpress.com/2014/12/27/analytical-dfg-term-for-ibl/
 float4 IntegrateGGXAndDisneyFGD(float3 V, float3 N, float roughness, uint sampleCount)
 {
-    float NdotV     = GetShiftedNdotV(N, V, false);
+    float NdotV     = GetShiftedNdotV(N, V, false); // This fix some rare artifact at edge.
     float4 acc      = float4(0.0, 0.0, 0.0, 0.0);
     // Add some jittering on Hammersley2d
     float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);