const char g_ShaderVSGeneral[]=
"float4x4 matWVP : register(c0);\n"
"float4x4 matWorld : register(c12);\n"
"float4x4 matWorldI : register(c16);\n"
"float3	 viewPos : register(c4);\n"
"float3	 viewDir : register(c10);\n"
"float4	 res : register(c5);\n"
"struct vsIn\n"
"{\n"
"float4 p : POSITION;\n"
"float3 n : NORMAL;\n"
"float4 c : COLOR;\n"
"float2 t : TEXCOORD;\n"
"};\n"
"struct vsOut\n"
"{\n"
"float4 p : POSITION;\n"
"float4 c : COLOR0;\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"vsOut vs_main(vsIn i) \n"
"{\n"
"vsOut o;\n"
"o.p= mul(i.p, matWVP);\n"
"o.c = i.c;\n"
"o.t = i.t;\n"
"o.w= mul(i.p, matWorld).xyz;\n"
"o.n= mul(i.n, transpose((float3x3)matWorldI));\n"
"o.v= viewPos - o.w;\n"
"o.s = o.p;\n"
"o.s.xy = o.s.xy * float2(.5f, -.5f) + o.s.w * (.5f + .5f * res.zw);\n"
"o.s.z = dot(o.w - viewPos, viewDir);\n"
"return o;\n"
"};\n"
"";

const char g_ShaderPSPhong[]=
"float4 g_fResolution : register(c0);\n"
"float3 g_vLightDir : register(c1);\n"
"sampler1D dif : register(s2);\n"
"sampler1D spec : register(s3);\n"
"sampler2D shadowSampler : register(s4);\n"
"sampler2D depthSampler : register(s5);\n"
"static float4 g_fSpecularPower = {0.85f, 0.85f, 0.85f, 0.85f};\n"
"struct psIn\n"
"{\n"
"float4 c : COLOR0;\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"float4 ps_main(psIn i):color\n"
"{\n"
"float2 sc = i.s.xy / i.s.w;\n"
"float aa = abs( tex2D(depthSampler, sc).x - i.s.z );\n"
"float2 ddaa = float2(ddx(aa), ddy(aa));\n"
"float2 aaetc = sign(-ddaa) * g_fResolution.zw;\n"
"sc += aaetc * saturate(4.f * aa);\n"
"float4 fColor = i.c;\n"
"float fS= 0.2f + 0.8f * tex2D(shadowSampler, sc);\n"
"float3 n = normalize(i.n);\n"
"fColor.xyz *= tex1D( dif, fS * ( 0.5f + 0.5f * dot( n, -g_vLightDir) ) );\n"
"float3 h = normalize( normalize(i.v) + -g_vLightDir );\n"
"float s = dot(n, h);\n"
"fColor.xyz += g_fSpecularPower * tex1D(spec, fS * ( 0.5f + 0.5f * s ) );\n"
"return fColor;\n"
"}\n"
"";

const char g_ShaderPSRainbow[]=
"float4 g_fResolution : register(c0);\n"
"float3 g_vLightDir : register(c1);\n"
"sampler2D tex : register(s0);\n"
"sampler1D dif : register(s2);\n"
"sampler1D spec : register(s3);\n"
"sampler2D shadowSampler : register(s4);\n"
"sampler2D depthSampler : register(s5);\n"
"static float4 g_fSpecularPower = {0.85f, 0.85f, 0.85f, 0.85f};\n"
"struct psIn\n"
"{\n"
"float4 c : COLOR0;\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"float4 ps_main(psIn i):color\n"
"{\n"
"float2 sc = i.s.xy / i.s.w;\n"
"float aa = abs( tex2D(depthSampler, sc).x - i.s.z );\n"
"float2 ddaa = float2(ddx(aa), ddy(aa));\n"
"float2 aaetc = sign(-ddaa) * g_fResolution.zw;\n"
"sc += aaetc * saturate(4.f * aa);\n"
"float4 fColor = i.c * tex2D( tex, i.t );\n"
"float fS= 0.125f + 0.875f * tex2D(shadowSampler, sc);\n"
"fColor.xyz *= tex1D(dif, fS * ( 0.5f + 0.5f * dot( i.n, -g_vLightDir) ));\n"
"float3 h = normalize( normalize(i.v) + -g_vLightDir );\n"
"float s = dot(i.n, h);\n"
"fColor.xyz += g_fSpecularPower * tex1D(spec, fS * ( 0.5f + 0.5f * s ) );\n"
"return fColor;\n"
"}\n"
"";

