#ifndef	SHADOW_H
#define SHADOW_H

#include "common.h"

//uniform	sampler	s_smap	: register(ps,s0);	// 2D/cube shadowmap
//Texture2D<float>	s_smap;		// 2D/cube shadowmap
//	Used for RGBA texture too ?!
Texture2D	s_smap : register(ps,t0);		// 2D/cube shadowmap

Texture2D<float> s_smap_minmax;		// 2D/cube shadowmap
#include "gather.ps"

SamplerComparisonState smp_smap;	//	Special comare sampler
sampler smp_jitter;

uniform float4 ssfx_shadow_bias;

Texture2D jitter0;
Texture2D jitter1;
Texture2D jitterMipped;

#ifndef USE_ULTRA_SHADOWS
	#define	KERNEL	0.6f
#else
	#define	KERNEL	1.0f
#endif

#define PCSS_PIXEL int(4)
#define PCSS_STEP int(2)
#define PCSS_PIXEL_MIN float(1.0)
#define PCSS_SUN_WIDTH float(150.0)

float modify_light( float light )
{
   return ( light > 0.7 ? 1.0 : lerp( 0.0, 1.0, saturate( light / 0.7 ) ) ); 
}

//////////////////////////////////////////////////////////////////////////////////////////
// hardware + PCF
//////////////////////////////////////////////////////////////////////////////////////////
float sample_hw_pcf (float4 tc,float4 shift)
{
	static const float 	ts = KERNEL / float(SMAP_size);

	tc.xyz 	/= tc.w;
	tc.xy 	+= shift.xy * ts;

	return s_smap.SampleCmpLevelZero( smp_smap, tc.xy, tc.z).x;
}

float shadow_hw( float4 tc )
{
  	float	s0		= sample_hw_pcf( tc, float4( -1, -1, 0, 0) );
  	float	s1		= sample_hw_pcf( tc, float4( +1, -1, 0, 0) );
  	float	s2		= sample_hw_pcf( tc, float4( -1, +1, 0, 0) );
  	float	s3		= sample_hw_pcf( tc, float4( +1, +1, 0, 0) );

	return	(s0+s1+s2+s3)/4.h;
}


#ifdef SM_MINMAX
bool cheap_reject( float3 tc, inout bool full_light ) 
{
   float4 plane0  = sm_minmax_gather( tc.xy, int2( -1,-1 ) );
   float4 plane1  = sm_minmax_gather( tc.xy, int2(  1,-1 ) );
   float4 plane2  = sm_minmax_gather( tc.xy, int2( -1, 1 ) );
   float4 plane3  = sm_minmax_gather( tc.xy, int2(  1, 1 ) );
   bool plane     = all( ( plane0 >= (0).xxxx ) * ( plane1 >= (0).xxxx ) * ( plane2 >= (0).xxxx ) * ( plane3 >= (0).xxxx ) );

   [flatten] if( !plane ) // if there are no proper plane equations in the support region
   {
      bool no_plane  = all( ( plane0 < (0).xxxx ) * ( plane1 < (0).xxxx ) * ( plane2 < (0).xxxx ) * ( plane3 < (0).xxxx ) );
      float4 z       = ( tc.z - 0.0005 ).xxxx;
      bool reject    = all( ( z > -plane0 ) * ( z > -plane1 ) * ( z > -plane2 ) * ( z > -plane3 ) ); 
      [flatten] if( no_plane && reject )
      {
         full_light = false;
         return true;
      }
      else
      {
         return false;
      }
   }
   else // plane equation detected
   {
      // compute corrected z for texel pos
      static const float scale = float( SMAP_size / 4 );
      float2 fc  = frac( tc.xy * scale );
      float  z   = lerp( lerp( plane0.y, plane1.x, fc.x ), lerp( plane2.z, plane3.w, fc.x ), fc.y );

      // do minmax test with new z
      full_light = ( ( tc.z - 0.0001 ) <= z );

      return true; 
   }
}

