Re-factor Shadow.hlsl in core such that the user of the library is including things instead. This is required for package usage, as Core package cannot depend on anything outside itself.

ScriptableRenderPipeline/Core/ShaderLibrary/Shadow/Shadow.hlsl

 #ifndef SHADOW_HLSL
 #define SHADOW_HLSL
+
-// First ShadowContext.hlsl must declare the specific ShadowContext struct and the loader that goes along with it.
+// First ShadowContext.hlsl provides a macro SHADOWCONTEXT_DECLARE that must be used in order to define the specific ShadowContext struct and accompanying loader.
-// Second there are two headers for shadow algorithms, whose signatures must match any of the Get...Attenuation function prototypes.
-// The first header contains engine defaults, whereas the second header is empty by default. All project specific custom shadow algorithms should go in there or leave empty.
-//
-// Last there's a dispatcher include. By default the Get...Attenuation functions are rerouted to their default implementations. This can be overridden for each
-// shadow type in the dispatcher source. For each overridden shadow type a specific define must be defined to prevent falling back to the default functions.
-//
+/* Required defines: (define these to the desired numbers - must be in sync with loading and resource setup from C#)
+#define SHADOWCONTEXT_MAX_TEX2DARRAY   0
+#define SHADOWCONTEXT_MAX_TEXCUBEARRAY 0
+#define SHADOWCONTEXT_MAX_SAMPLER      0
+#define SHADOWCONTEXT_MAX_COMPSAMPLER  0
+*/
-#define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0 // only on >= sm 5.1
-#define SHADOW_OPTIMIZE_REGISTER_USAGE   0 // redefine this as 1 in your ShadowContext.hlsl to optimize for register usage over instruction count
+/* Default values for optional defines:
+#define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0        // Dynamic indexing only works on >= sm 5.1
+#define SHADOW_OPTIMIZE_REGISTER_USAGE   0        // Redefine this as 1 in your ShadowContext.hlsl to optimize for register usage over instruction count
+// #define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL    // Enable custom implementations of GetPunctualShadowAttenuation. If not defined, a default implementation will be used.
+// #define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL // Enable custom implementations of GetDirectionalShadowAttenuation. If not defined, a default implementation will be used.
+*/
-#include "../../../Core/Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
-#include "ShadowTexFetch.hlsl"						// Resource sampling definitions (don't modify)
+#ifndef SHADOW_SUPPORTS_DYNAMIC_INDEXING
+    #define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0
+#endif
+#ifndef SHADOW_OPTIMIZE_REGISTER_USAGE
+    #define SHADOW_OPTIMIZE_REGISTER_USAGE   0
+#endif
-// Declares a shadow context struct with members and sampling code based on whether _...Slots > 0
-#define SHADOWCONTEXT_DECLARE( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )				\
-																													\
-	struct ShadowContext																							\
-	{																												\
-		StructuredBuffer<ShadowData>	shadowDatas;																\
-		StructuredBuffer<int4>			payloads;																	\
-		SHADOWCONTEXT_DECLARE_TEXTURES( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )	\
-	};																												\
-																													\
-	SHADOW_DEFINE_SAMPLING_FUNCS( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )
+#include "Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
+#include "ShadowTexFetch.hlsl"						// Resource sampling definitions (don't modify)
+struct ShadowContext
+{
+    StructuredBuffer<ShadowData>	shadowDatas;
+    StructuredBuffer<int4>			payloads;
+    SHADOWCONTEXT_DECLARE_TEXTURES( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER )
+};
-// Shadow context definition and initialization, i.e. resource binding (project header, must be kept in sync with C# runtime)
-#define SHADOW_CONTEXT_INCLUDE
-#include "../../ShadowIncludes.hlsl"
-#undef SHADOW_CONTEXT_INCLUDE
+SHADOW_DEFINE_SAMPLING_FUNCS( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER )
 
 // helper function to extract shadowmap data from the ShadowData struct
 void UnpackShadowmapId( uint shadowmapId, out uint texIdx, out uint sampIdx, out float slice )
 // shadow sampling prototypes
 float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L );
 float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS );
+
-
-// wedge in the actual shadow sampling algorithms
-#include "ShadowSampling.hlsl"			// sampling patterns (don't modify)
-#include "ShadowAlgorithms.hlsl"		// engine default algorithms (don't modify)
-#include "ShadowAlgorithmsCustom.hlsl"	// project specific custom algorithms (project can modify this)
-
-
-// default dispatchers for the individual shadow types (with and without screenspace support)
-// point/spot light shadows
-float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
-{
-	return EvalShadow_PunctualDepth(shadowContext, positionWS, normalWS, shadowDataIndex, L);
-}
-float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
-{
-	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-}
-// directional light shadows
-float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
-{
-	return EvalShadow_CascadedDepth_Blend( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-}
-float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
-{
-	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-}
-
-// include project specific shadow dispatcher. If this file is not empty, it MUST define which default shadows it's overriding
-#define SHADOW_DISPATCH_INCLUDE
-#include "../../ShadowIncludes.hlsl"
-#undef SHADOW_DISPATCH_INCLUDE
-
-// if shadow dispatch is empty we'll fall back to default shadow sampling implementations
-	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+    return EvalShadow_PunctualDepth(shadowContext, positionWS, normalWS, shadowDataIndex, L);
+
-	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L, unPositionSS );
+    return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+
-	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+    return EvalShadow_CascadedDepth_Blend( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+
-	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L, unPositionSS );
+    return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+
+#include "ShadowSampling.hlsl"			// sampling patterns (don't modify)
+#include "ShadowAlgorithms.hlsl"		// engine default algorithms (don't modify)
+#include "ShadowAlgorithmsCustom.hlsl"	// project specific custom algorithms (project can modify this)
 
 #endif // SHADOW_HLSL

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Lighting.hlsl

 #include "../Lighting/LightDefinition.cs.hlsl"
 #include "../Lighting/LightUtilities.hlsl"
 
-#define SHADOW_TILEPASS
-#include "../../Core/ShaderLibrary/Shadow/Shadow.hlsl"
-#undef SHADOW_TILEPASS
+#include "TilePass/Shadow.hlsl"
 
 #if defined(LIGHTLOOP_SINGLE_PASS) || defined(LIGHTLOOP_TILE_PASS)
 #include "../Lighting/TilePass/TilePass.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/ShadowContext.hlsl

-
-// This can be custom for each project and needs to be in sync with the ShadowMgr
+#ifndef TILEPASS_SHADOW_CONTEXT_HLSL
+#define TILEPASS_SHADOW_CONTEXT_HLSL
-
-#undef  SHADOW_OPTIMIZE_REGISTER_USAGE
-SHADOWCONTEXT_DECLARE( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER );
+#include "ShaderLibrary/Shadow/Shadow.hlsl"
 
 TEXTURE2D_ARRAY(_ShadowmapExp_VSM_0);
 SAMPLER2D(sampler_ShadowmapExp_VSM_0);
 	return sc;
 }
 
+#endif // TILEPASS_SHADOW_CONTEXT_HLSL

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/ShadowContext.hlsl.meta

 fileFormatVersion: 2
 guid: b0e81431fe3a7604fb9f9dd2a96bd7e0
-timeCreated: 1491321445
-licenseType: Pro
+  externalObjects: {}
+  nonModifiableTextures: []
   userData: 
   assetBundleName: 
   assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             scInit.resourceBinder                    = binder;
 
             m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
-            // set global overrides - these need to match the override specified in ShadowDispatch.hlsl
+            // set global overrides - these need to match the override specified in TilePass/Shadow.hlsl
             bool useGlobalOverrides = true;
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Spot         , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Shadow.hlsl

-// This file is empty by default.
-// Project specific file to override the default shadow sampling routines.
-// We need to define which dispatchers we're overriding, otherwise the compiler will pick default implementations which will lead to compilation errors.
-// Check Shadow.hlsl right below where this header is included for the individual defines.
+#ifndef TILEPASS_SHADOW_HLSL
+#define TILEPASS_SHADOW_HLSL
+#define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL
+#define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
+#include "ShadowContext.hlsl"
 
 // This is an example of how to override the default dynamic resource dispatcher
 // by hardcoding the resources used and calling the shadow sampling routines that take an explicit texture and sampler.
 