const char g_ShaderPSTarmac[]=
"float4 g_fResolution : register(c0);\n"
"float3 g_vLightDir : register(c1);\n"
"sampler3D randomSampler : register(s0);\n"
"sampler1D diffSampler : register(s2);\n"
"sampler1D specSampler : register(s3);\n"
"sampler2D shadowSampler : register(s4);\n"
"sampler2D depthSampler : register(s5);\n"
"static float g_fTileHardness = .6f;\n"
"static float g_fTileDepth = 8.f;\n"
"static float g_fBumpDepth = .75f;\n"
"static float g_fTexScale = 1.f;\n"
"static float g_fSpecularPower = 0.5f;\n"
"static float g_fSpecularHardness = 32.f;\n"
"struct psIn\n"
"{\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"float rand_val(float4 r)\n"
"{\n"
"float lr = dot(r, float4(10.f, 100.f, 1000.f, 1.f));\n"
"return lr / 1111.f;\n"
"}\n"
"float noise(float3 t)\n"
"{\n"
"float4 r = tex3D(randomSampler, .03125f * t);\n"
"return rand_val(r)* 2.f - 1.f;\n"
"}\n"
"float noise_grad(float3 t, float3 dtX, float3 dtY)\n"
"{\n"
"float4 r = tex3Dgrad(randomSampler, .03125f * t, .0625f * dtX, .0625f * dtY);\n"
"return rand_val(r)* 2.f - 1.f;\n"
"}\n"
"float abs_noise(float3 t)\n"
"{\n"
"return abs( noise(t) );\n"
"}\n"
"float abs_noise_grad(float3 t, float3 dtX, float3 dtY)\n"
"{\n"
"return abs( noise_grad(t, dtX, dtY) );\n"
"}\n"
"float4 ps_main(psIn i) : COLOR0\n"
"{\n"
"float3 t = i.w * g_fTexScale;\n"
"float3 pw = i.w.xxz; pw.y = 0.0f; \n"
"float3 pt = pw * g_fTexScale + .5f;\n"
"float3 tt = floor(pt);\n"
"float3 dttX = ddx(pt);\n"
"float3 dttY = ddy(pt);\n"
"float3 fColor = 0.15f * saturate( dot(1.f, abs(dttX) + abs(dttY)) );\n"
"fColor += abs_noise_grad(tt, dttX, dttY);\n"
"fColor += abs_noise(2.f * t) / 8.f;\n"
"fColor += noise(4.f * t) / 8.f;\n"
"float fDetail = noise(8.f * t) / 16.f;\n"
"fDetail += noise(16.f * t) / 16.f;\n"
"fDetail += noise(32.f * t) / 32.f;\n"
"fDetail += noise(128.f * t) / 32.f;\n"
"fDetail += noise(1024.f * t) / 32.f;\n"
"fColor += fDetail;\n"
"fColor = 1.0f - saturate(fColor);\n"
"fColor *= fColor;\n"
"fColor = 1.0f - fColor;\n"
"float3 tb = 2.f * frac(pt) - 1.f;\n"
"float3 te = tb * tb; \n"
"te *= te; \n"
"te *= te; \n"
"float tdd = saturate(1.f - 2.f * fwidth(pt));\n"
"float td = saturate( dot(tdd, te) );\n"
"float3 tc = 1.f - td;\n"
"float3 ti = saturate(td - g_fTileHardness);\n"
"float3 n = normalize(i.n + g_fBumpDepth * g_fTileDepth * ti * tb);\n"
"float2 sc = i.s.xy / i.s.w;\n"
"float aa = abs( tex2D(depthSampler, sc).x - i.s.z );\n"
"float2 ddaa = float2(ddx(aa), ddy(aa));\n"
"float2 aaetc = sign(-ddaa) * g_fResolution.zw;\n"
"sc += aaetc * saturate(4.f * aa);\n"
"float fShadow = 0.2f + 0.8f * (float)tex2D(shadowSampler, sc);\n"
"fColor *= tex1D( diffSampler, fShadow * (0.5f + 0.5f * dot(n, -g_vLightDir)) ).xyz;\n"
"float3 h = normalize( normalize(i.v) + -g_vLightDir );\n"
"float s =  0.5f + 0.5f * dot(n, h);\n"
"s *= saturate(1.f + g_fBumpDepth * fDetail);\n"
"fColor += g_fSpecularPower * tex1D(specSampler, fShadow * s).xyz; \n"
"fColor *= tc;\n"
"return float4(fColor, 1.0f);\n"
"}\n"
"";

const char g_ShaderPSWall[]=
"float4 g_fResolution : register(c0);\n"
"float3 g_vLightDir : register(c1);\n"
"float4 g_fTime : register(c3);\n"
"sampler3D randomSampler : register(s0);\n"
"sampler2D tex : register(s1);\n"
"sampler1D diffSampler : register(s2);\n"
"sampler1D specSampler : register(s3);\n"
"sampler2D shadowSampler : register(s4);\n"
"sampler2D depthSampler : register(s5);\n"
"static float g_fVariation = .1f;\n"
"static float g_fBumpDepth = .02f;\n"
"static float g_fBumpFalloff = 256.f;\n"
"static float g_fTexScale = 1.f;\n"
"static float g_fSpecularPower = 0.2f;\n"
"static float g_fSpecularHardness = 32.f;\n"
"struct psIn\n"
"{\n"
"float4 c : COLOR0;\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"float noise(float3 t)\n"
"{\n"
"float4 r = tex3D(randomSampler, .03125f * t);\n"
"float lr = dot(r, float4(1.f, 10.f, 100.f, 1000.f));\n"
"return lr * 2.f / 1111.f - 1.f;\n"
"}\n"
"float abs_noise(float3 t) { return abs( noise(t) ); }\n"
"float4 ps_main(psIn i) : COLOR0\n"
"{\n"
"float3 t = i.w * g_fTexScale;\n"
"float4 fColor = i.c;\n"
"float fStruct = noise(t) / 2.f;\n"
"fStruct += noise(4.f * t) / 4.f;\n"
"fStruct += noise(8.f * t) / 8.f;\n"
"fStruct += noise(16.f * t) / 16.f;\n"
"fStruct += noise(32.f * t) / 32.f;\n"
"fColor.xyz *= (1.f - g_fVariation) + g_fVariation * fStruct;\n"
"float fDetail = noise(81.f * t) / 2.f;\n"
"fDetail += noise(243.f * t) / 4.f;\n"
"fDetail += noise(729.f * t) / 8.f;\n"
"float3 pp = i.w + i.n * g_fBumpDepth * (fStruct + fDetail / 16.f); \n"
"float3 ddppx = ddx(pp);\n"
"float3 ddppy = ddy(pp);\n"
"float3 n = normalize( cross(ddppx, ddppy) );\n"
"float3 wrd= float3(\n"
"round( i.w.x / g_fTime.w ) * g_fTime.w,\n"
"round( i.w.y / g_fTime.w ) * g_fTime.w,\n"
"round( i.w.z / g_fTime.w ) * g_fTime.w );\n"
"float fOffset= 33.0f - wrd.z / 8.0f - g_fTime / 56.0f;\n"
"if( fOffset < 0.0f )\n"
"{\n"
"fOffset= 0.0f;\n"
"}\n"
"float plasmaVal = \n"
"sin( sin ( 0.021f * g_fTime + wrd.y * 0.23f ) * 0.7f + wrd.x * 0.09f ) \n"
"+ sin( 0.009f * g_fTime + sin ( wrd.z * 0.35f ) * 0.9f + wrd.y * 0.47f ) \n"
"+ sin( sin ( 0.013f * g_fTime + wrd.x * 0.17f ) * 1.3f + wrd.z * 0.13f ) \n"
"+ fOffset;\n"
"if( plasmaVal > 0.0f && plasmaVal < 1.0f )\n"
"{\n"
"fColor.xyz= tex2D( tex, plasmaVal ).xyz;\n"
"}\n"
"float2 sc = i.s.xy / i.s.w;\n"
"float aa = abs( tex2D(depthSampler, sc).x - i.s.z );\n"
"float2 ddaa = float2(ddx(aa), ddy(aa));\n"
"float2 aaetc = sign(-ddaa) * g_fResolution.zw;\n"
"sc += aaetc * saturate(4.f * aa);\n"
"float fShadow = 0.2f + 0.8f * (float)tex2D(shadowSampler, sc);\n"
"fColor.xyz *= tex1D( diffSampler, fShadow * (0.5f + 0.5f * dot(n, -g_vLightDir)) ).xyz;\n"
"float3 h = normalize( normalize(i.v) + -g_vLightDir );\n"
"float s = saturate( dot(n, h) );\n"
"fColor.xyz += g_fSpecularPower *  tex1D(specSampler, fShadow * s).xyz;\n"
"return fColor;\n"
"}\n"
"";