//Sunshafts
float shadow_dx10_1_sunshafts( float4 tc, float2 pos2d ) 
{
   float3 t         = tc.xyz / tc.w;
   float minmax     = s_smap_minmax.SampleLevel( smp_nofilter, t, 0 ).x;
   bool   umbra     = ( ( minmax.x < 0 ) && ( t.z > -minmax.x ) );

   [branch] if( umbra )
   {
      return 0.0;
   }
   else
   {
      return shadow_hw( tc ); 
   }
}
#endif	//	SM_MINMAX



	//PCSS shadows
static const float2 poissonDisk[32] = {
	float2(0.0617981, 0.07294159),
	float2(0.6470215, 0.7474022),
	float2(-0.5987766, -0.7512833),
	float2(-0.693034, 0.6913887),
	float2(0.6987045, -0.6843052),
	float2(-0.9402866, 0.04474335),
	float2(0.8934509, 0.07369385),
	float2(0.1592735, -0.9686295),
	float2(-0.05664673, 0.995282),
	float2(-0.1203411, -0.1301079),
	float2(0.1741608, -0.1682285),
	float2(-0.09369049, 0.3196758),
	float2(0.185363, 0.3213367),
	float2(-0.1493771, -0.3147511),
	float2(0.4452095, 0.2580113),
	float2(-0.1080467, -0.5329178),
	float2(0.1604507, 0.5460774),
	float2(-0.4037193, -0.2611179),
	float2(0.5947998, -0.2146744),
	float2(0.3276062, 0.9244621),
	float2(-0.6518704, -0.2503952),
	float2(-0.3580975, 0.2806469),
	float2(0.8587891, 0.4838005),
	float2(-0.1596546, -0.8791054),
	float2(-0.3096867, 0.5588146),
	float2(-0.5128918, 0.1448544),
	float2(0.8581337, -0.424046),
	float2(0.1562584, -0.5610626),
	float2(-0.7647934, 0.2709858),
	float2(-0.3090832, 0.9020988),
	float2(0.3935608, 0.4609676),
	float2(0.3929337, -0.5010948),
};

	//Quality tokens --Fine
#if !defined(SUN_QUALITY)
	#define PCSS_NUM_SAMPLES int(1)
#elif SUN_QUALITY==1
	#define PCSS_NUM_SAMPLES int(8)
#elif SUN_QUALITY==2
	#define PCSS_NUM_SAMPLES int(12)
#elif SUN_QUALITY==3
	#define PCSS_NUM_SAMPLES int(20)
#elif (SUN_QUALITY==4 || SUN_QUALITY==5)
	#define PCSS_NUM_SAMPLES int(32)
#endif

float shadow_pcss( float4 tc )
{
	// - Small modification to fix flickering and black squares.
	// - Added a extra performance option with lower SUN_QUALITY settings.
	// - Extended the blocker search from 3x3 to 4x4 for better results.
	// https://www.moddb.com/mods/stalker-anomaly/addons/screen-space-shaders/

	tc.xyz /= tc.w;

#if SUN_QUALITY > 3 // Blocker search ( Penumbra ) and filter

	int3 uv = int3(tc.xy * float(SMAP_size), 0);
	float zBlock = tc.z - 0.0001;
	float avgBlockerDepth = 0.0;
	float blockerCount = 0.0;

	[unroll] 
	for( int row = -PCSS_PIXEL; row <= PCSS_PIXEL; row += PCSS_STEP )
	{
		[unroll] 
		for( int col = -PCSS_PIXEL; col <= PCSS_PIXEL; col += PCSS_STEP )
		{
			float shadowMapDepth = s_smap.Load( uv, int2( col, row ) ).x;
			float b1 = ( shadowMapDepth < zBlock ) ? 1.0 : 0.0;
			blockerCount += b1;
			avgBlockerDepth += shadowMapDepth * b1;
		}
	}

	if(blockerCount < 1)
		return 1.0;

	avgBlockerDepth /= blockerCount;
	float fRatio = saturate( ( ( tc.z - avgBlockerDepth ) * PCSS_SUN_WIDTH ) / avgBlockerDepth );
	fRatio *= fRatio;
	fRatio = max(PCSS_PIXEL_MIN, fRatio * float(PCSS_PIXEL)) / float(SMAP_size);

	float s = 0.0;
	[unroll] 
	for( uint i = 0; i < PCSS_NUM_SAMPLES; ++i )
	{
		float2 offset = poissonDisk[i] * fRatio;
		s += s_smap.SampleCmpLevelZero( smp_smap, tc.xy + offset, tc.z ).x;
	}
	return s / PCSS_NUM_SAMPLES;

#else // No blocker search ( Penumbra ), just filter


	float fRatio = 4.0f / float(SMAP_size);

	float s = 0.0;
	[unroll] 
	for( uint i = 0; i < PCSS_NUM_SAMPLES; ++i )
	{
		float2 offset = poissonDisk[i] * fRatio;
		float test = s_smap.SampleCmpLevelZero( smp_smap, tc.xy + offset, tc.z ).x;
		s += test;
	}

	return s / PCSS_NUM_SAMPLES;
	

#endif

}