-#define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL	    // enables hardcoded resources and algorithm for directional lights
-#define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL		    // enables hardcoded resources and algorithm for punctual lights
 //#define SHADOW_DISPATCH_USE_SEPARATE_CASCADE_ALGOS  // enables separate cascade sampling variants for each cascade
 //#define SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS	    // enables separate resources and algorithms for spot and point lights
 
 {
 	return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
+#else
+#include "ShaderLibrary/Shadow/DirectionalShadowAttenuation.hlsl"
 #endif
 
 
 		return EvalShadow_SpotDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 	}
 #else
-	// example for choosing the same algo 
+	// example for choosing the same algo
 	Texture2DArray			tex      = shadowContext.tex2DArray[SHADOW_DISPATCH_PUNC_TEX];
 	SamplerComparisonState	compSamp = shadowContext.compSamplers[SHADOW_DISPATCH_PUNC_SMP];
 	uint					algo     = SHADOW_DISPATCH_PUNC_ALG;
 {
 	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
+#else
+#include "ShaderLibrary/Shadow/PunctualShadowAttenuation.hlsl"
 #endif
 
 // cleanup the defines
 #ifdef SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS
 #undef SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS
 #endif
+
+
+
+#endif // TILEPASS_SHADOW_HLSL

TestbedPipelines/Fptl/FptlLighting.cs

             scInit.resourceBinder                    = binder;
 
             m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
-            // set global overrides - these need to match the override specified in ShadowDispatch.hlsl
+            // set global overrides - these need to match the override specified in Fptl/Shadow.hlsl
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Spot         , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Directional  , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );

TestbedPipelines/Fptl/LightingTemplate.hlsl

 #define CUBEMAPFACE_POSITIVE_Z 4
 #define CUBEMAPFACE_NEGATIVE_Z 5
 
-#define SHADOW_FPTL
-#	if defined(SHADER_API_D3D11)
-#		include "ShaderLibrary/API/D3D11.hlsl"
-#	elif defined(SHADER_API_PSSL)
-#		include "ShaderLibrary/API/PSSL.hlsl"
-#	elif defined(SHADER_API_XBOXONE)
-#		include "ShaderLibrary/API/D3D11.hlsl"
-#		include "ShaderLibrary/API/D3D11_1.hlsl"
-#	elif defined(SHADER_API_METAL)
-#		include "ShaderLibrary/API/Metal.hlsl"
-#	else
-#		error unsupported shader api
-#	endif
-#	include "ShaderLibrary/API/Validate.hlsl"
-#	include "ShaderLibrary/Shadow/Shadow.hlsl"
-#undef SHADOW_FPTL
+#if defined(SHADER_API_D3D11)
+#	include "ShaderLibrary/API/D3D11.hlsl"
+#elif defined(SHADER_API_PSSL)
+#	include "ShaderLibrary/API/PSSL.hlsl"
+#elif defined(SHADER_API_XBOXONE)
+#	include "ShaderLibrary/API/D3D11.hlsl"
+#	include "ShaderLibrary/API/D3D11_1.hlsl"
+#elif defined(SHADER_API_METAL)
+#	include "ShaderLibrary/API/Metal.hlsl"
+#else
+#	error unsupported shader api
+#endif
+#include "ShaderLibrary/API/Validate.hlsl"
+
+#include "Shadow.hlsl"
 
 CBUFFER_START(ShadowLightData)
 

TestbedPipelines/Fptl/ShadowContext.hlsl

-
-// This can be custom for each project and needs to be in sync with the ShadowMgr
+#ifndef FPTL_SHADOW_CONTEXT_HLSL
+#define FPTL_SHADOW_CONTEXT_HLSL
 
 #define SHADOWCONTEXT_MAX_TEX2DARRAY   1
 #define SHADOWCONTEXT_MAX_TEXCUBEARRAY 0