const char g_ShaderPSGrass[]=
"float4 g_fResolution : register(c0);\n"
"float3 g_vLightDir : register(c1);\n"
"sampler2D randomSampler : register(s0);\n"
"sampler1D diffSampler : register(s2);\n"
"sampler2D shadowSampler : register(s4);\n"
"sampler2D depthSampler : register(s5);\n"
"static float3 g_fColor = float3(0.45f, 0.5f, 0.18f); \n"
"static float g_fTexScale = .25f;\n"
"static float g_fDensity = 3.f;\n"
"static float2 g_fInnerOuterRadiusSq = float2(240.f * 240.f, 380.f * 380.f);\n"
"static float4 g_fHaze = float4(0.765f, 0.808f, 0.871f, -0.3f);\n"
"static float2 g_fHazeDensityIntensity = float2(0.25f, 0.6f);\n"
"struct psIn\n"
"{\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"float noise(float2 t)\n"
"{\n"
"float4 r = tex2D(randomSampler, .03125f * t);\n"
"float lr = dot(r, float4(1.f, 10.f, 100.f, 1000.f));\n"
"return lr * 2.f / 1111.f - 1.f;\n"
"}\n"
"float abs_noise(float2 t) { return abs( noise(t) ); }\n"
"float4 ps_main(psIn i):color\n"
"{\n"
"float2 t = i.w.xz * g_fTexScale;\n"
"float fCenterDist = dot(i.w.xz, i.w.xz) - g_fInnerOuterRadiusSq.x;\n"
"fCenterDist /= g_fInnerOuterRadiusSq.y - g_fInnerOuterRadiusSq.x;\n"
"float4 fColor = abs_noise(t) / 2.f;\n"
"fColor.xyz = 0.5f + 0.1f * fColor.xyz;\n"
"fColor.zw += noise(2.f * t) / float2(32.f, 4.f);\n"
"fColor.xw += noise(4.f * t) / float2(64.f, 8.f);\n"
"fColor.yw += noise(8.f * t) / float2(16.f, 16.f);\n"
"fColor.xyz += noise(16.f * t) / 16.f;\n"
"fColor.xyz += noise(32.f * t) / 32.f;\n"
"fColor.xyz += noise(128.f * t) / 32.f;\n"
"fColor.xyz += noise(1024.f * t) / 32.f;\n"
"fColor.xyz *= 2.f * fColor.xyz;\n"
"fColor.xyz *= g_fColor;\n"
"fColor.w = saturate(g_fDensity * fColor.w + fCenterDist);\n"
"float2 sc = i.s.xy / i.s.w;\n"
"float aa = abs( tex2D(depthSampler, sc).x - i.s.z );\n"
"float2 ddaa = float2(ddx(aa), ddy(aa));\n"
"float2 aaetc = sign(-ddaa) * g_fResolution.zw;\n"
"sc += aaetc * saturate(4.f * aa);\n"
"float fShadow = 0.2f + 0.8f * (float)tex2D(shadowSampler, sc);\n"
"fColor.xyz *= tex1D( diffSampler, fShadow * (0.5f + 0.5f * dot(normalize(i.n), -g_vLightDir)) ).xyz;\n"
"fColor.xyz = lerp( fColor.xyz, g_fHaze,\n"
"saturate(g_fHazeDensityIntensity.x * fCenterDist) * g_fHazeDensityIntensity.y );\n"
"fColor.xyz *= fColor.a;\n"
"return fColor;\n"
"}\n"
"";

const char g_ShaderPSDepth[]=
"float4 ps_main(float4 s : TEXCOORD3):color\n"
"{\n"
"return s.z;\n"
"}\n"
"";