//////////////////////////////////////////////////////////////////////////////////////////
//	D24X8+PCF
//////////////////////////////////////////////////////////////////////////////////////////

float4 test (float4 tc, float2 offset)
{
	tc.xyz 	/= tc.w;
	tc.xy 	+= offset;
	return s_smap.SampleCmpLevelZero( smp_smap, tc.xy, tc.z).x;
}

half 	shadowtest_sun 	(float4 tc, float4 tcJ)			// jittered sampling
{
	half4	r;
	const 	float 	scale 	= (0.7/float(SMAP_size));

	float2 	tc_J	= frac(tc.xy/tc.w*SMAP_size/4.0 )*0.5;
	float4	J0		= jitter0.Sample(smp_jitter,tc_J)*scale;

	const float k = 0.5/float(SMAP_size);
	r.x 	= test 	(tc, J0.xy+half2(-k,-k)).x;
	r.y 	= test 	(tc, J0.wz+half2( k,-k)).y;
	r.z		= test	(tc,-J0.xy+half2(-k, k)).z;
	r.w		= test	(tc,-J0.wz+half2( k, k)).x;

	return	dot(r,1.0/4.0);
}

float shadow_hw_hq( float4 tc )
{
#ifdef SM_MINMAX
   bool   full_light = false; 
   bool   cheap_path = cheap_reject( tc.xyz / tc.w, full_light );

   [branch] if( cheap_path )
   {
      [branch] if( full_light == true )
         return 1.0;
      else
         return sample_hw_pcf( tc, (0).xxxx ); 
   }
   else
   {
      return shadow_pcss(tc);
   }
#else //	SM_MINMAX
      return shadow_pcss(tc);
#endif //	SM_MINMAX
}

uniform float4x4	m_shadow;
#include "slb_shadow.h"
float shadow( float4 tc, float2 pos2d )
{
	return SLB_Shadow(tc, pos2d);
#ifdef USE_ULTRA_SHADOWS
	#ifdef SM_MINMAX
		return modify_light( shadow_hw_hq( tc ) ); 
	#else
		return shadow_hw_hq( tc ); 
	#endif
#else
	return shadow_pcss(tc);
#endif
}

//////////////////////////////////////////////////////////////////////////////////////////
// testbed

float shadow_rain(float4 tc, float2 tcJ)			// jittered sampling
{
	float4	r;

	const 	float 	scale 	= (4.0/float(SMAP_size));

	float4	J0 	= jitter0.Sample( smp_linear, tcJ )*scale;
	float4	J1 	= jitter1.Sample( smp_linear, tcJ )*scale;

	r.x 	= test 	(tc,J0.xy).x;
	r.y 	= test 	(tc,J0.wz).y;
	r.z		= test	(tc,J1.xy).z;
	r.w		= test	(tc,J1.wz).x;
	return	dot(r,1.0/4.0);
}

//////////////////////////////////////////////////////////////////////////////////////////
#ifdef  USE_SUNMASK	
float3x4 m_sunmask;	// ortho-projection
float sunmask( float4 P )
{
	float2 		tc	= mul( m_sunmask, P );		//
	return 		s_lmap.SampleLevel( smp_linear, tc, 0 ).w;	//Hemi map - ambient occlusion	
}
#else
float sunmask( float4 P ) { return 1.0; }		// 
#endif
//////////////////////////////////////////////////////////////////////////////////////////

#endif