const char g_shadow[] =
"// Built-in shadow shader\n"
"// (c)2008 virtools\n"
"float4x4 WVP : WORLDVIEWPROJECTION;\n"
"float3x3 WIT : WORLDIT;\n"
"float4x3 World : WORLD;\n"
"// remap object coordinate from projective space into shadow map space\n"
"float4x4 WorldShadowViewProj : WORLDSHADOWVIEWPROJ;\n"
"//\n"
"float4 ShadowColor;\n"
"float ShadowLightingFactor;\n"
"float3 WorldProjectCenter; // for perspective projection \n"
"float3 WorldProjectDir;    // for directional projection \n"
"texture2D ShadowMapTex;\n"
"\n"
"float alphaTestEnable : AlphaTestEnable;\n"
"float alphaRef : AlphaRef;\n"
"\n"
"\n"
"texture2D MaterialTexture : Texture;\n"
"sampler2D MaterialTextureSampler = sampler_state\n"
"{  \n"
"	Texture = <MaterialTexture>; \n"
"	MipFilter = LINEAR; \n"
"	MinFilter = LINEAR; \n"
"	MagFilter = LINEAR; \n"
"	AddressU  = CLAMP;		\n"
"	AddressV  = CLAMP;\n"
"};\n"
"\n"
"\n"
"\n"
"sampler2D ShadowMap = sampler_state\n"
"{  \n"
"	Texture = <ShadowMapTex>; \n"
"	MipFilter = LINEAR; \n"
"	MinFilter = LINEAR; \n"
"	MagFilter = LINEAR; \n"
"	AddressU  = CLAMP;		\n"
"	AddressV  = CLAMP;\n"
"};\n"
"\n"
"sampler2D UnfilteredShadowMap = sampler_state\n"
"{  \n"
"	Texture = <ShadowMapTex>; \n"
"	MipFilter = POINT;\n"
"	MinFilter = POINT; \n"
"	MagFilter = POINT; \n"
"	AddressU  = CLAMP;		\n"
"	AddressV  = CLAMP;\n"
"};\n"
"\n"
"\n"
"float4 DirectionalAttenWorldGrad; // world gradient for directionnal attenuation (setting to (0, 0, 0, 1) simply disable attenuation)\n"
"\n"
"float4 LightFactors; // light factors : x = atten0, y = atten1, z = atten2, w = range\n"
"float3 SpotFactors;  // x = penumbra angle scale, y = penumbra angle bias, z = falloff\n"
"// -> if light is not a spot, setting spotFactors to (0, 0, 1) will disable spotlight limits\n"
"\n"
"float2 WScaleBias;\n"
"\n"
"// displacement for multi-tap sampling (du, dv, 0)\n"
"float4 TapDelta0;\n"
"float4 TapDelta1;\n"
"float4 TapDelta2;\n"
"float4 TapDelta3;\n"
"float4 TapDelta4;\n"
"float4 TapDelta5;\n"
"float4 TapDelta6;\n"
"float4 TapDelta7;\n"
"float4 TapDelta8;\n"
"float4 TapDelta9;\n"
"float4 TapDelta10;\n"
"float4 TapDelta11;\n"
"\n"
"float2 ShadowMapSize;\n"
"\n"
"\n"
"static const float4 TapDeltas[] = \n"
"{ \n"
"	TapDelta0,\n"
"	TapDelta1,\n"
"	TapDelta2,\n"
"	TapDelta3,\n"
"	TapDelta4,\n"
"	TapDelta5,\n"
"	TapDelta6,\n"
"	TapDelta7,\n"
"	TapDelta8,\n"
"	TapDelta9,\n"
"	TapDelta10,\n"
"	TapDelta11\n"
"};\n"
"\n"
"\n"
"// Lit shadows (needed for subtractive shadows)\n"
"#define LIGHTMODE_UNLIT 0\n"
"#define LIGHTMODE_PERSPLIT 1\n"
"#define LIGHTMODE_DIRLIT 2\n"
"\n"
"// Attenuation mode\n"
"#define NO_LIGHTFACTORS 0\n"
"#define USE_LIGHTFACTORS 1\n"
"\n"
"// Shadow map formats\n"
"#define SMFORMAT_HW 0       // hardware support\n"
"#define SMFORMAT_FLOATW 1   // w-buffer in float texture\n"
"\n"
"#define ALPHA_TEST_ON true\n"
"#define ALPHA_TEST_OFF false\n"
"\n"
"struct VS_IN\n"
"{\n"
"	float4 Pos : POSITION;\n"
"	float3 Normal : NORMAL; \n"
"	float2 UV0 : TEXCOORD0; // for alpha test lookup\n"
"};\n"
"//\n"
"struct VS_OUT\n"
"{\n"
"	float4 Pos : POSITION;\n"
"	float4 ShTap0 : TEXCOORD0;\n"
"	float4 ShTap1 : TEXCOORD1;\n"
"	float4 ShTap2 : TEXCOORD2;\n"
"	float4 ShTap3 : TEXCOORD3;\n"
"	float4 ShTap4 : TEXCOORD4;\n"
"	float4 ShTap5 : TEXCOORD5; \n"
"	float4 ShTap6 : TEXCOORD6;\n"
"	float4 ShTap7 : TEXCOORD7;\n"
"	float4 ShColor : COLOR0; \n"
"};\n"
"//\n"
"VS_OUT ShadowVS(VS_IN vsIn,\n"
"				uniform int lightMode,\n"
"				uniform int useLightFactors,\n"
"				uniform int tapCount,\n"
"				uniform int smFormat,\n"
"				uniform bool useAlphaTest\n"
"				)\n"
"{\n"
"	VS_OUT vsOut = (VS_OUT) 0;\n"
"	vsOut.Pos = mul(vsIn.Pos, WVP);	\n"
"	float factor;\n"
"	// SHADOW LIGHTING\n"
"	float3 worldNormal = normalize(mul(vsIn.Normal, WIT));\n"
"	float4 worldPos = float4(mul(vsIn.Pos, World), 1);\n"
"	float3 L = normalize(float3(WorldProjectCenter - worldPos));\n"
"	float spotCos = dot(L, -WorldProjectDir);\n"
"	if (lightMode == LIGHTMODE_UNLIT)\n"
"	{	\n"
"		factor = 1;\n"
"	}\n"
"	else if (lightMode == LIGHTMODE_PERSPLIT)\n"
"	{\n"
"\n"
"		factor = saturate(ShadowLightingFactor * dot(L, worldNormal));	   \n"
"	}\n"
"	else // if (lightMode == LIGHTMODE_DIRLIT)\n"
"	{\n"
"		factor = saturate(ShadowLightingFactor * dot(worldNormal, -WorldProjectDir));	    \n"
"	}\n"
"	// ATTENUATION	\n"
"	factor *= saturate(dot(DirectionalAttenWorldGrad, worldPos)); // directional attenuation (possibly a constant)	\n"
"	//\n"
"	if (useLightFactors)\n"
"	{\n"
"		// light attenuation\n"
"		float3 deltaPos = WorldProjectCenter - worldPos.xyz;\n"
"		float d2 = dot(deltaPos, deltaPos);\n"
"		float d = sqrt(d2);\n"
"		if (d > LightFactors.w)\n"
"		{\n"
"			factor = 0;\n"
"		}\n"
"		factor *= saturate(1 / dot(LightFactors.xyz, float3(1, d, d2)));\n"
"		// spotlight fallof\n"
"		float penumbra = pow(1 - saturate(SpotFactors.x * (spotCos + SpotFactors.y)), SpotFactors.z);		\n"
"		factor *= penumbra;		\n"
"	}	\n"
"	//\n"
"	vsOut.ShColor = lerp(float4(1, 1, 1, 1), ShadowColor, factor);\n"
"\n"
"	// Generate shadow taps texcoords (use texcoords when possible)\n"
"	vsOut.ShTap0 = mul(vsIn.Pos, WorldShadowViewProj); // from post-projective space to spot	\n"
"\n"
"	if (smFormat == SMFORMAT_FLOATW)\n"
"	{\n"
"		vsOut.ShTap0.z = WScaleBias.x * vsOut.ShTap0.z + WScaleBias.y;\n"
"	}\n"
"\n"
"	// pack as many taps as possible into texcoord, to avoid additionnal dependent read in the shader	\n"
"	if (tapCount >= 1) vsOut.ShTap1 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[0].xyzz;\n"
"	if (tapCount >= 2) vsOut.ShTap2 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[1].xyzz;\n"
"	if (tapCount >= 3) vsOut.ShTap3 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[2].xyzz;\n"
"	if (tapCount >= 4) vsOut.ShTap4 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[3].xyzz;\n"
"	if (tapCount >= 5) vsOut.ShTap5 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[4].xyzz;\n"
"	if (tapCount >= 6) vsOut.ShTap6 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[5].xyzz;\n"
"	if (useAlphaTest)\n"
"	{\n"
"		vsOut.ShTap7 = vsIn.UV0.xyxy;\n"
"	}\n"
"	else\n"
"	{	\n"
"		if (tapCount >= 7) vsOut.ShTap7 = vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[6].xyzz;\n"
"	}\n"
"	//	\n"
"	return vsOut;\n"
"}\n"
"\n"
"\n"
"const float Ramp = (float) (16 * 1024 * 1024);\n"
"//const float Ramp = 1.f;\n"
"\n"
"//const float Ramp = 1024.f;\n"
"\n"
"\n"
"float ReadShadowMap(float4 pos, float w, float4 weights, uniform int smFormat)\n"
"{\n"
"	if (smFormat == SMFORMAT_HW)\n"
"	{\n"
"		// hw z-buffer\n"
"		return tex2Dproj(ShadowMap, pos).x;\n"
"	}\n"
"	else\n"
"	{\n"
"		// 'fetch 4' version\n"
"		float4 taps4 = tex2Dproj(UnfilteredShadowMap, pos);\n"
"		//taps4 = taps4 > w ? float4(1, 1, 1, 1) : float4(0, 0, 0, 0);\n"
"		// do a steep ramp here to save a sub then a cmp ...\n"
"		taps4 = saturate(Ramp * taps4 - w);\n"
"		return dot(taps4, weights); // bilinear filter\n"
"\n"
"		// unfiltered version		\n"
"		//return tex2Dproj(UnfilteredShadowMap, pos).x > w ? 1.f : 0.f;\n"
"\n"
"	}\n"
"}\n"
"\n"
"//\n"
"float4 ShadowPS(in VS_OUT vsOut, uniform int tapCount, uniform int smFormat, uniform bool useAlphaTest) : COLOR\n"
"{\n"
"	/*\n"
"	if (alphaTestEnable)\n"
"	{	\n"
"	clip(result.w - alphaRef); // must emulate alpha test for a float render target...\n"
"	}*/\n"
"\n"
"	clip(vsOut.ShTap0.z); // reject fragment that are behind the projector\n"
"	// Handle up to 13 taps, use interpolators when possible\n"
"	const float4 taps[] = \n"
"	{\n"
"		vsOut.ShTap0,\n"
"		vsOut.ShTap1,\n"
"		vsOut.ShTap2,\n"
"		vsOut.ShTap3,\n"
"		vsOut.ShTap4,\n"
"		vsOut.ShTap5,\n"
"		vsOut.ShTap6,\n"
"		useAlphaTest ? vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[6].xyzz : vsOut.ShTap7, // alpha test requires one additionnal texcoord slot\n"
"		vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[7].xyzz, // additionnal taps performed as dependent reads\n"
"		vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[8].xyzz,\n"
"		vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[9].xyzz,\n"
"		vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[10].xyzz,\n"
"		vsOut.ShTap0 + vsOut.ShTap0.w * TapDeltas[11].xyzz\n"
"	};\n"
"\n"
"	float2 alphaMaskLookupCoord = vsOut.ShTap7;\n"
"\n"
"\n"
"	if (useAlphaTest)\n"
"	{		\n"
"		clip(tex2D(MaterialTextureSampler, alphaMaskLookupCoord).w - alphaRef);\n"
"		//return tex2D(MaterialTextureSampler, alphaMaskLookupCoord);\n"
"		//return float4(alphaMaskLookupCoord.x, alphaMaskLookupCoord.y, 0, 1);\n"
"	}\n"
"\n"
"	float4 weights;\n"
"	float2 subUV = ShadowMapSize * (vsOut.ShTap0.xy / vsOut.ShTap0.w);\n"
"	subUV = frac(subUV);\n"
"	float2 xLerp = float2(1.f - subUV.x, subUV.x);\n"
"	weights.xy = (1.f - subUV.y) * xLerp; \n"
"	weights.z = subUV.y * xLerp.x; \n"
"	weights.w = subUV.y * xLerp.y;\n"
"\n"
"	float w = vsOut.ShTap0.z;\n"
"\n"
"	if (smFormat == SMFORMAT_FLOATW)\n"
"	{\n"
"		w *= Ramp;\n"
"	}\n"
"\n"
"	float tmpValues[4] = { 0.f, 0.f, 0.f, 0.f };\n"
"	// accumulate 4 values at once\n"
"	int k, i = 0;\n"
"	for (k = 0; k < tapCount / 4; k += 4, ++i)\n"
"	{\n"
"		float4 values = float4(ReadShadowMap(taps[k], w, weights, smFormat),\n"
"			ReadShadowMap(taps[k + 1], w, weights, smFormat),\n"
"			ReadShadowMap(taps[k + 2], w, weights, smFormat),\n"
"			ReadShadowMap(taps[k + 3], w, weights, smFormat));\n"
"		tmpValues[i] = dot(values, float4(1, 1, 1, 1));\n"
"	}	\n"
"\n"
"	// remaining values 		\n"
"	for (; k < tapCount; ++k)\n"
"	{\n"
"		tmpValues[3] += ReadShadowMap(taps[k], w, weights, smFormat);\n"
"\n"
"	}\n"
"\n"
"	// accumulate and scale\n"
"	float visibilityValue = dot(float4(tmpValues[0], tmpValues[1], tmpValues[2], tmpValues[3]), float4(1.f / tapCount, 1.f / tapCount, 1.f / tapCount, 1.f / tapCount));\n"
"\n"
"	//visibilityValue *= 1.f / tapCount;\n"
"\n"
"	return lerp(vsOut.ShColor, float4(1, 1, 1, 1), visibilityValue);  \n"
"	//return visibilityValue;\n"
"	//return w - tex2Dproj(ShadowMap, taps[0]).r;\n"
"\n"
"}\n"
"\n"
"\n"
"#define DECLARE_SH_TECH(name, tapCount, lightMode, attenMode, smFormat) \\\n"
"	technique name\\\n"
"{ \\\n"
"	pass p \\\n"
"{ \\\n"
"	VertexShader = compile vs_1_1 ShadowVS(lightMode, attenMode, tapCount, smFormat, ALPHA_TEST_ON); \\\n"
"	PixelShader = compile ps_2_0 ShadowPS(tapCount, smFormat, ALPHA_TEST_ON); \\\n"
"	AlphaBlendEnable = TRUE; \\\n"
"	SrcBlend = ZERO; \\\n"
"	Destblend=SRCCOLOR; \\\n"
"} \\\n"
"} \\\n"
"\n"
"\n"
"\n"
"/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n"
"\n"
"////////////////////\n"
"// SHADOW MAPPING //\n"
"////////////////////\n"
"\n"
"\n"
"///////////\n"
"// 1 TAP //\n"
"///////////\n"
"\n"
"\n"
"\n"
"DECLARE_SH_TECH(SM_1Tap_Unlit_NoLightFactors_HW,      1, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_1Tap_PerspLit_NoLightFactors_HW,   1, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_1Tap_DirLit_NoLightFactors_HW,     1, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"DECLARE_SH_TECH(SM_1Tap_Unlit_UseLightFactors_HW,     1, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_1Tap_PerspLit_UseLightFactors_HW,  1, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_1Tap_DirLit_UseLightFactors_HW,    1, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"\n"
"DECLARE_SH_TECH(SM_1Tap_Unlit_NoLightFactors_FLT,      1, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_1Tap_PerspLit_NoLightFactors_FLT,   1, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_1Tap_DirLit_NoLightFactors_FLT,     1, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"//\n"
"DECLARE_SH_TECH(SM_1Tap_Unlit_UseLightFactors_FLT,     1, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_1Tap_PerspLit_UseLightFactors_FLT,  1, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_1Tap_DirLit_UseLightFactors_FLT,    1, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"\n"
"////////////\n"
"// 5 TAPS //\n"
"////////////\n"
"\n"
"DECLARE_SH_TECH(SM_5Tap_Unlit_NoLightFactors_HW,      5, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_5Tap_PerspLit_NoLightFactors_HW,   5, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_5Tap_DirLit_NoLightFactors_HW,     5, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"DECLARE_SH_TECH(SM_5Tap_Unlit_UseLightFactors_HW,     5, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_5Tap_PerspLit_UseLightFactors_HW,  5, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_5Tap_DirLit_UseLightFactors_HW,    5, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"DECLARE_SH_TECH(SM_5Tap_Unlit_NoLightFactors_FLT,     5, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_5Tap_PerspLit_NoLightFactors_FLT,  5, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_5Tap_DirLit_NoLightFactors_FLT,    5, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"//\n"
"DECLARE_SH_TECH(SM_5Tap_Unlit_UseLightFactors_FLT,    5, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_5Tap_PerspLit_UseLightFactors_FLT, 5, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_5Tap_DirLit_UseLightFactors_FLT,   5, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"\n"
"\n"
"\n"
"////////////\n"
"// 9 TAPS //\n"
"////////////\n"
"\n"
"\n"
"DECLARE_SH_TECH(SM_9Tap_Unlit_NoLightFactors_HW,      9, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_9Tap_PerspLit_NoLightFactors_HW,   9, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_9Tap_DirLit_NoLightFactors_HW,     9, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"DECLARE_SH_TECH(SM_9Tap_Unlit_UseLightFactors_HW,     9, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_9Tap_PerspLit_UseLightFactors_HW,  9, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_9Tap_DirLit_UseLightFactors_HW,    9, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"DECLARE_SH_TECH(SM_9Tap_Unlit_NoLightFactors_FLT,     9, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_9Tap_PerspLit_NoLightFactors_FLT,  9, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_9Tap_DirLit_NoLightFactors_FLT,    9, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"//\n"
"DECLARE_SH_TECH(SM_9Tap_Unlit_UseLightFactors_FLT,     9, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_9Tap_PerspLit_UseLightFactors_FLT,  9, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_9Tap_DirLit_UseLightFactors_FLT,    9, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"\n"
"\n"
"\n"
"/////////////\n"
"// 13 TAPS //\n"
"/////////////\n"
"\n"
"\n"
"/*\n"
"DECLARE_SH_TECH(SM_13Tap_Unlit_NoLightFactors_HW,      13, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"\n"
"\n"
"DECLARE_SH_TECH(SM_13Tap_PerspLit_NoLightFactors_HW,   13, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_13Tap_DirLit_NoLightFactors_HW,     13, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"DECLARE_SH_TECH(SM_13Tap_Unlit_UseLightFactors_HW,     13, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_13Tap_PerspLit_UseLightFactors_HW,  13, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"DECLARE_SH_TECH(SM_13Tap_DirLit_UseLightFactors_HW,    13, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_HW)\n"
"//\n"
"\n"
"DECLARE_SH_TECH(SM_13Tap_Unlit_NoLightFactors_FLT,     13, LIGHTMODE_UNLIT,     NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"\n"
"DECLARE_SH_TECH(SM_13Tap_PerspLit_NoLightFactors_FLT,  13, LIGHTMODE_PERSPLIT,  NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_13Tap_DirLit_NoLightFactors_FLT,    13, LIGHTMODE_DIRLIT,    NO_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"//\n"
"DECLARE_SH_TECH(SM_13Tap_Unlit_UseLightFactors_FLT,    13, LIGHTMODE_UNLIT,     USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_13Tap_PerspLit_UseLightFactors_FLT, 13, LIGHTMODE_PERSPLIT,  USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"DECLARE_SH_TECH(SM_13Tap_DirLit_UseLightFactors_FLT,   13, LIGHTMODE_DIRLIT,    USE_LIGHTFACTORS, SMFORMAT_FLOATW)\n"
"*/\n"
"\n"
"\n"
"/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n"
"\n"
"//////////////////////////\n"
"// SHADOW MAP RENDERING //\n"
"//////////////////////////\n"
"\n"
"\n"
"// Built-in technique to render W buffer -> handle alpha testing with the main diffuse map of material\n"
"\n"
"/*\n"
"technique RenderHWShadowMap\n"
"{\n"
"pass p\n"
"{\n"
"VertexShader = compile vs_1_1 ShadowVS(lightMode, attenMode, tapCount);\n"
"PixelShader = compile ps_2_0 ShadowPS(tapCount, smFormat);\n"
"AlphaBlendEnable = TRUE;\n"
"SrcBlend = ZERO;\n"
"Destblend=SRCCOLOR;\n"
"}\n"
"}\n"
"*/\n"
"\n"
"\n"
"struct RENDER_SM_VS_IN\n"
"{\n"
"	float4 Pos : POSITION;\n"
"	float2 TexCoord  : TEXCOORD0;\n"
"};\n"
"\n"
"struct RENDER_SM_VS_OUT\n"
"{\n"
"	float4 Pos : POSITION; \n"
"	float2 TexCoord  : TEXCOORD0;\n"
"	float  W         : TEXCOORD1; // for w-buffer\n"
"};\n"
"\n"
"\n"
"RENDER_SM_VS_OUT RenderWBufferVS(RENDER_SM_VS_IN vsIn)\n"
"{\n"
"	RENDER_SM_VS_OUT vsOut = (RENDER_SM_VS_OUT) 0;\n"
"	vsOut.Pos = mul(vsIn.Pos, WVP);\n"
"	vsOut.W = WScaleBias.x * vsOut.Pos.w + WScaleBias.y;\n"
"	vsOut.TexCoord = vsIn.TexCoord;\n"
"	return vsOut;\n"
"}\n"
"\n"
"// 'do-it-all' pixel shader : handle textured case as well as alpha test. This is not optimal, but\n"
"// easy to setup on an existing composition\n"
"float4 RenderWBufferPS(in RENDER_SM_VS_OUT vsOut) : COLOR\n"
"{\n"
"	if (alphaTestEnable)\n"
"	{	\n"
"		clip(tex2D(MaterialTextureSampler, vsOut.TexCoord).w - alphaRef); // must emulate alpha test for a float render target...\n"
"	}\n"
"	return vsOut.W;\n"
"}\n"
"\n"
"\n"
"// Built-in technique to render W buffer -> handle alpha testing with the main diffuse map of material\n"
"technique RenderWBuffer\n"
"{\n"
"	pass p\n"
"	{\n"
"		VertexShader = compile vs_1_1 RenderWBufferVS();\n"
"		PixelShader = compile ps_2_0 RenderWBufferPS();	\n"
"	}\n"
"}\n"
"\n"
"////////////////////\n"
"// DEBUG MATERIAL //\n"
"////////////////////\n"
"\n"
"struct DEBUG_MATERIAL_VS_IN\n"
"{\n"
"	float4 Pos : POSITION;\n"
"	float2 TexCoord  : TEXCOORD0;\n"
"};\n"
"\n"
"struct DEBUG_MATERIAL_VS_OUT\n"
"{\n"
"	float4 Pos : POSITION; \n"
"	float2 TexCoord  : TEXCOORD0;\n"
"};\n"
"\n"
"\n"
"DEBUG_MATERIAL_VS_OUT DebugMaterialVS(DEBUG_MATERIAL_VS_IN vsIn)\n"
"{\n"
"	DEBUG_MATERIAL_VS_OUT vsOut = (DEBUG_MATERIAL_VS_OUT) 0;\n"
"	vsOut.Pos = mul(vsIn.Pos, WVP);	\n"
"	vsOut.TexCoord = vsIn.TexCoord;\n"
"	return vsOut;\n"
"}\n"
"\n"
"float4 DebugMaterialPS(in DEBUG_MATERIAL_VS_OUT vsOut) : COLOR\n"
"{\n"
"	if (alphaTestEnable)\n"
"	{	\n"
"		clip(tex2D(MaterialTextureSampler, vsOut.TexCoord).w - alphaRef); // must emulate alpha test for a float render target...\n"
"	}\n"
"	return float4(1, 0, 1, 1);\n"
"}\n"
"\n"
"\n"
"\n"
"// Built-in technique : render debug material (handles alpha test)\n"
"technique DebugMaterial\n"
"{\n"
"	pass p\n"
"	{\n"
"		VertexShader = compile vs_1_1 DebugMaterialVS();\n"
"		PixelShader = compile ps_2_0 DebugMaterialPS();\n"
"		AlphaBlendEnable = TRUE;\n"
"		SrcBlend  = ONE;\n"
"		DestBlend = ONE;\n"
"	}\n"
"\n"
"}\n"
"\n"
"\n"
"\n"
"///////////////////////////////\n"
"// FETCH4 TEXTURE GENERATION //\n"
"///////////////////////////////\n"
"\n"
"// Generate a texture that replicate all neighbour texel depth for fast filtering in the shadow receive shader\n"
"\n"
"struct FETCH4_VS_IN\n"
"{\n"
"	float4 Pos : POSITION;\n"
"	float2 Tap : TEXCOORD0;\n"
"};\n"
"\n"
"struct FETCH4_VS_OUT\n"
"{\n"
"	float4 Pos  : POSITION; \n"
"	float2 Tap0 : TEXCOORD0;\n"
"	float2 Tap1 : TEXCOORD1;\n"
"	float2 Tap2 : TEXCOORD2;\n"
"	float2 Tap3 : TEXCOORD3;\n"
"};\n"
"\n"
"float4 DeltaUV;\n"
"\n"
"FETCH4_VS_OUT RenderFetch4VS(FETCH4_VS_IN vsIn)\n"
"{\n"
"	FETCH4_VS_OUT vsOut = (FETCH4_VS_OUT) 0;\n"
"	vsOut.Pos  = mul(vsIn.Pos, WVP);\n"
"	vsOut.Tap0 = vsIn.Tap;\n"
"	vsOut.Tap1 = vsIn.Tap + DeltaUV.xz;\n"
"	vsOut.Tap2 = vsIn.Tap + DeltaUV.zy;\n"
"	vsOut.Tap3 = vsIn.Tap + DeltaUV.xy;\n"
"	return vsOut;\n"
"}\n"
"\n"
"// 'do-it-all' pixel shader : handle textured case as well as alpha test. This is not optimal, but\n"
"// can be used directly.\n"
"float4 RenderFetch4PS(in FETCH4_VS_OUT vsOut) : COLOR\n"
"{\n"
"	float4 result;\n"
"	result.x = tex2D(UnfilteredShadowMap, vsOut.Tap0).x;\n"
"	result.y = tex2D(UnfilteredShadowMap, vsOut.Tap1).x;\n"
"	result.z = tex2D(UnfilteredShadowMap, vsOut.Tap2).x;\n"
"	result.w = tex2D(UnfilteredShadowMap, vsOut.Tap3).x;\n"
"	return result;\n"
"}\n"
"\n"
"\n"
"// Built-in technique to render W buffer -> handle alpha testing with the main diffuse map of material\n"
"technique RenderFetch4\n"
"{\n"
"	pass p\n"
"	{\n"
"		VertexShader = compile vs_1_1 RenderFetch4VS();\n"
"		PixelShader = compile ps_2_0 RenderFetch4PS();\n"
"		ZEnable = FALSE;\n"
"		ZWriteEnable = FALSE;	  \n"
"	}\n"
"}\n";