const char g_ShaderPSText[]=
"float4 g_fResolution : register(c0);\n"
"float3 g_vLightDir : register(c1);\n"
"sampler1D dif : register(s2);\n"
"sampler1D spec : register(s3);\n"
"sampler2D shadowSampler : register(s4);\n"
"sampler2D depthSampler : register(s5);\n"
"static float4 g_fSpecularPower = {1.15f, 1.05f, 1.0f, 1.25f};\n"
"struct psIn\n"
"{\n"
"float4 c : COLOR0;\n"
"float2 t : TEXCOORD0;\n"
"float3 n : TEXCOORD1;\n"
"float3 v : TEXCOORD2;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"float4 ps_main(psIn i):color\n"
"{\n"
"float2 sc = i.s.xy / i.s.w;\n"
"float aa = abs( tex2D(depthSampler, sc).x - i.s.z );\n"
"float2 ddaa = float2(ddx(aa), ddy(aa));\n"
"float2 aaetc = sign(-ddaa) * g_fResolution.zw;\n"
"sc += aaetc * saturate(4.f * aa);\n"
"float3 fColor = float3( 0.25f, 0.3f, 0.4f );\n"
"float fS= 0.2f + 0.8f * tex2D(shadowSampler, sc);\n"
"float3 n = normalize(i.n);\n"
"fColor.xyz *= tex1D( dif, fS * ( 0.5f + 0.5f * dot( n, -g_vLightDir) ) );\n"
"float3 h = normalize( normalize(i.v) + -g_vLightDir );\n"
"float s = dot( n, h);\n"
"fColor += g_fSpecularPower * tex1D(spec, fS * ( 0.5f + 0.5f * s ) );\n"
"return float4(fColor, 1.0f);\n"
"}\n"
"";

const char g_ShaderVSSky[]=
"float4x4 matWVP : register(c0);\n"
"float3	 viewPos : register(c4);\n"
"struct vsOut\n"
"{\n"
"float4 p : POSITION;\n"
"float4 s : TEXCOORD3;\n"
"float3 w : TEXCOORD4;\n"
"};\n"
"vsOut vs_main(float4 p : POSITION) \n"
"{\n"
"vsOut o;\n"
"o.p = p;\n"
"o.p.xyz += viewPos;\n"
"o.p= mul(o.p, matWVP);\n"
"o.p.z= (1.f - 4.8e-6f) * o.p.w;\n"
"o.w= p.xyz;\n"
"o.s= 4.e3f;\n"
"return o;\n"
"};\n"
"";

const char g_ShaderPSSky[]=
"float3 g_vLightDir : register(c1); \n"
"float3 g_fTime : register(c3);\n"
"sampler3D randomSampler : register(s0);\n"
"static float4 g_fSky = float4(0.392f, 0.502f, 0.702f, 0.7f);\n"
"static float4 g_fHaze = float4(0.765f, 0.808f, 0.871f, -0.3f);\n"
"static float g_fSunSize = .0025f;\n"
"static float g_fCoronaSize = .005f;\n"
"static float4 g_fSunColor = float4(0.925f, 1.0f, 0.75f, 1.f);\n"
"float4 clouds(float3 d, float4 color)\n"
"{\n"
"float3 t = float3(g_fTime.x*0.001, 0, 0);\n"
"float3 bumpOffset = float3(0.f, .07f, 0.f);\n"
"float3 d1 = normalize(d + bumpOffset), d2 = normalize(d + cross(bumpOffset, d));\n"
"float4 cloud = tex3D(randomSampler, float3(0.2,0.6,0.2) * d);\n"
"float4 cloud1 = tex3D(randomSampler, float3(0.2,0.6,0.2) * d1);\n"
"float4 cloud2 = tex3D(randomSampler, float3(0.2,0.6,0.2) * d2);\n"
"float cover = g_fTime.z;\n"
"float3 smoothAlpha = float3(cloud.a, cloud1.a, cloud2.a);\n"
"smoothAlpha = saturate( smoothAlpha - max(cover - smoothAlpha, 0.f) * .25f );\n"
"float bumpDepth = .5f;\n"
"float3 cloudel = d + d * (bumpDepth - bumpDepth * smoothAlpha.x);\n"
"float3 cloudel1 = d1 + d1 * (bumpDepth - bumpDepth * smoothAlpha.y);\n"
"float3 cloudel2 = d2 + d2 * (bumpDepth - bumpDepth * smoothAlpha.z);\n"
"float3 normal = normalize( cross(cloudel1 - cloudel, cloudel2 - cloudel) );\n"
"cloud *= 0.5;\n"
"cloud += tex3D(randomSampler, float3(0.4,1.2,0.4) * (d + t)) * 0.25;\n"
"cloud += tex3D(randomSampler, float3(0.8,2.4,0.8) * d) * 0.125;\n"
"cloud += tex3D(randomSampler, float3(1.6,4.8,1.6) * (d + t)) * 0.0625;\n"
"cloud.a = saturate( saturate( cloud.a * 2.5f ) - max(cover - cloud.a, 0.f) * 25.f );\n"
"float3 sdd = d + g_vLightDir;\n"
"float sd = dot(sdd, sdd);\n"
"float s = g_fCoronaSize / ( g_fCoronaSize + saturate(sd - g_fSunSize) );\n"
"float light = 0.5f + 0.7f * dot(normal, -g_vLightDir);\n"
"float3 stormNormal = normalize(cloud.xyz * 2 - 1);\n"
"float stormLight = 0.5f + 0.5f * dot(stormNormal, g_vLightDir);\n"
"cloud.xyz = lerp(cloud.xyz, stormLight, 0.3f * saturate(1.f - cover));\n"
"cloud.xyz = dot(cloud.xyz, .3f) + 0.1f * cloud.xyz;\n"
"cloud.xyz = 1.f - .65f * cloud.xyz * (1.f - 0.2f * cover);\n"
"cloud.xyz += 0.4f * light * saturate(cover);\n"
"cloud.xyz = cloud.a * cloud.xyz + (1 - cloud.a) * color.xyz;\n"
"cloud.xyz += (1 - 0.5f * cloud.a) * g_fSunColor.xyz * s;\n"
"float3 riseColor = float3(0.9,0.8,0) * (1 - g_fTime.z * 0.5);\n"
"float a = pow( max(0, dot(g_vLightDir, -d)), 2 ) * 0.7 * (1.f - .9f * abs(g_vLightDir.y));\n"
"float risefac = -1.f - g_vLightDir.y;\n"
"if (sign(dot(g_vLightDir, d)) > 0)\n"
"risefac = -1.0;\n"
"cloud.xyz += max( 0, a * lerp( riseColor, 1, min(1.0, risefac*1.5) + risefac ) );\n"
"cloud.a = 1.f;\n"
"return cloud;\n"
"}\n"
"float4 ps_main(float3 w : TEXCOORD4):color\n"
"{\n"
"float4 fColor = g_fSky;\n"
"float3 d = normalize(w);\n"
"float g1 = saturate( (d.y - g_fSky.w) / (g_fHaze.w - g_fSky.w) );\n"
"fColor.xyz = lerp(g_fSky.xyz, g_fHaze.xyz, g1);\n"
"return clouds(d, fColor);\n"
"}\n"
"";

