Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
623 lines (533 sloc) 15.8 KB
// This file is distributed under a BSD license. See LICENSE.txt for details.
asc
{
cbuffer CubeHordeBasePara : register(c0) : slot vs 0
{
float4x4 mvp;
float4 lightDir;
float4x3 lightMvp;
float3 up;
float4 shadowCol;
float4 positions[8];
float4 normals[6];
};
cbuffer CubeHordePixelPara : register(c0) : slot ps 0
{
float4 darkCol;
float4 lightCol;
float4 clipPlane;
};
cbuffer CubeHordeXForm : register(c32) : slot vs 1
{
float4 transform[224]; // 112*2
};
cbuffer BlurPara : register(c0) : slot vs 0
{
float4x4 mvp;
float2 pixelOffset;
};
}
// TODO: check out how to use functions with ASC so I don't have to copy&paste
// the cube stuff every time :)
// (variance) shadow map write
shader CubeHordeShadowWrite : sASCMaterial
{
vs
{
asc vs_2_0
{
use CubeHordeBasePara;
use CubeHordeXForm;
void main(
in int4 indices : POSITION,
in float4 in_col : COLOR,
out float4 out_pos : POSITION,
out float out_z : TEXCOORD0,
)
{
// get input params
float4 in_pos = positions[indices.x];
// x axis
float3 x_axis = transform[indices.z];
// scale
float lenXSq = dot(x_axis,x_axis);
float lenXRSq = rsqrt(lenXSq);
x_axis *= lenXRSq;
float3 scale;
scale.x = lenXSq * lenXRSq;
scale.y = transform[indices.z].w;
scale.z = transform[indices.z+1].w;
// get transform for this cube
float3 z_axis = normalize(cross(x_axis,up));
float3 y_axis = cross(z_axis,x_axis);
float4 xlate = transform[indices.z+1];
// calc worldspace position
float4 world_pos;
float3 scaled_pos;
scaled_pos = in_pos.xyz * scale;
world_pos.xyz = scaled_pos.x * x_axis;
world_pos.xyz += scaled_pos.y * y_axis;
world_pos.xyz += scaled_pos.z * z_axis;
world_pos.xyz += xlate.xyz;
world_pos.w = 1.0f;
// calc output position+z
out_pos = mul(world_pos,mvp);
out_z = mul(world_pos,lightMvp).z;
}
}
}
ps
{
asc ps_2_0
{
void main(
in float4 in_col : COLOR,
in float in_z : TEXCOORD0,
out float4 result : COLOR
)
{
result = in_z;
}
}
}
};
// render with shadow map
shader CubeHordeShadowRender : sASCMaterial
{
vs
{
asc vs_2_0
{
use CubeHordeBasePara;
use CubeHordeXForm;
void main(
in int4 indices : POSITION,
in float4 in_col : COLOR,
out float4 out_pos : POSITION,
out float4 out_col : COLOR,
out float3 out_mpos : TEXCOORD0,
out float3 out_ldir : TEXCOORD1,
out float3 out_lrpos : TEXCOORD2, // light-relative position
)
{
// get input params
float4 in_pos = positions[indices.x];
// x axis
float3 x_axis = transform[indices.z];
// scale
float lenXSq = dot(x_axis,x_axis);
float lenXRSq = rsqrt(lenXSq);
x_axis *= lenXRSq;
float3 scale;
scale.x = lenXSq * lenXRSq;
scale.y = transform[indices.z].w;
scale.z = transform[indices.z+1].w;
// get transform for this cube
float3 z_axis = normalize(cross(x_axis,up));
float3 y_axis = cross(z_axis,x_axis);
float4 xlate = transform[indices.z+1];
// calc worldspace position
float4 world_pos;
float3 scaled_pos;
scaled_pos = in_pos.xyz * scale;
world_pos.xyz = scaled_pos.x * x_axis;
world_pos.xyz += scaled_pos.y * y_axis;
world_pos.xyz += scaled_pos.z * z_axis;
world_pos.xyz += xlate.xyz;
world_pos.w = 1.0f;
// calc output position/color/light dir
out_pos = mul(world_pos,mvp);
out_col = in_col;
out_mpos = in_pos;
out_ldir = lightDir;
out_ldir.x = dot(lightDir,x_axis);
out_ldir.y = dot(lightDir,y_axis);
out_ldir.z = dot(lightDir,z_axis);
out_lrpos = mul(world_pos,lightMvp);
}
}
}
ps
{
asc ps_2_0
{
use CubeHordePixelPara;
samplerCUBE sampNormal : register(s0);
sampler2D sampShadow : register(s1);
void main(
in float4 in_col : COLOR,
in float3 in_mpos : TEXCOORD0,
in float3 in_ldir : TEXCOORD1,
in float3 in_lrpos : TEXCOORD2,
out float4 result : COLOR
)
{
// normal from model position
float3 normal = texCUBE(sampNormal,in_mpos);
// shade (diffuse, directional)
float lightTerm = saturate(dot(normal,in_ldir));
float4 baseCol = in_col * saturate(dot(normal,in_ldir));
// read shadow map, variance shadow map computation
float2 moments = tex2D(sampShadow,in_lrpos.xy);
float litFactor = in_lrpos.z <= moments.x+0.01;
result = lerp(darkCol,lightCol,lightTerm * (litFactor * 0.9 + 0.1));
//result = baseCol * (litFactor * 0.9 + 0.1);
/*float variance = moments.y - moments.x*moments.x;
float md = moments.x - in_lrpos.z;
float pMax = min(variance / (variance + md*md),1.0f);
result = baseCol * (max(litFactor,pMax) * 0.9 + 0.1);*/
}
}
}
};
// render with shadow map and plane clip
shader CubeHordeShadowRenderClip : sASCMaterial
{
vs
{
asc vs_2_0
{
use CubeHordeBasePara;
use CubeHordeXForm;
void main(
in int4 indices : POSITION,
in float4 in_col : COLOR,
out float4 out_pos : POSITION,
out float4 out_col : COLOR,
out float3 out_mpos : TEXCOORD0,
out float3 out_ldir : TEXCOORD1,
out float3 out_lrpos : TEXCOORD2, // light-relative position
out float3 out_wpos : TEXCOORD3, // world position
)
{
// get input params
float4 in_pos = positions[indices.x];
// x axis
float3 x_axis = transform[indices.z];
// scale
float lenXSq = dot(x_axis,x_axis);
float lenXRSq = rsqrt(lenXSq);
x_axis *= lenXRSq;
float3 scale;
scale.x = lenXSq * lenXRSq;
scale.y = transform[indices.z].w;
scale.z = transform[indices.z+1].w;
// get transform for this cube
float3 z_axis = normalize(cross(x_axis,up));
float3 y_axis = cross(z_axis,x_axis);
float4 xlate = transform[indices.z+1];
// calc worldspace position
float4 world_pos;
float3 scaled_pos;
scaled_pos = in_pos.xyz * scale;
world_pos.xyz = scaled_pos.x * x_axis;
world_pos.xyz += scaled_pos.y * y_axis;
world_pos.xyz += scaled_pos.z * z_axis;
world_pos.xyz += xlate.xyz;
world_pos.w = 1.0f;
// calc output position/color/light dir
out_pos = mul(world_pos,mvp);
out_col = in_col;
out_mpos = in_pos;
out_ldir = lightDir;
out_ldir.x = dot(lightDir,x_axis);
out_ldir.y = dot(lightDir,y_axis);
out_ldir.z = dot(lightDir,z_axis);
out_lrpos = mul(world_pos,lightMvp);
out_wpos = world_pos;
}
}
}
ps
{
asc ps_2_0
{
use CubeHordePixelPara;
samplerCUBE sampNormal : register(s0);
sampler2D sampShadow : register(s1);
void main(
in float4 in_col : COLOR,
in float3 in_mpos : TEXCOORD0,
in float3 in_ldir : TEXCOORD1,
in float3 in_lrpos : TEXCOORD2,
in float3 in_wpos : TEXCOORD3,
out float4 result : COLOR
)
{
// normal from model position
float3 normal = texCUBE(sampNormal,in_mpos);
// shade (diffuse, directional)
float lightTerm = saturate(dot(normal,in_ldir));
float4 baseCol = in_col * saturate(dot(normal,in_ldir));
// read shadow map, variance shadow map computation
float2 moments = tex2D(sampShadow,in_lrpos.xy);
float litFactor = in_lrpos.z <= moments.x+0.01;
result = lerp(darkCol,lightCol,lightTerm * (litFactor * 0.9 + 0.1));
// clip this!
clip(dot(float4(in_wpos,1),clipPlane));
}
}
}
};
// lotsa cubes ahoy!
shader CubeHordeShaderClip : sASCMaterial
{
vs
{
asc vs_2_0
{
use CubeHordeBasePara;
use CubeHordeXForm;
void main(
in int4 indices : POSITION,
in float4 in_col : COLOR,
out float4 out_pos : POSITION,
out float4 out_col : COLOR,
out float3 out_mpos : TEXCOORD0,
out float3 out_ldir : TEXCOORD1,
out float3 out_wpos : TEXCOORD2,
)
{
// get input params
float4 in_pos = positions[indices.x];
// x axis
float3 x_axis = transform[indices.z];
// scale
float lenXSq = dot(x_axis,x_axis);
float lenXRSq = rsqrt(lenXSq);
x_axis *= lenXRSq;
float3 scale;
scale.x = lenXSq * lenXRSq;
scale.y = transform[indices.z].w;
scale.z = transform[indices.z+1].w;
// get transform for this cube
float3 z_axis = normalize(cross(x_axis,up));
float3 y_axis = cross(z_axis,x_axis);
float4 xlate = transform[indices.z+1];
// calc worldspace position
float4 world_pos;
float3 scaled_pos;
scaled_pos = in_pos.xyz * scale;
world_pos.xyz = scaled_pos.x * x_axis;
world_pos.xyz += scaled_pos.y * y_axis;
world_pos.xyz += scaled_pos.z * z_axis;
world_pos.xyz += xlate.xyz;
world_pos.w = 1.0f;
// calc output position/color/light dir
out_pos = mul(world_pos,mvp);
out_col = in_col;
out_mpos = in_pos;
out_ldir = lightDir;
out_ldir.x = dot(lightDir,x_axis);
out_ldir.y = dot(lightDir,y_axis);
out_ldir.z = dot(lightDir,z_axis);
out_wpos = world_pos;
}
}
}
ps
{
asc ps_2_0
{
use CubeHordePixelPara;
samplerCUBE sampNormal : register(s0);
void main(
in float4 in_col : COLOR,
in float3 in_mpos : TEXCOORD0,
in float3 in_ldir : TEXCOORD1,
in float3 in_wpos : TEXCOORD2,
out float4 result : COLOR
)
{
// normal from model position
float3 normal = texCUBE(sampNormal,in_mpos);
// shade (diffuse, directional)
float lightTerm = saturate(dot(normal,in_ldir));
result = lerp(darkCol,lightCol,lightTerm);
// clip this!
clip(dot(float4(in_wpos,1),clipPlane));
}
}
}
};
// lotsa cubes ahoy!
shader CubeHordeShader : sASCMaterial
{
vs
{
asc vs_2_0
{
use CubeHordeBasePara;
use CubeHordeXForm;
void main(
in int4 indices : POSITION,
in float4 in_col : COLOR,
out float4 out_pos : POSITION,
out float4 out_col : COLOR,
out float3 out_mpos : TEXCOORD0,
out float3 out_ldir : TEXCOORD1,
)
{
// get input params
float4 in_pos = positions[indices.x];
// x axis
float3 x_axis = transform[indices.z];
// scale
float lenXSq = dot(x_axis,x_axis);
float lenXRSq = rsqrt(lenXSq);
x_axis *= lenXRSq;
float3 scale;
scale.x = lenXSq * lenXRSq;
scale.y = transform[indices.z].w;
scale.z = transform[indices.z+1].w;
// get transform for this cube
float3 z_axis = normalize(cross(x_axis,up));
float3 y_axis = cross(z_axis,x_axis);
float4 xlate = transform[indices.z+1];
// calc worldspace position
float4 world_pos;
float3 scaled_pos;
scaled_pos = in_pos.xyz * scale;
world_pos.xyz = scaled_pos.x * x_axis;
world_pos.xyz += scaled_pos.y * y_axis;
world_pos.xyz += scaled_pos.z * z_axis;
world_pos.xyz += xlate.xyz;
world_pos.w = 1.0f;
// calc output position/color/light dir
out_pos = mul(world_pos,mvp);
out_col = in_col;
out_mpos = in_pos;
out_ldir = lightDir;
out_ldir.x = dot(lightDir,x_axis);
out_ldir.y = dot(lightDir,y_axis);
out_ldir.z = dot(lightDir,z_axis);
}
}
}
ps
{
asc ps_2_0
{
use CubeHordePixelPara;
samplerCUBE sampNormal : register(s0);
void main(
in float4 in_col : COLOR,
in float3 in_mpos : TEXCOORD0,
in float3 in_ldir : TEXCOORD1,
out float4 result : COLOR
)
{
// normal from model position
float3 normal = texCUBE(sampNormal,in_mpos);
// shade (diffuse, directional)
float lightTerm = saturate(dot(normal,in_ldir));
result = lerp(darkCol,lightCol,lightTerm);
}
}
}
};
// for the ground plane; no lighting, no tex, no zwrite variant.
// (this is a normal render-triangles-with-VSM shader)
shader GroundPlaneShader : sASCMaterial
{
vs
{
asc vs_2_0
{
use CubeHordeBasePara;
void main(
in float4 in_pos : POSITION,
in float4 in_col : COLOR,
out float4 out_pos : POSITION,
out float4 out_col : COLOR,
out float3 out_lrpos : TEXCOORD0, // light-relative position
)
{
// this is pretty straightforward.
out_pos = mul(in_pos,mvp);
out_col = shadowCol;
out_lrpos = mul(in_pos,lightMvp);
}
}
}
ps
{
asc ps_2_0
{
sampler2D sampShadow : register(s0);
void main(
in float4 in_col : COLOR,
in float3 in_lrpos : TEXCOORD0,
out float4 result : COLOR
)
{
// read shadow map, variance shadow map computation
float2 moments = tex2D(sampShadow,in_lrpos.xy);
float litFactor = saturate(in_lrpos.z) <= moments.x+0.01;
//result = in_col * (litFactor * 0.9 + 0.1);
result = lerp(in_col, float4(0,0,0,0), litFactor * 0.9 + 0.1);
/*float variance = moments.y - moments.x*moments.x;
float md = moments.x - in_lrpos.z;
float pMax = min(variance / (variance + md*md),1.0f);
result = in_col * (max(litFactor,pMax) * 0.9 + 0.1);*/
}
}
}
};
// simple blur shader
shader BlurShader : sASCMaterial
{
vs
{
asc vs_2_0
{
use BlurPara;
void main(
in float4 in_pos : POSITION,
in float4 in_uv : TEXCOORD0,
out float4 out_pos : POSITION,
out float2 out_uv0 : TEXCOORD0,
out float2 out_uv1 : TEXCOORD1,
out float2 out_uv2 : TEXCOORD2,
out float2 out_uv3 : TEXCOORD3,
out float2 out_uv4 : TEXCOORD4,
)
{
// this is pretty straightforward.
out_pos = mul(in_pos,mvp);
out_uv0 = in_uv - 2 * pixelOffset;
out_uv1 = in_uv - pixelOffset;
out_uv2 = in_uv;
out_uv3 = in_uv + pixelOffset;
out_uv4 = in_uv + 2 * pixelOffset;
}
}
}
ps
{
asc ps_2_0
{
sampler2D samp0 : register(s0);
sampler2D samp1 : register(s1);
sampler2D samp2 : register(s2);
void main(
in float2 in_uv0 : TEXCOORD0,
in float2 in_uv1 : TEXCOORD1,
in float2 in_uv2 : TEXCOORD2,
in float2 in_uv3 : TEXCOORD3,
in float2 in_uv4 : TEXCOORD4,
out float4 result : COLOR
)
{
// read pixels
float4 p0 = tex2D(samp0,in_uv0);
float4 p1 = tex2D(samp1,in_uv1);
float4 p2 = tex2D(samp2,in_uv2);
float4 p3 = tex2D(samp0,in_uv3);
float4 p4 = tex2D(samp1,in_uv4);
// weighted sum for results: (1 4 6 4 1)/16
result = 1.0/16.0 * (p0 + p4) + 1.0/4.0 * (p1 + p3) + 3.0/8.0 * p2;
}
}
}
};
You can’t perform that action at this time.