621 lines
21 KiB
C++
621 lines
21 KiB
C++
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";
|
|
|