const char g_ShaderVSFSQuad[]=
"float4x4	matWVP				: register(c0);\n"
"float4		res					: register(c5);\n"
"float3		viewPos				: register(c4);\n"
"float3		lightDir			: register(c6);\n"
"float3x3	viewMatrixRotInv	: register(c7);\n"
"float4		projScaleOffsetInv	: register(c11);\n"
"struct vsOut\n"
"{\n"
"float4 p : POSITION;\n"
"float2 t : TEXCOORD0;\n"
"float3 e : TEXCOORD1;\n"
"float2 l : TEXCOORD2;\n"
"};\n"
"vsOut vs_main(float4 p : POSITION)\n"
"{\n"
"vsOut o = { p, p.xy, p.xyw, (float2)0.f };\n"
"o.p.xy += float2(-1.f, 1.f) * res.zw;\n"
"o.t = o.t * float2(.5f, -.5f) + .5f;\n"
"o.e.xy = o.e.xy * projScaleOffsetInv.xy + projScaleOffsetInv.zw;\n"
"o.e = mul(o.e, viewMatrixRotInv);\n"
"o.e.xy += float2(-1.f, 1.f) * res.zw;\n"
"float4 lightPos = mul( float4(viewPos - lightDir, 1.0f), matWVP );\n"
"o.l = clamp( lightPos.xy / abs(lightPos.w), -1.f, 1.f );\n"
"o.l = o.l * float2(.5f, -.5f) + .5f;\n"
"return o;\n"
"};\n"
"";

const char g_ShaderPSPSSM[]=
"float2		g_fResolution							: register(c0);\n"
"float3		g_vViewPos								: register(c2);\n"
"float		g_fSplit								: register(c23);\n"
"float4x4	g_mShadowVP								: register(c24);\n"
"float3		g_vShadowViewPos						: register(c28);\n"
"float3		g_vShadowViewDir						: register(c29);\n"
"float4		g_fShadowMapScalingRes					: register(c30);\n"
"sampler2D shadowMapSampler : register(s0);\n"
"sampler2D depthSampler : register(s1);\n"
"sampler2D ditherSampler : register(s2);\n"
"static float g_fRadius = 6.0f / 64.0f;\n"
"static float g_fBias = 4.0f / 64.0f;\n"
"static float g_fDepthBias = 16.0f / 64.0f;\n"
"static float g_fBiasFalloff = 1.5f / 64.0f;\n"
"static float g_fSharpness = 640.0f / 64.0f;\n"
"static float g_fBlurSharpness = 640.0f / 64.0f;\n"
"static float g_fDepthBlurSharpness = 16.0f / 64.0f;\n"
"static const float2 s_vShadowDisc[] = {\n"
"float2(-0.326212f, -0.40581f),\n"
"float2(-0.840144f, -0.07358f),\n"
"float2(-0.695914f, 0.457137f),\n"
"float2(-0.203345f, 0.620716f),\n"
"float2(0.96234f, -0.194983f),\n"
"float2(0.473434f, -0.480026f),\n"
"float2(0.519456f, 0.767022f),\n"
"float2(0.185461f, -0.893124f),\n"
"float2(0.507431f, 0.064425f),\n"
"float2(0.89642f, 0.412458f),\n"
"float2(-0.32194f, -0.932615f),\n"
"float2(-0.791559f, -0.59771f)\n"
"};\n"
"float4 ps_main(float2 TexCoord : TEXCOORD0, float3 EyeDir : TEXCOORD1) : COLOR0\n"
"{\n"
"float fEyeDepth = tex2D(depthSampler, TexCoord).x;\n"
"float4 vEyePoint = float4(g_vViewPos + fEyeDepth * EyeDir, 1.0f);\n"
"float4 vShadowCoord = mul(vEyePoint, g_mShadowVP);\n"
"vShadowCoord.z = dot(vEyePoint.xyz - g_vShadowViewPos, g_vShadowViewDir);\n"
"vShadowCoord.xy = vShadowCoord.xy * float2(.5f, -.5f)\n"
"+ vShadowCoord.w * (.5f + .5f / g_fShadowMapScalingRes.zw);\n"
"float2 fScaledRadius = g_fRadius * g_fShadowMapScalingRes.xy;\n"
"float2 vShadowCoordProj = vShadowCoord.xy / vShadowCoord.w;\n"
"clip( float4(vShadowCoordProj, 1.0f - vShadowCoordProj) - fScaledRadius.xyxy );\n"
"float4 vShadowCoordDDX = ddx(vShadowCoord), vShadowCoordDDY = ddy(vShadowCoord);\n"
"float2 vShadowCoordDeltaDepth = float2(\n"
"vShadowCoordDDX.y * vShadowCoordDDY.z - vShadowCoordDDY.y * vShadowCoordDDX.z,\n"
"vShadowCoordDDY.x * vShadowCoordDDX.z - vShadowCoordDDX.x * vShadowCoordDDY.z )\n"
"/ (vShadowCoordDDY.x * vShadowCoordDDX.y - vShadowCoordDDX.x * vShadowCoordDDY.y);\n"
"vShadowCoordDeltaDepth = vShadowCoord.w * clamp(vShadowCoordDeltaDepth, -16.f, 16.f);\n"
"float fAdaption = 1.f / (1.0f + g_fBiasFalloff * fEyeDepth);\n"
"float fAdaptedBias = g_fBias; \n"
"float fAdaptedBlurSharpness = lerp(g_fDepthBlurSharpness, g_fBlurSharpness, fAdaption);\n"
"float fReferenceDepth = vShadowCoord.z - fAdaptedBias;\n"
"float4 vRotation = tex2D(ditherSampler, TexCoord * g_fResolution / 32.0f) * 2.0f - 1.0f;\n"
"float2x2 mRotation = float2x2(vRotation.xy, vRotation.zw);\n"
"float fShadow = -1.f;\n"
"float fSampleWeight = 1.f / 6;\n"
"for(int i = 0; i < 12; )\n"
"{\n"
"float4 fSampleDepth;\n"
"[unroll] for(int j = 0; j < 4; j++, i++)\n"
"{\n"
"float2 vSampleOffset = fScaledRadius * mul(s_vShadowDisc[i], mRotation);\n"
"float fSampleDeltaDepth = dot(vSampleOffset * vShadowCoordDeltaDepth, 1.f);\n"
"fSampleDepth[j] = tex2D(shadowMapSampler, vShadowCoordProj + vSampleOffset).x - fSampleDeltaDepth;\n"
"}\n"
"float4 fOcclusion = saturate(fAdaptedBlurSharpness * (fReferenceDepth - fSampleDepth));\n"
"fShadow += dot(fOcclusion, fSampleWeight);\n"
"}\n"
"return (1.0f - fShadow); \n"
"}\n"
"";