-SHADOWCONTEXT_DECLARE( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER );
+#include "ShaderLibrary/Shadow/Shadow.hlsl"
 
 TEXTURE2D_ARRAY(_ShadowmapExp_PCF);
 SAMPLER2D_SHADOW(sampler_ShadowmapExp_PCF);
 	return sc;
 }
 
+#endif // FPTL_SHADOW_CONTEXT_HLSL

TestbedPipelines/Fptl/ShadowContext.hlsl.meta

-fileFormatVersion: 2
-guid: 30016f0dcc663b14483b62ccf2e8a7ce
-timeCreated: 1503477804
-licenseType: Pro
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 7c02f6444b51404e99b1158f7f152678
+timeCreated: 1511273566

TestbedPipelines/OnTileDeferredPipeline/OnTileDeferredRenderPipeline.cs

 			scInit.resourceBinder                    = binder;
 
 			m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
-			// set global overrides - these need to match the override specified in ShadowDispatch.hlsl
+			// set global overrides - these need to match the override specified in Fptl/Shadow.hlsl
 			m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
 			m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Spot         , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
 			m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Directional  , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );

TestbedPipelines/OnTileDeferredPipeline/Shaders/LightingTemplate.hlsl

 #define BOX_LIGHT (2)
 #define DIRECTIONAL_LIGHT (3)
 
-#define SHADOW_FPTL
-#	if defined(SHADER_API_D3D11)
-#		include "ShaderLibrary/API/D3D11.hlsl"
-#	elif defined(SHADER_API_PSSL)
-#		include "ShaderLibrary/API/PSSL.hlsl"
-#	elif defined(SHADER_API_XBOXONE)
-#		include "ShaderLibrary/API/D3D11.hlsl"
-#		include "ShaderLibrary/API/D3D11_1.hlsl"
-#	elif defined(SHADER_API_METAL)
-#		include "ShaderLibrary/API/Metal.hlsl"
-#	else
-#		error unsupported shader api
-#	endif
-#	include "ShaderLibrary/API/Validate.hlsl"
-#	include "ShaderLibrary/Shadow/Shadow.hlsl"
-#undef SHADOW_FPTL
+#if defined(SHADER_API_D3D11)
+#	include "ShaderLibrary/API/D3D11.hlsl"
+#elif defined(SHADER_API_PSSL)
+#	include "ShaderLibrary/API/PSSL.hlsl"
+#elif defined(SHADER_API_XBOXONE)
+#	include "ShaderLibrary/API/D3D11.hlsl"
+#	include "ShaderLibrary/API/D3D11_1.hlsl"
+#elif defined(SHADER_API_METAL)
+#	include "ShaderLibrary/API/Metal.hlsl"
+#else
+#	error unsupported shader api
+#endif
+#include "ShaderLibrary/API/Validate.hlsl"
+#include "../../Fptl/Shadow.hlsl"
 
 UNITY_DECLARE_DEPTH_TEXTURE(_CameraGBufferZ);
 

TestbedPipelines/OnTileDeferredPipeline/Shaders/UnityStandardForwardMobile.cginc

 #define CUBEMAPFACE_POSITIVE_Z 4
 #define CUBEMAPFACE_NEGATIVE_Z 5
 
