Merge branch 'master' into LighweightPipelineXR

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

                     float texelSizeX = 1.0f, texelSizeY = 1.0f;
                     CachedEntry ce = m_EntryCache[ceIdx];
                     // modify
-                    Matrix4x4 vp;
+                    Matrix4x4 vp, invvp;
-                        vp = ShadowUtils.ExtractPointLightMatrix( lights[sr.index], key.faceIdx, 2.0f, out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData );
+                        vp = ShadowUtils.ExtractPointLightMatrix( lights[sr.index], key.faceIdx, 2.0f, out ce.current.view, out ce.current.proj, out invvp, out ce.current.lightDir, out ce.current.splitData );
-                        vp = ShadowUtils.ExtractSpotLightMatrix( lights[sr.index], out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData );
+                        vp = ShadowUtils.ExtractSpotLightMatrix( lights[sr.index], out ce.current.view, out ce.current.proj, out invvp, out ce.current.lightDir, out ce.current.splitData );
-                        vp = ShadowUtils.ExtractDirectionalLightMatrix( lights[sr.index], key.faceIdx, cascadeCnt, cascadeRatios, nearPlaneOffset, width, height, out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData, m_CullResults, (int) sr.index );
+                        vp = ShadowUtils.ExtractDirectionalLightMatrix( lights[sr.index], key.faceIdx, cascadeCnt, cascadeRatios, nearPlaneOffset, width, height, out ce.current.view, out ce.current.proj, out invvp, out ce.current.lightDir, out ce.current.splitData, m_CullResults, (int) sr.index );
                         m_TmpSplits[key.faceIdx]    = ce.current.splitData.cullingSphere;
                         if( ce.current.splitData.cullingSphere.w != float.NegativeInfinity )
                         {
                         }
                     }
                     else
-                        vp = Matrix4x4.identity; // should never happen, though
+                        vp = invvp = Matrix4x4.identity; // should never happen, though
                     if (cameraRelativeRendering)
                     {
                         Vector3 camPosWS = camera.transform.position;
                     m_EntryCache[ceIdx] = ce;
 
                     sd.worldToShadow = vp.transpose; // apparently we need to transpose matrices that are sent to HLSL
+                    sd.shadowToWorld = invvp.transpose;
+                    sd.textureSize   = new Vector4( m_Width, m_Height, ce.current.viewport.width, ce.current.viewport.height );
                     sd.texelSizeRcp  = new Vector4( m_WidthRcp, m_HeightRcp, 1.0f / ce.current.viewport.width, 1.0f / ce.current.viewport.height );
                     sd.PackShadowmapId( m_TexSlot, m_SampSlot, ce.current.slice );
                     sd.PackShadowType( sr.shadowType, sanitizedAlgo );

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs

     {
         // shadow texture related params (need to be set by ShadowmapBase and derivatives)
         public Matrix4x4     worldToShadow;  // to light space matrix
+        public Matrix4x4     shadowToWorld;  // from light space matrix
+        public Vector4       textureSize;    // the shadowmap's size in x and y. xy is texture relative, zw is viewport relative.
         public Vector4       texelSizeRcp;   // reciprocal of the shadowmap's texel size in x and y. xy is texture relative, zw is viewport relative.
         public uint          id;             // packed texture id, sampler id and slice idx
         public uint          shadowType;     // determines the shadow algorithm, i.e. which map to sample and how to interpret the data

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderPipeline/core/Shadow/ShadowBase.cs.  Please don't edit by hand.
 //
 
 #ifndef SHADOWBASE_CS_HLSL
 struct ShadowData
 {
     float4x4 worldToShadow;
+    float4x4 shadowToWorld;
+    float4 textureSize;
     float4 texelSizeRcp;
     uint id;
     uint shadowType;
 {
 	return value.worldToShadow;
 }
+float4x4 GetShadowToWorld(ShadowData value)
+{
+	return value.shadowToWorld;
+}
+}
+float4 GetTextureSize(ShadowData value)
+{
+	return value.textureSize;
 }
 float4 GetTexelSizeRcp(ShadowData value)
 {

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowUtilities.cs

     }
     public class ShadowUtils
     {
-        public static Matrix4x4 ExtractSpotLightMatrix( VisibleLight vl, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData )
+        public static void InvertView( ref Matrix4x4 view, out Matrix4x4 invview )
+        {
+            invview = Matrix4x4.zero;
+            invview.m00 = view.m00; invview.m01 = view.m10; invview.m02 = view.m20;
+            invview.m10 = view.m01; invview.m11 = view.m11; invview.m12 = view.m21;
+            invview.m20 = view.m02; invview.m21 = view.m12; invview.m22 = view.m22;
+            invview.m33 = 1.0f;
+            invview.m03 = -(invview.m00 * view.m03 + invview.m01 * view.m13 + invview.m02 * view.m23);
+            invview.m13 = -(invview.m10 * view.m03 + invview.m11 * view.m13 + invview.m12 * view.m23);
+            invview.m23 = -(invview.m20 * view.m03 + invview.m21 * view.m13 + invview.m22 * view.m23);
+        }
+
+        public static void InvertOrthographic( ref Matrix4x4 proj, ref Matrix4x4 view, out Matrix4x4 vpinv )
+        {
+            Matrix4x4 invview;
+            InvertView( ref view, out invview );
+
+            Matrix4x4 invproj = Matrix4x4.zero;
+            invproj.m00 = 1.0f / proj.m00;
+            invproj.m11 = 1.0f / proj.m11;
+            invproj.m22 = 1.0f / proj.m22;
+            invproj.m33 = 1.0f;
+            invproj.m03 =   proj.m03 * invproj.m00;
+            invproj.m13 =   proj.m13 * invproj.m11;
+            invproj.m23 = - proj.m23 * invproj.m22;
+
+            vpinv = invview * invproj;
+        }
+
+        public static void InvertPerspective( ref Matrix4x4 proj, ref Matrix4x4 view, out Matrix4x4 vpinv )
+        {
+            Matrix4x4 invview;
+            InvertView(ref view, out invview);
+
+            Matrix4x4 invproj = Matrix4x4.zero;
+            invproj.m00 = 1.0f / proj.m00;
+            invproj.m03 = proj.m02 * invproj.m00;
+            invproj.m11 = 1.0f / proj.m11;
+            invproj.m13 = proj.m12 * invproj.m11;
+            invproj.m22 = 0.0f;
+            invproj.m23 = -1.0f;
+            invproj.m33 = proj.m22 / proj.m23;
+            invproj.m32 = invproj.m33 / proj.m22;
+
+            vpinv = invview * invproj;
+        }
+
+        public static Matrix4x4 ExtractSpotLightMatrix( VisibleLight vl, out Matrix4x4 view, out Matrix4x4 proj, out Matrix4x4 vpinverse, out Vector4 lightDir, out ShadowSplitData splitData )
         {
             splitData = new ShadowSplitData();
             splitData.cullingSphere.Set( 0.0f, 0.0f, 0.0f, float.NegativeInfinity );
             float fov = vl.spotAngle;
             proj = Matrix4x4.Perspective(fov, 1.0f, znear, zfar);
             // and the compound
+            InvertPerspective( ref proj, ref view, out vpinverse );
-        public static Matrix4x4 ExtractPointLightMatrix( VisibleLight vl, uint faceIdx, float fovBias, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData )
+        public static Matrix4x4 ExtractPointLightMatrix( VisibleLight vl, uint faceIdx, float fovBias, out Matrix4x4 view, out Matrix4x4 proj, out Matrix4x4 vpinverse, out Vector4 lightDir, out ShadowSplitData splitData )
         {
             Debug.Assert( faceIdx <= (uint) CubemapFace.NegativeZ, "Tried to extract cubemap face " + faceIdx + "." );
 
             float nearPlane = vl.light.shadowNearPlane >= nearmin ? vl.light.shadowNearPlane : nearmin;
             proj = Matrix4x4.Perspective( 90.0f + fovBias, 1.0f, nearPlane, farPlane );
             // and the compound
+            InvertPerspective( ref proj, ref view, out vpinverse );
-        public static Matrix4x4 ExtractDirectionalLightMatrix( VisibleLight vl, uint cascadeIdx, int cascadeCount, float[] splitRatio, float nearPlaneOffset, uint width, uint height, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData, CullResults cullResults, int lightIndex )
+        public static Matrix4x4 ExtractDirectionalLightMatrix( VisibleLight vl, uint cascadeIdx, int cascadeCount, float[] splitRatio, float nearPlaneOffset, uint width, uint height, out Matrix4x4 view, out Matrix4x4 proj, out Matrix4x4 vpinverse, out Vector4 lightDir, out ShadowSplitData splitData, CullResults cullResults, int lightIndex )
         {
             Debug.Assert( width == height, "Currently the cascaded shadow mapping code requires square cascades." );
             splitData = new ShadowSplitData();
                 ratios[i] = splitRatio[i];
             cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives( lightIndex, (int) cascadeIdx, cascadeCount, ratios, (int) width, nearPlaneOffset, out view, out proj, out splitData );
             // and the compound
+            InvertOrthographic( ref proj, ref view, out vpinverse );
             return proj * view;
         }
 

Assets/ScriptableRenderPipeline/Fptl/ShadowDispatch.hlsl

 	SamplerComparisonState	compSamp = shadowContext.compSamplers[0];
 	uint					algo     = GPUSHADOWALGORITHM_PCF_9TAP;
 
-	return EvalShadow_CascadedDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_CascadedDepth_Blend( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 }
 
 float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/ShadowDispatch.hlsl

 	SamplerComparisonState	compSamp = shadowContext.compSamplers[SHADOW_DISPATCH_DIR_SMP];
 	uint			        algo     = SHADOW_DISPATCH_DIR_ALG;
 
-	return EvalShadow_CascadedDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_CascadedDepth_Blend( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 }
 
 float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

 
                     for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Count; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
                     {
-                        var probe = cullResults.visibleReflectionProbes[probeIndex];
+                        VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
 
                         // probe.texture can be null when we are adding a reflection probe in the editor
                         if (probe.texture == null || envLightCount >= k_MaxEnvLightsOnScreen)
                         LightVolumeType lightVolumeType = probe.boxProjection != 0 ? LightVolumeType.Box : LightVolumeType.Box;
                         ++envLightCount;
 
-                        // 16 bit lightVolume, 16 bit index
-                        sortKeys[sortCount++] = (uint)lightVolumeType << 16 | (uint)probeIndex;
+                        float boxVolume = 8 * probe.bounds.extents.x * probe.bounds.extents.y * probe.bounds.extents.z;
+                        float logVolume = Mathf.Clamp(256 + Mathf.Log(boxVolume, 1.1f), 0, 8191); // Allow for negative exponents
+
+                        // 13 bit volume, 3 bit LightVolumeType, 16 bit index
+                        sortKeys[sortCount++] = (uint)logVolume << 19 | (uint)lightVolumeType << 16 | ((uint)probeIndex & 0xFFFF); // Sort by volume
                     }
 
                     // Not necessary yet but call it for future modification with sphere influence volume
                     {
                         // In 1. we have already classify and sorted the light, we need to use this sorted order here
                         uint sortKey = sortKeys[sortIndex];
-                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0xFFFF);
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3);
                         int probeIndex = (int)(sortKey & 0xFFFF);
 
                         VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

         #endif
     }
 
-    float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
+    float3 iblDiffuseLighting  = float3(0.0, 0.0, 0.0);
-
-    // TODO: Check the reflection hierarchy, for the current system (matching legacy unity) we must sort from bigger solid angle to lower (lower override bigger). So begging by sky
-    // TODO: Change the way it is done by reversing the order, from smaller solid angle to bigger, so we can early out when the weight is 1.
-    // Only apply sky IBL if the sky texture is available.
-    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
-    {
-        if(_EnvLightSkyEnabled)
-        {
-            float3 localDiffuseLighting, localSpecularLighting;
-            float2 weight;
-            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
-            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-            iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
-            iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
-        }
-    }
+    float  totalIblWeight      = 0; // Max: 1
+    // Reflection probes are sorted by volume (in the increasing order).
-        #ifdef LIGHTLOOP_TILE_PASS
-
+    #ifdef LIGHTLOOP_TILE_PASS
+    #else
+        uint envLightCount = _EnvLightCount;
+    #endif
-        for(i = 0; i < envLightCount; ++i)
+        for(i = 0; i < envLightCount && totalIblWeight < 1.0; ++i)
+        #ifdef LIGHTLOOP_TILE_PASS
+            uint envLightIndex = FetchIndex(envLightStart, i);
+        #else
+            uint envLightIndex = i;
+        #endif
+
-            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[FetchIndex(envLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[envLightIndex], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // IBL weights should not exceed 1.
+            float accumulatedWeight = totalIblWeight + weight.y;
+            totalIblWeight          = saturate(accumulatedWeight);
+            weight.y               -= saturate(accumulatedWeight - totalIblWeight);
+
-
-        #else
+    }
-        for (i = 0; i < _EnvLightCount; ++i)
+    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
+    {
+        // Only apply the sky IBL if the sky texture is available, and if we haven't yet accumulated enough IBL lighting.
+        if(_EnvLightSkyEnabled && totalIblWeight < 1.0)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[i], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // IBL weights should not exceed 1.
+            float accumulatedWeight = totalIblWeight + weight.y;
+            totalIblWeight          = 1.0;
+            weight.y               -= saturate(accumulatedWeight - totalIblWeight);
+
-
-        #endif
     }
 
     // Apply ambient occlusion on direct lighting based on strenght factor

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

             // Clear RenderTarget to avoid tile initialization on mobile GPUs
             // https://community.arm.com/graphics/b/blog/posts/mali-performance-2-how-to-correctly-handle-framebuffers
             if (camera.clearFlags != CameraClearFlags.Nothing)
-                cmd.ClearRenderTarget(camera.clearFlags == CameraClearFlags.Color, camera.clearFlags == CameraClearFlags.Color || camera.clearFlags == CameraClearFlags.Depth, camera.backgroundColor);
+            {
+                bool clearDepth = (camera.clearFlags != CameraClearFlags.Nothing);
+                bool clearColor = (camera.clearFlags == CameraClearFlags.Color);
+                cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
+
+            }
 
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/Shadow.hlsl

 // directional light shadows
 float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
 {
-	return EvalShadow_CascadedDepth( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_CascadedDepth_Blend( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
 float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
 {

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 	return EvalShadow_GetTexcoords( sd, positionWS, ndc, false );
 }
 
+uint2 EvalShadow_GetTexcoords( ShadowData sd, float3 positionWS, out float2 closestSampleNDC )
+{
+	float4 posCS = mul( float4( positionWS, 1.0 ), sd.worldToShadow );
+	float2 posNDC = posCS.xy / posCS.w;
+	// calc TCs
+	float2 posTC = posNDC * 0.5 + 0.5;
+	closestSampleNDC = (floor(posTC * sd.textureSize.zw) + 0.5) * sd.texelSizeRcp.zw * 2.0 - 1.0.xx;
+	return (posTC * sd.scaleOffset.xy + sd.scaleOffset.zw) * sd.textureSize.xy;
+}
+
 int EvalShadow_GetCubeFaceID( float3 dir )
 {
 	// TODO: Use faceID intrinsic on console
 	float slice;
 	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
 	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
-	return SampleShadow_SelectAlgorithm(shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx);
+	return SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
 }
 
 #define EvalShadow_PunctualDepth_( _samplerType )																																		\
 	return offset + 4;
 }
 
-float EvalShadow_CascadedDepth( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
+float EvalShadow_CascadedDepth_Blend( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
 {
 	// load the right shadow data for the current face
 	float4 dirShadowSplitSpheres[4];
 	return shadow;
 }
 
+#define EvalShadow_CascadedDepth_( _samplerType ) 																																		        \
+	float EvalShadow_CascadedDepth_Blend( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L )   \
+	{																																													        \
+		/* load the right shadow data for the current face */																															        \
+		float4 dirShadowSplitSpheres[kMaxShadowCascades];																																        \
+		uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );																				        \
+		float relDistance;                                                                                                                                                                      \
+		int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );															        \
+		if( shadowSplitIndex < 0 )                                                                                                                                                              \
+			return 1.0;                                                                                                                                                                         \
+																																																\
+		float4 scales = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                       \
+		payloadOffset++;                                                                                                                                                                        \
+		float4 borders = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                      \
+		payloadOffset++;                                                                                                                                                                        \
+																																																\
+		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										        \
+		/* normal based bias */																																							        \
+		float3 orig_pos = positionWS;                                                                                                                                                           \
+		uint   orig_payloadOffset = payloadOffset;		                                                                                                                                        \
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );									        \
+		/* get shadowmap texcoords */																																					        \
+		float3 posNDC;                                                                                                                                                                          \
+		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );																											        \
+		/* sample the texture */																																						        \
+		float slice;																																									        \
+		UnpackShadowmapId( sd.id, slice );																																				        \
+																																																\
+		float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                                     \
+																																																\
+		float border = borders[shadowSplitIndex];                                                                                                                                               \
+		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                               \
+																																																\
+		shadowSplitIndex++;                                                                                                                                                                     \
+		float shadow1 = 1.0;                                                                                                                                                                    \
+		if( shadowSplitIndex < kMaxShadowCascades )                                                                                                                                             \
+		{                                                                                                                                                                                       \
+			float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex - 1];                                                                                                                   \
+			float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex].xyz );                                                                                   \
+			float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                                    \
+			float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                                    \
+			alpha   = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                                   \
+			shadow1 = shadow;                                                                                                                                                                   \
+																																																\
+			[branch]                                                                                                                                                                            \
+			if( alpha > 0.0 )                                                                                                                                                                   \
+			{                                                                                                                                                                                   \
+				sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										            \
+				positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );				        \
+				posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, false );																										        \
+				/* sample the texture */																																				        \
+				UnpackShadowmapId( sd.id, slice );																																		        \
+																																																\
+				if( all( abs( posNDC.xy ) <= (1.0 - sd.texelSizeRcp.zw * 0.5) ) )                                                                                                               \
+					shadow1 = SampleShadow_SelectAlgorithm( shadowContext, sd, orig_payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                         \
+			}                                                                                                                                                                                   \
+		}                                                                                                                                                                                       \
+		shadow = lerp( shadow, shadow1, alpha );                                                                                                                                                \
+		return shadow;                                                                                                                                                                          \
+	}
+	EvalShadow_CascadedDepth_( SamplerComparisonState )
+	EvalShadow_CascadedDepth_( SamplerState )
+#undef EvalShadow_CascadedDepth_
+
+
+float EvalShadow_hash12( float2 pos )
+{
+	float3 p3  = frac( pos.xyx * float3( 443.8975, 397.2973, 491.1871 ) );
+		   p3 += dot( p3, p3.yzx + 19.19 );
+	return frac( (p3.x + p3.y) * p3.z );
+}
+
+float EvalShadow_CascadedDepth_Dither( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
+{
+	// load the right shadow data for the current face
+	float4 dirShadowSplitSpheres[4];
+	uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );
+	float relDistance;
+	int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );
+	if( shadowSplitIndex < 0 )
+		return 1.0;
+
+	float4 scales = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float4 borders = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float border = borders[shadowSplitIndex];
+	float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );
-#define EvalShadow_CascadedDepth_( _samplerType ) 																																		\
-	float EvalShadow_CascadedDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L ) \
-	{																																													\
-		/* load the right shadow data for the current face */																															\
-		float4 dirShadowSplitSpheres[kMaxShadowCascades];																																\
-		uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );																				\
-		float relDistance;                                                                                                                                                              \
-		int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );															\
-		if( shadowSplitIndex < 0 )                                                                                                                                                      \
-			return 1.0;                                                                                                                                                                 \
-																																														\
-		float4 scales = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                               \
-		payloadOffset++;                                                                                                                                                                \
-		float4 borders = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                              \
-		payloadOffset++;                                                                                                                                                                \
-																																														\
-		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										\
-		/* normal based bias */																																							\
-		float3 orig_pos = positionWS;                                                                                                                                                   \
-		uint orig_payloadOffset = payloadOffset;		                                                                                                                                \
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );									\
-		/* get shadowmap texcoords */																																					\
-		float3 posNDC;                                                                                                                                                                  \
-		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );																											\
-		/* sample the texture */																																						\
-		float slice;																																									\
-		UnpackShadowmapId( sd.id, slice );																																				\
-																																														\
-		float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                             \
-																																														\
-		float border = borders[shadowSplitIndex];                                                                                                                                       \
-		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                       \
-																																														\
-		shadowSplitIndex++;                                                                                                                                                             \
-		float shadow1 = 1.0;                                                                                                                                                            \
-		if( shadowSplitIndex < kMaxShadowCascades )                                                                                                                                     \
-		{                                                                                                                                                                               \
-			float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex - 1];                                                                                                           \
-			float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex].xyz );                                                                           \
-			float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                            \
-			float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                            \
-			alpha   = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                           \
-			shadow1 = shadow;                                                                                                                                                           \
-																																														\
-			[branch]                                                                                                                                                                    \
-			if( alpha > 0.0 )                                                                                                                                                           \
-			{                                                                                                                                                                           \
-				sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										    \
-				positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );				\
-				posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, false );																										\
-				/* sample the texture */																																				\
-				UnpackShadowmapId( sd.id, slice );																																		\
-																																														\
-				if( all( abs( posNDC.xy ) <= (1.0 - sd.texelSizeRcp.zw * 0.5) ) )                                                                                                       \
-					shadow1 = SampleShadow_SelectAlgorithm( shadowContext, sd, orig_payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                 \
-			}                                                                                                                                                                           \
-		}                                                                                                                                                                               \
-		shadow = lerp( shadow, shadow1, alpha );                                                                                                                                        \
-		return shadow;                                                                                                                                                                  \
+	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
+	// normal based bias
+	float3 orig_pos = positionWS;
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );
+	// get shadowmap texcoords
+	float3 posNDC;
+	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );
+
+	if( shadowSplitIndex < (kMaxShadowCascades-1) )
+	{
+		float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex];
+		float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex+1].xyz );
+		float3 wposDir     = normalize( -splitSphere.xyz + positionWS );
+		float  cascDot     = dot( cascadeDir, wposDir );
+		alpha = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );
+
+		if( step( EvalShadow_hash12( posTC.xy ), alpha ) )
+		{
+			shadowSplitIndex++;
+			sd         = shadowContext.shadowDatas[index + 2 + shadowSplitIndex];
+			positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex+1] * sd.texelSizeRcp.zw, sd.normalBias );
+			posTC      = EvalShadow_GetTexcoords( sd, positionWS );
+		}
+	}
+	// sample the texture
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+
+	uint shadowType, shadowAlgorithm;
+	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
+
+	float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
+	return shadowSplitIndex < (kMaxShadowCascades-1) ? shadow : lerp( shadow, 1.0, alpha );
+}
+
+#define EvalShadow_CascadedDepth_( _samplerType ) 																																		        \
+	float EvalShadow_CascadedDepth_Dither( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L )  \
+	{																																													        \
+		/* load the right shadow data for the current face */																															        \
+		float4 dirShadowSplitSpheres[kMaxShadowCascades];																																        \
+		uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );																				        \
+		float relDistance;                                                                                                                                                                      \
+		int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );															        \
+		if( shadowSplitIndex < 0 )                                                                                                                                                              \
+			return 1.0;                                                                                                                                                                         \
+																																																\
+		float4 scales = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                       \
+		payloadOffset++;                                                                                                                                                                        \
+		float4 borders = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                      \
+		payloadOffset++;                                                                                                                                                                        \
+		float border = borders[shadowSplitIndex];                                                                                                                                               \
+		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                               \
+																																																\
+		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										        \
+		/* normal based bias */																																							        \
+		float3 orig_pos = positionWS;                                                                                                                                                           \
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );									        \
+		/* get shadowmap texcoords */																																					        \
+		float3 posNDC;                                                                                                                                                                          \
+		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );																											        \
+																																																\
+		if( shadowSplitIndex < (kMaxShadowCascades-1) )                                                                                                                                         \
+		{                                                                                                                                                                                       \
+			float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex];                                                                                                                       \
+			float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex+1].xyz );                                                                                 \
+			float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                                    \
+			float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                                    \
+			alpha = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                                     \
+																																																\
+			if( step( EvalShadow_hash12( posTC.xy ), alpha ) )                                                                                                                                  \
+			{                                                                                                                                                                                   \
+				sd         = shadowContext.shadowDatas[index + 2 + shadowSplitIndex];                                                                                                           \
+				positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex+1] * sd.texelSizeRcp.zw, sd.normalBias );				        \
+				posTC      = EvalShadow_GetTexcoords( sd, positionWS );                                                                                                                         \
+			}                                                                                                                                                                                   \
+		}                                                                                                                                                                                       \
+		/* sample the texture */																																						        \
+		float  slice;																																									        \
+		UnpackShadowmapId( sd.id, slice );																																				        \
+		float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                                     \
+		return shadowSplitIndex < (kMaxShadowCascades-1) ? shadow : lerp( shadow, 1.0, alpha );                                                                                                 \
+
+
+//------------------------------------------------------------------------------------------------------------------------------------
+
+float3 EvalShadow_GetClosestSample_Point( ShadowContext shadowContext, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	// load the right shadow data for the current face
+	int faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+
+float3 EvalShadow_GetClosestSample_Point( ShadowContext shadowContext, Texture2DArray tex, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	// load the right shadow data for the current face
+	int faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	float slice;
+	UnpackShadowmapId(sd.id, slice);
+	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, slice, 0 ).x;
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Spot( ShadowContext shadowContext, float3 positionWS, int index )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+
+float3 EvalShadow_GetClosestSample_Spot( ShadowContext shadowContext, Texture2DArray tex, float3 positionWS, int index )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	float slice;
+	UnpackShadowmapId(sd.id, slice);
+	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, slice, 0 ).x;
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Punctual( ShadowContext shadowContext, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	uint shadowType;
+	UnpackShadowType( sd.shadowType, shadowType );
+	// load the right shadow data for the current face
+	int faceIndex = shadowType == GPUSHADOWTYPE_POINT ? (EvalShadow_GetCubeFaceID( L ) + 1) : 0;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Punctual( ShadowContext shadowContext, Texture2DArray tex, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	uint shadowType;
+	UnpackShadowType( sd.shadowType, shadowType );
+	// load the right shadow data for the current face
+	int faceIndex = shadowType == GPUSHADOWTYPE_POINT ? (EvalShadow_GetCubeFaceID( L ) + 1) : 0;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	float slice;
+	UnpackShadowmapId(sd.id, slice);
+	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, slice, 0 ).x;
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float4 L )
+{
+	// load the right shadow data for the current face
+	float4 dirShadowSplitSpheres[4];
+	uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );
+	float relDistance;
+	int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );
+	if( shadowSplitIndex < 0 )
+		return 1.0;
+
+	float4 scales = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float4 borders = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+
+	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowTexFetch.hlsl

 // Shader model >= 5.1
 #	define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots  , _SamplerCompSlots )	float4 SampleCompShadow_T2DA( ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float slice					)	{ return SAMPLE_TEXTURE2D_ARRAY_SHADOW( ctxt.tex2DArray[texIdx], ctxt.compSamplers[sampIdx], tcs, slice );		}
 #	define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots  , _SamplerSlots )		float4 SampleShadow_T2DA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float2 tcs, float slice, float lod = 0.0	)	{ return SAMPLE_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[texIdx], ctxt.samplers[sampIdx], tcs, slice, lod );		}