const char g_ShaderPSAmbOcc[]=
"float4	 res : register(c0);\n"
"sampler2D colorSampler : register(s0);\n"
"sampler2D depthSampler : register(s1);\n"
"sampler2D ditherSampler : register(s2);\n"
"static float g_fRadiusBase = 0.005f;\n"
"static float g_fRadiusScale = 0.25f;\n"
"static float g_fFallOff = 0.7f;\n"
"static float g_fIntensity = 1.25f;\n"
"static float g_fGrain = 0.01f;\n"
"static float g_fRange = 1024.0f;\n"
"static float g_fBlurSensitivity = 250.f;\n"
"static const float3 vSamplePoints[12] = {\n"
"float3(0.083333f, 0.000000f, 0.083333f),\n"
"float3(-0.144338f, -0.083333f, 0.166667f),\n"
"float3(0.125000f, 0.216506f, 0.250000f),\n"
"float3(0.000000f, -0.333333f, 0.333333f),\n"
"float3(-0.208333f, 0.360844f, 0.416667f),\n"
"float3(0.433013f, -0.250000f, 0.500000f),\n"
"float3(-0.583333f, -0.000000f, 0.583333f),\n"
"float3(0.577350f, 0.333333f, 0.666667f),\n"
"float3(-0.375000f, -0.649519f, 0.750000f),\n"
"float3(-0.000000f, 0.833333f, 0.833333f),\n"
"float3(0.458333f, -0.793857f, 0.916667f),\n"
"float3(-0.866025f, 0.500000f, 1.000000f)\n"
"};\n"
"float4 ps_main(float2 TexCoord : TEXCOORD0) : COLOR0\n"
"{\n"
"float4 vRotation = tex2D(ditherSampler, TexCoord * res.xy / 32.0f) * 2.0f - 1.0f;\n"
"float2x2 mRotation = float2x2(vRotation.xy, vRotation.zw);\n"
"float fDepth = tex2D(depthSampler, TexCoord).x;\n"
"float3 fScaledRadius = g_fRadiusBase + g_fRadiusScale / ( 8.0f + fDepth );\n"
"fScaledRadius = clamp(fScaledRadius, 4.0f * res.z, 64.0f * res.w);\n"
"fScaledRadius.z *= fDepth;\n"
"float fOcclusion = 0.0f;\n"
"float fSampleWeight = 1.f / 18.849556f;		\n"
"for(int i = 0; i < 12; )\n"
"{\n"
"float4 fSampleDepth, fSampleRadius;\n"
"[unroll] for(int j = 0; j < 4; j++, i++)\n"
"{\n"
"float3 vSampleOffset = fScaledRadius * vSamplePoints[i];\n"
"vSampleOffset.xy = mul(vSampleOffset.xy, mRotation);\n"
"fSampleDepth[j] = tex2D(depthSampler, TexCoord + vSampleOffset.xy).x;\n"
"fSampleRadius[j] = vSampleOffset.z;\n"
"}\n"
"float4 fDeltaDepth = (fDepth - fSampleDepth) / fSampleRadius;\n"
"float4 fAttenuation = g_fFallOff * fDeltaDepth;\n"
"float4 fBlocking = atan(fDeltaDepth) / (1.0f + max(0.0f, fAttenuation));	\n"
"fOcclusion += dot(fBlocking, fSampleWeight);\n"
"}\n"
"float2 fPixelPos = TexCoord * 2.0f - 1.0f;\n"
"float fBorderAttenuation = 1.0f - 0.7071f * dot(fPixelPos, fPixelPos);\n"
"float fAO = saturate(g_fIntensity * fOcclusion + g_fGrain) * fBorderAttenuation * step(fDepth, g_fRange);\n"
"return float4((float3)fAO, 0.f);\n"
"}\n"
"float4 ps_blur(float2 TexCoord, uniform bool bVertical)\n"
"{\n"
"float2 fStepSize = float2(1.f, bVertical ? -1.f : 1.f) * res.zw;\n"
"float3 fCenterDepths;\n"
"fCenterDepths.x = tex2D(depthSampler, TexCoord - fStepSize).x;\n"
"fCenterDepths.y = tex2D(depthSampler, TexCoord).x;\n"
"fCenterDepths.z = tex2D(depthSampler, TexCoord + fStepSize).x;\n"
"float3 fDepthContinuities, fDepthDeltas;\n"
"fDepthContinuities.x = tex2D(depthSampler, TexCoord - 2.0f * fStepSize).x;\n"
"fDepthContinuities.y = fCenterDepths.x;\n"
"fDepthContinuities.z = tex2D(depthSampler, TexCoord + 2.0f * fStepSize).x;\n"
"fDepthDeltas = fDepthContinuities - fCenterDepths.yzy;\n"
"fDepthContinuities += fCenterDepths.yzy - 2.0f * fCenterDepths;\n"
"fDepthContinuities = abs(fDepthContinuities);\n"
"fDepthDeltas = abs(fDepthDeltas);\n"
"fDepthDeltas -= min(min(fDepthDeltas.x, fDepthDeltas.y), fDepthDeltas.z);\n"
"float3 fWeights = 1.0f / (1.0f + g_fBlurSensitivity * (fDepthContinuities + 16.f * fDepthDeltas));\n"
"float fOutput = 0.0f;\n"
"float3 fSamples;\n"
"float3 fSampleWeights = float3(3.0f, 1.5f, 1.0f);\n"
"fSamples.x = tex2D(colorSampler, TexCoord - 2.0f * fStepSize).x;\n"
"fSamples.y = tex2D(colorSampler, TexCoord - fStepSize).x;\n"
"fSamples.z = tex2D(colorSampler, TexCoord).x;\n"
"fOutput += dot(fSamples, fWeights.x);\n"
"fSamples.x = tex2D(colorSampler, TexCoord + fStepSize).x;\n"
"fOutput += dot(fSamples, fWeights.y);\n"
"fSamples.y = tex2D(colorSampler, TexCoord + 2.0f * fStepSize).x;\n"
"fOutput += dot(fSamples, fWeights.z);\n"
"float fOutputWeight = dot(fWeights, 1.0f);\n"
"fOutput /= 3.0f * fOutputWeight;\n"
"float fCorrectionWeight = saturate(1.0f - fOutputWeight);\n"
"fOutput = (1.0f - fCorrectionWeight) * fOutput + fCorrectionWeight * fSamples.z;\n"
"return float4((float3)fOutput, 0.f);\n"
"}\n"
"float4 ps_blur_hor(float2 TexCoord : TEXCOORD0) : COLOR0 { return ps_blur(TexCoord, false); }\n"
"float4 ps_blur_ver(float2 TexCoord : TEXCOORD0) : COLOR0 { return ps_blur(TexCoord, true); }\n"
"";

const char g_ShaderPSDOF[]=
"float4	 res : register(c0);\n"
"float2   Dist : register(c3);\n"
"sampler2D colorSampler : register(s0);\n"
"sampler2D depthSampler : register(s1);\n"
"sampler2D blurSampler : register(s4);\n"
"static float g_fRadius = 0.005f;\n"
"static float g_fLowRadiusScaling = 0.4f;\n"
"static float g_fNearPlane = 1.0f;\n"
"static float g_fFocalPlane = Dist.y;\n"
"static float g_fDistScale = 1.0f / pow( g_fFocalPlane , 2.5f );\n"
"static float g_fFarPlane= 128.0f;\n"
"static const float2 vPoissonDisc[] = {\n"
"float2(-0.326212f, -0.40581f),\n"
"float2(-0.840144f, -0.07358f),\n"
"float2(-0.695914f, 0.457137f),\n"
"float2(-0.203345f, 0.620716f),\n"
"float2(0.96234f, -0.194983f),\n"
"float2(0.473434f, -0.480026f),\n"
"float2(0.519456f, 0.767022f),\n"
"float2(0.185461f, -0.893124f),\n"
"float2(0.507431f, 0.064425f),\n"
"float2(0.89642f, 0.412458f),\n"
"float2(-0.32194f, -0.932615f),\n"
"float2(-0.791559f, -0.59771f)\n"
"};\n"
"float4 ps_blur_intensity(float2 TexCoord : TEXCOORD0) : COLOR0\n"
"{\n"
"float fDepth = tex2D(depthSampler, TexCoord).x;\n"
"float4 fDDTexCoords1 = TexCoord.xyxy, fDDTexCoords2 = TexCoord.xyxy;\n"
"fDDTexCoords1.zw -= res.zw; fDDTexCoords2.zw += res.zw;\n"
"float4 fDDDepth4 = fDepth - float4(\n"
"tex2D(depthSampler, fDDTexCoords1.zy).x, tex2D(depthSampler, fDDTexCoords1.xw).x,\n"
"tex2D(depthSampler, fDDTexCoords2.zy).x, tex2D(depthSampler, fDDTexCoords2.xw).x );\n"
"float2 fDeltaDepth2 = max(fDDDepth4.xy, fDDDepth4.zw);\n"
"float fDeltaDepth = max(fDeltaDepth2.x, fDeltaDepth2.y);\n"
"float fIntensity;\n"
"if(fDepth < g_fFocalPlane)\n"
"{\n"
"fIntensity = (fDepth - g_fFocalPlane) / (g_fFocalPlane - g_fNearPlane);\n"
"}\n"
"else\n"
"{\n"
"float2 fDistances = (fDepth - g_fFocalPlane);\n"
"fDistances.y -= max(fDeltaDepth, 0.f);\n"
"float2 fIntensities = saturate(fDistances * g_fDistScale );\n"
"fIntensity = lerp(fIntensities.y, fIntensities.x, fIntensities.y);\n"
"}\n"
"return float4(\n"
"tex2D(colorSampler, TexCoord).xyz,\n"
"saturate(0.5f + 0.5f * fIntensity) );\n"
"}\n"
"float4 ps_main(float2 TexCoord : TEXCOORD0) : COLOR0\n"
"{\n"
"float fDepth = tex2D(colorSampler, TexCoord).w;\n"
"float fRadius = abs(2.0f * g_fRadius * fDepth - g_fRadius);\n"
"float fLowRadius = fRadius * g_fLowRadiusScaling;\n"
"float4 fColor = 0.0f;\n"
"float fAmount = 0.0f;\n"
"for(int i = 0; i < 12; i++)\n"
"{\n"
"float2 fHighSampleTexCoord = TexCoord + fRadius * vPoissonDisc[i];\n"
"float2 fLowSampleTexCoord = TexCoord + fLowRadius * vPoissonDisc[i];\n"
"float4 fHighSample = tex2D(colorSampler, fHighSampleTexCoord);\n"
"float4 fLowSample = tex2D(blurSampler, fLowSampleTexCoord);\n"
"float fSampleBlurIntensity = abs(2.f * fHighSample.w - 1.f);\n"
"float4 fSample = lerp(fHighSample, fLowSample, fSampleBlurIntensity);\n"
"float fWeight = fSample.w < fDepth ? abs(2.f * fSample.w - 1.f) : 1.f;\n"
"fColor += fSample * fWeight;\n"
"fAmount += fWeight;\n"
"}\n"
"return fColor / fAmount;\n"
"}\n"
"";

const char g_ShaderPSRay[]=
"float3 lightDir : register(c1);\n"
"float3 viewDir : register(c4);\n"
"float3 passID2expIsLast : register(c23);\n"
"sampler2D colorSampler : register(s0);\n"
"sampler2D depthSampler : register(s1);\n"
"static float4 g_fRayColor = float4(0.9f, 0.8f, 0.7f, 1.0f);\n"
"static float g_fRayNearPlane = 10.0f;\n"
"static float g_fRayFarPlane = 500.0f;\n"
"static float g_fRayDensity = 0.25f;\n"
"static float g_fRayDecay = 0.9125f;\n"
"static float g_fRayAnglePersistence = 4.f;\n"
"float4 ps_ray_mask(float2 TexCoord : TEXCOORD0, float2 LightPos : TEXCOORD2) : COLOR0\n"
"{\n"
"float2 d = LightPos - TexCoord;\n"
"float r = saturate( 1.f - dot(d, d) );\n"
"r *= saturate( g_fRayAnglePersistence * dot(-lightDir, viewDir) );\n"
"float m = tex2D(depthSampler, TexCoord).x;\n"
"m = saturate( (m - g_fRayNearPlane) / (g_fRayFarPlane - g_fRayNearPlane) );\n"
"return /* b */ m * r * g_fRayColor;\n"
"}\n"
"float4 ps_ray_extrude(float2 TexCoord : TEXCOORD0, float2 LightPos : TEXCOORD2) : COLOR0\n"
"{	\n"
"float2 s = g_fRayDensity / (passID2expIsLast.y) * (LightPos - TexCoord) / 8.f;\n"
"float4 r = 0.f, ro = 0.f, rm = 0.f, rd = .125f;\n"
"float2 c = TexCoord;\n"
"for(int i = 0; i < 8; i++)\n"
"{\n"
"float4 rs = tex2D(colorSampler, c);\n"
"ro = (i == 0) ? rs : ro;\n"
"rm = max(rs, rm);\n"
"rs.xyz = rm.xyz;\n"
"r += rs * rd;\n"
"rd.xyz *= (float3)g_fRayDecay;\n"
"c += s;\n"
"}\n"
"r.a = min(ro.a, r.a);\n"
"return r * saturate(1.f - passID2expIsLast.z * r.a);\n"
"}\n"
"";

const char g_ShaderPSBlur[]=
"float4	 res : register(c0);\n"
"float4	 glow : register(c31);\n"
"sampler2D colorSampler : register(s0);\n"
"sampler2D guideSampler : register(s4);\n"
"static float2 fGaussianWeights[] = {\n"
"float2(-3.0f, 0.015625f),\n"
"float2(-2.0f, 0.09375f),\n"
"float2(-1.0f, 0.234375f),\n"
"float2(0.0f, 0.3125f),\n"
"float2(1.0f, 0.234375f),\n"
"float2(2.0f, 0.09375f),\n"
"float2(3.0f, 0.015625f)\n"
"};\n"
"float4 ps_blur(float2 t : TEXCOORD0, uniform float2 vDir) : COLOR0\n"
"{\n"
"float2 vDelta = vDir * res.zw;\n"
"float4 fColor = 0.f;\n"
"for(int i = 0; i < 7; i++)\n"
"fColor += fGaussianWeights[i].y\n"
"* tex2D(colorSampler, t + fGaussianWeights[i].x * vDelta);\n"
"return fColor;\n"
"}\n"
"float4 ps_blur_hor(float2 t : TEXCOORD0) : COLOR0 { return ps_blur(t, float2(1.f, 0.f)); }\n"
"float4 ps_blur_ver(float2 t : TEXCOORD0) : COLOR0 { return ps_blur(t, float2(0.f, 1.f)); }\n"
"float4 ps_blur_bil(float2 t : TEXCOORD0, uniform float2 vDir) : COLOR0\n"
"{\n"
"float2 vDelta = vDir * res.zw;\n"
"float4 fGuide = tex2D(guideSampler, t);\n"
"float4 fColor = 0.f;\n"
"float fWeight = 0.f;\n"
"for(int i = 0; i < 7; i++)\n"
"{\n"
"float2 to = t + vDelta * fGaussianWeights[i].x;\n"
"float4 fSample = tex2D(colorSampler, to);\n"
"float fSampleWeight = (1.f - saturate(4.f * (fGuide.w - fSample.w))) * fGaussianWeights[i].y;\n"
"fColor += fSample * fSampleWeight;\n"
"fWeight += fSampleWeight;\n"
"}\n"
"return lerp(fGuide, fColor / fWeight, fWeight);\n"
"}\n"
"float4 ps_blur_bil_hor(float2 t : TEXCOORD0) : COLOR0 { return ps_blur_bil(t, float2(1.f, 0.f)); }\n"
"float4 ps_blur_bil_ver(float2 t : TEXCOORD0) : COLOR0 { return ps_blur_bil(t, float2(0.f, 1.f)); }\n"
"float4 ps_extract_inv_alpha(float2 t : TEXCOORD0) : COLOR0\n"
"{\n"
"float4 c = tex2D(colorSampler, t);\n"
"c.a = 1.f - c.a;\n"
"c.xyz *= c.a;\n"
"return c * glow;\n"
"}\n"
"";