// Each #kernel tells which function to compile; you can have many kernels
#pragma kernel DeferredDirectionalShadow				    DEFERRED_DIRECTIONAL=DeferredDirectionalShadow
#pragma kernel DeferredDirectionalShadow_Contact		    DEFERRED_DIRECTIONAL=DeferredDirectionalShadow_Contact	        ENABLE_CONTACT_SHADOWS
#pragma kernel DeferredDirectionalShadow_Normals		    DEFERRED_DIRECTIONAL=DeferredDirectionalShadow_Normals          ENABLE_NORMALS
#pragma kernel DeferredDirectionalShadow_Contact_Normals	DEFERRED_DIRECTIONAL=DeferredDirectionalShadow_Contact_Normals  ENABLE_CONTACT_SHADOWS ENABLE_NORMALS

#ifdef ENABLE_NORMALS
#   define LIGHTLOOP_TILE_PASS 1
#   define USE_FPTL_LIGHTLIST  1 // deferred opaque always use FPTL
#   define UNITY_MATERIAL_LIT
#else
#   define SHADOW_USE_ONLY_VIEW_BASED_BIASING 1   // Enable only light view vector based biasing. If undefined, biasing will be based on the normal and calling code must provide a valid normal.
#endif

#ifdef SHADER_API_PSSL
#   pragma argument( scheduler=minpressure ) // instruct the shader compiler to prefer minimizing vgpr usage
#endif

#include "CoreRP/ShaderLibrary/Common.hlsl"
#include "../ShaderVariables.hlsl"
#include "Lighting.hlsl" 

//#pragma enable_d3d11_debug_symbols

RWTexture2D<float4> _DeferredShadowTextureUAV;

CBUFFER_START(DeferredShadowParameters)
uint    _DirectionalShadowIndex;
float3  _LightDirection;
float4  _ScreenSpaceShadowsParameters;
int     _SampleCount;
CBUFFER_END

#define _ContactShadowLength                _ScreenSpaceShadowsParameters.x
#define _ContactShadowDistanceScaleFactor   _ScreenSpaceShadowsParameters.y
#define _ContactShadowFadeEnd               _ScreenSpaceShadowsParameters.z
#define _ContactShadowFadeOneOverRange      _ScreenSpaceShadowsParameters.w

#define DEFERRED_SHADOW_TILE_SIZE 16

// Return 1.0 if occluded 0.0 if not
float4 ScreenSpaceShadowRayCast(float3 positionWS, float3 rayDirection, float rayLength)
{
	uint3 hashInput = uint3(abs(GetAbsolutePositionWS(positionWS)) * 1000);
	// Dither pattern is shifted by 0.5 because we want to jitter the ray starting position backward and forward (so we need values between -0.5 and 0.5)
	float ditherBias = 0.5;
	float dither = GenerateHashedRandomFloat(hashInput) - ditherBias;

	float3 rayStartWS = positionWS;
	float3 rayEndWS = rayStartWS + rayDirection * rayLength;

	float4 rayStartCS = TransformWorldToHClip(rayStartWS);
	float4 rayEndCS = TransformWorldToHClip(rayEndWS);

	// Here we compute a ray perpendicular to view space. This is the ray we use to compute the threshold for rejecting samples.
	// This is done this way so that the threshold is less dependent of ray slope.
	float4 rayOrthoViewSpace = rayStartCS + mul(GetViewToHClipMatrix(), float4(0, 0, rayLength, 0));
	rayOrthoViewSpace = rayOrthoViewSpace / rayOrthoViewSpace.w;

	rayStartCS.xyz = rayStartCS.xyz / rayStartCS.w;
	rayEndCS.xyz = rayEndCS.xyz / rayEndCS.w;

	// Pixel to light ray in clip space.
	float3 rayCS = rayEndCS.xyz - rayStartCS.xyz;

	// Depth at the start of the ray
	float startDepth = rayStartCS.z;
	// Depth range of the ray
	float rayDepth = rayCS.z;

	// Starting UV of the sampling loop
	float2 startUV = rayStartCS.xy * 0.5f + 0.5f;
	startUV.y = 1.0 - startUV.y;

	// Pixel to light ray in 
	float2 rayUV = rayCS.xy * 0.5f;
	rayUV.y = -rayUV.y;

	float step = 1.0 / _SampleCount;
	float compareThreshold = abs(rayOrthoViewSpace.z - rayStartCS.z) * step;

	float occluded = 0.0f;

	for (int i = 0; i < _SampleCount; i++)
	{
		// Step for this sample
		float sampleStep = ((i + 1) * step + step * dither);

		// UVs for the current sample
		float2 sampleUV = (startUV + rayUV * sampleStep) * _ScreenToTargetScale.xy;
		// Ray depth for this sample
		float raySampleDepth = startDepth + rayDepth * sampleStep;

		// Depth buffer depth for this sample
		float sampleDepth = SAMPLE_TEXTURE2D_LOD(_MainDepthTexture, sampler_MainDepthTexture, sampleUV, 0.0).x;

		bool Hit = false;
		float depthDiff = sampleDepth - raySampleDepth;
		Hit = depthDiff < compareThreshold && depthDiff > 0.0;// 1e-4;

		if (Hit)
			occluded = 1.0f;
	}

	// Off screen masking
	// We remove the occlusion if the ray is occluded and only if direction steps out of the screen
	float2 vignette = max(6.0 * abs(rayStartCS.xy + rayCS.xy * occluded * 0.5) - 5.0, 0.0);
	occluded *= saturate( 1.0 - dot(vignette, vignette) );

	return occluded;
}

[numthreads(DEFERRED_SHADOW_TILE_SIZE, DEFERRED_SHADOW_TILE_SIZE, 1)]
void DEFERRED_DIRECTIONAL(uint2 groupThreadId : SV_GroupThreadID, uint2 groupId : SV_GroupID)
{
	uint2 pixelCoord = groupId * DEFERRED_SHADOW_TILE_SIZE + groupThreadId;
	uint2 tileCoord = groupId;

	float depth = LOAD_TEXTURE2D(_MainDepthTexture, pixelCoord.xy).x;

	if (depth == UNITY_RAW_FAR_CLIP_VALUE)
		return;

	PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, tileCoord);

#ifdef ENABLE_NORMALS
	BSDFData bsdfData;
	BakeLightingData unused;
	DECODE_FROM_GBUFFER(posInput.positionSS, UINT_MAX, bsdfData, unused.bakeDiffuseLighting);
	float3 nrm = bsdfData.normalWS;
#else
	float3 nrm = 0.0.xxx;
#endif

	ShadowContext shadowContext = InitShadowContext();
	float shadow = GetDirectionalShadowAttenuation(shadowContext, posInput.positionWS, nrm, _DirectionalShadowIndex, _LightDirection);

#ifdef ENABLE_CONTACT_SHADOWS
	float contactShadow = 1.0f;
	if (_ContactShadowLength > 0.0f)
	{
		float4 result = ScreenSpaceShadowRayCast(posInput.positionWS, normalize(_LightDirection), _ContactShadowLength * max(0.5, posInput.linearDepth * _ContactShadowDistanceScaleFactor));
		contactShadow = 1.0 - result.x * saturate((_ContactShadowFadeEnd - posInput.linearDepth) * _ContactShadowFadeOneOverRange);
		shadow *= contactShadow;
	}
#endif

	_DeferredShadowTextureUAV[pixelCoord] = float4(shadow, 0.0, 0.0, 0.0);
}