+#   define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots  )	                    float4 LoadShadow_T2DA(	      ShadowContext ctxt, uint texIdx,               uint2  tcs, uint  slice, uint lod = 0	    )   { return LOAD_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[texIdx], tcs, slice, lod ).x;                                }
 #	define SHADOW_DEFINE_SAMPLING_FUNC_TCA_COMP(  _TexCubeArraySlots, _SamplerCompSlots )	float4 SampleCompShadow_TCA(  ShadowContext ctxt, uint texIdx, uint sampIdx, float4 tcs, float cubeIdx					)	{ return SAMPLE_TEXTURECUBE_ARRAY_SHADOW( ctxt.texCubeArray[texIdx], ctxt.compSamplers[sampIdx], tcs, cubeIdx );}
 #	define SHADOW_DEFINE_SAMPLING_FUNC_TCA_SAMP(  _TexCubeArraySlots, _SamplerSlots )		float4 SampleShadow_TCA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float cubeIdx, float lod = 0.0 )	{ return SAMPLE_TEXTURECUBE_ARRAY_LOD( ctxt.texCubeArray[texIdx], ctxt.samplers[sampIdx], tcs, cubeIdx, lod );	}
 
 			return res;																											\
 		}
 
+#	define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots )												            \
+		float LoadShadow_T2DA( ShadowContext ctxt, uint texIdx, uint2 tcs, uint slice, uint lod = 0 )		                    \
+		{																														\
+			float res = 1.0;																								    \
+			[unroll] for( uint i = 0; i < _Tex2DArraySlots; i++ )																\
+			{																													\
+				[branch] if( i == texIdx )																	                    \
+				{																											    \
+					res = LOAD_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[i], tcs, slice, lod ).x;				                    \
+					break;																									    \
+				}																											    \
+			}																													\
+			return res;																											\
+		}
+
+
 #	define SHADOW_DEFINE_SAMPLING_FUNC_TCA_COMP( _TexCubeArraySlots, _SamplerCompSlots )										\
 		float4 SampleCompShadow_TCA( ShadowContext ctxt, uint texIdx, uint sampIdx, float4 tcs, float cubeIdx )					\
 		{																														\
 // helper macro to suppress code generation if _cnt is 0
 #define SHADOW_DECLARE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots  , _SamplerCompSlots )	float4 SampleCompShadow_T2DA( ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float slice					);
 #define SHADOW_DECLARE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots  , _SamplerSlots )		float4 SampleShadow_T2DA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float2 tcs, float slice, float lod = 0.0	);
+#define SHADOW_DECLARE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots  )	                    float4 LoadShadow_T2DA(	      ShadowContext ctxt, uint texIdx,               uint2  tcs, uint  slice, uint lod = 0	    );
 #define SHADOW_DECLARE_SAMPLING_FUNC_TCA_COMP(  _TexCubeArraySlots, _SamplerCompSlots )	float4 SampleCompShadow_TCA(  ShadowContext ctxt, uint texIdx, uint sampIdx, float4 tcs, float cubeIdx					);
 #define SHADOW_DECLARE_SAMPLING_FUNC_TCA_SAMP(  _TexCubeArraySlots, _SamplerSlots )		float4 SampleShadow_TCA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float cubeIdx, float lod = 0.0 );
 
 #define SHADOW_DEFINE_SAMPLING_FUNCS( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )	\
 	SHADOW_CHECK( _Tex2DArraySlots  , SHADOW_CHECK_ALT( _SamplerCompSlots, SHADOW_DEFINE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots, _SamplerCompSlots ), SHADOW_DECLARE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots, _SamplerCompSlots ) ) )	\
 	SHADOW_CHECK( _Tex2DArraySlots  , SHADOW_CHECK_ALT( _SamplerSlots    , SHADOW_DEFINE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots, _SamplerSlots     ), SHADOW_DECLARE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots, _SamplerSlots     ) ) )	\
+									  SHADOW_CHECK_ALT( _Tex2DArraySlots , SHADOW_DEFINE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots                    ), SHADOW_DECLARE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots                    ) )	\
 	SHADOW_CHECK( _TexCubeArraySlots, SHADOW_CHECK_ALT( _SamplerCompSlots, SHADOW_DEFINE_SAMPLING_FUNC_TCA_COMP(_TexCubeArraySlots, _SamplerCompSlots ), SHADOW_DECLARE_SAMPLING_FUNC_TCA_COMP(_TexCubeArraySlots, _SamplerCompSlots ) ) )	\
 	SHADOW_CHECK( _TexCubeArraySlots, SHADOW_CHECK_ALT( _SamplerSlots    , SHADOW_DEFINE_SAMPLING_FUNC_TCA_SAMP(_TexCubeArraySlots, _SamplerSlots     ), SHADOW_DECLARE_SAMPLING_FUNC_TCA_SAMP(_TexCubeArraySlots, _SamplerSlots     ) ) )