-#define SHADOW_FPTL
-#	if defined(SHADER_API_D3D11)
-#		include "ShaderLibrary/API/D3D11.hlsl"
-#	elif defined(SHADER_API_PSSL)
-#		include "ShaderLibrary/API/PSSL.hlsl"
-#	elif defined(SHADER_API_XBOXONE)
-#		include "ShaderLibrary/API/D3D11.hlsl"
-#		include "ShaderLibrary/API/D3D11_1.hlsl"
-#	elif defined(SHADER_API_METAL)
-#		include "ShaderLibrary/API/Metal.hlsl"
-#	else
-#		error unsupported shader api
-#	endif
-#	include "ShaderLibrary/API/Validate.hlsl"
-#	include "ShaderLibrary/Shadow/Shadow.hlsl"
-#undef SHADOW_FPTL
+#if defined(SHADER_API_D3D11)
+#	include "ShaderLibrary/API/D3D11.hlsl"
+#elif defined(SHADER_API_PSSL)
+#	include "ShaderLibrary/API/PSSL.hlsl"
+#elif defined(SHADER_API_XBOXONE)
+#	include "ShaderLibrary/API/D3D11.hlsl"
+#	include "ShaderLibrary/API/D3D11_1.hlsl"
+#elif defined(SHADER_API_METAL)
+#	include "ShaderLibrary/API/Metal.hlsl"
+#else
+#	error unsupported shader api
+#endif
+#include "ShaderLibrary/API/Validate.hlsl"
+#include "../../Fptl/Shadow.hlsl"
 
 struct VertexOutputForwardNew
 {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Shadow.hlsl.meta

+fileFormatVersion: 2
+guid: a17db9285d434b8aafe02c6d8af3353c
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

TestbedPipelines/Fptl/Shadow.hlsl

+#ifndef FPTL_SHADOW_HLSL
+#define FPTL_SHADOW_HLSL
+
+#define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL    // Define this to provide custom implementations of GetPunctualShadowAttenuation
+#define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL // Define this to provide custom implementations of GetDirectionalShadowAttenuation
+
+#include "ShadowContext.hlsl"
+
+#ifdef  SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
+{
+	Texture2DArray			tex      = shadowContext.tex2DArray[0];
+	SamplerComparisonState	compSamp = shadowContext.compSamplers[0];
+	uint					algo     = GPUSHADOWALGORITHM_PCF_9TAP;
+
+	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 )
+{
+	return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+}
+#endif
+
+#ifdef  SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
+{
+	// example for choosing the same algo
+	Texture2DArray			tex = shadowContext.tex2DArray[0];
+	SamplerComparisonState	compSamp = shadowContext.compSamplers[0];
+	uint					algo     = GPUSHADOWALGORITHM_PCF_9TAP;
+	return EvalShadow_PunctualDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+}
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
+{
+	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+}
+#endif
+
+#endif // FPTL_SHADOW_HLSL

TestbedPipelines/Fptl/Shadow.hlsl.meta

+fileFormatVersion: 2
+guid: d042b3cf919f4d7d815e9923fa3f1c65
+timeCreated: 1511268424

ScriptableRenderPipeline/Core/ShadowIncludes.hlsl.meta

-fileFormatVersion: 2
-guid: cbc2765f95de56a47a8f39f5f1badd58
-timeCreated: 1491314187
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/Core/ShadowIncludes.hlsl

-// This file is inlined by ShaderLibrary/Shadow/Shadow.hlsl twice.
-// Each time either SHADOW_CONTEXT_INCLUDE or SHADOW_DISPATCH_INCLUDE is defined.
-// In the case of SHADOW_CONTEXT_INCLUDE a valid path must be given to a file that contains
-// the code to initialize a shadow context.
-// SHADOW_DISPATCH_INCLUDE is optional.
-
-#ifdef SHADOW_CONTEXT_INCLUDE
-#	ifdef SHADOW_TILEPASS
-#		include "../HDRenderPipeline/Lighting/TilePass/ShadowContext.hlsl"
-#	elif defined( SHADOW_FPTL )
-#		include "../../TestbedPipelines/fptl/ShadowContext.hlsl"
-#	else
-#		error "No valid path to the shadow context has been given."
-#	endif
-#endif
-
-#ifdef SHADOW_DISPATCH_INCLUDE
-#	ifdef SHADOW_TILEPASS
-#		include "../HDRenderPipeline/Lighting/TilePass/ShadowDispatch.hlsl"
-#	elif defined( SHADOW_FPTL )
-#		include "../../TestbedPipelines/fptl/ShadowDispatch.hlsl"
-#	else
-		// It's ok not to have a dispatcher include as it only acts as an override
-#	endif
-#endif

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

-fileFormatVersion: 2
-guid: e7e55b7306a2b2f43886918882a8935a
-timeCreated: 1491321445
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: