|
The following is an excerpt from Advanced Game Development with Programmable Graphics Hardware (ISBN 1-56881-240-X) published by A K Peters, Ltd.
--
Integrating
shadows to the relief map objects is an important feature in fully
integrating the effect into a game scenario. The corrected depth option
(see Chapter 5), which ensures that the depth values stored in Z-buffer
include the displaced depth from the relief map, makes it possible to
implement correct shadow effects for such objects. We consider the use
of stencil shadows and shadow maps in this context. We can implement
three types of shadows: shadows from relief object to the world, from
the world to relief object and from relief object to itself
(self-shadows).
Let
us first consider what can be achieved using stencil volume shadows.
When generating the shadow volumes, we can only use the polygons from
the original mesh to generate the volume. This means that the shadows
from relief objects to the world will not show the displaced geometry
of the relief texture, but will reflect the shape of the original
triangle mesh without the displaced pixels (Figure 1).
However, as we have the corrected depth stored in Z-buffer
when rendering the lighting pass we can have shadows volumes from the
world projected onto the relief objects correctly, and they will follow
the displaced geometry properly. Self-shadows (relief object to itself)
are not possible with stencil shadows.
Thus, using relief maps in conjunction with shadow volumes, we have the following:
- Relief object to world: correct silhouette or displacement visible in shadows is not possible.
- World to relief object: shadows can project on displaced pixels correctly.
- Relief object to relief object: not possible.
Relief
mapped objects integrate much better into shadow map algorithms. Using
a shadow map, we can resolve all three cases; as for any other object,
we render the relief mapped object into the shadow map. As the shadow
map only needs depth values, the shader, used when rendering the object
to the shadow map, does not need to calculate lighting. Also if no
self-shadows are desired, we could simplify the ray intersect function
to invoke only the linear search (as in this case we only need to know
if a pixel has an intersection and we do not need the exact
intersection point). The shader used when rendering relief objects to a
shadow map is given in Listing 4.4, and an example is shown in Figure
2.
To
project shadows from the world to the relief map objects, we need to
pass the shadow map texture and light matrix (light frustum
view/projection/bias multiplied by inverse camera view matrix). Then,
just before calculating the final colour in the shader we project the
displaced pixel position into the light space and compare the depth map
at that position to the pixel depth in light space.
#ifdef RM_SHADOWS
// transform pixel position to shadow map space
sm= mul (viewinverse_lightviewprojbias,position);
sm/=sm.w;
if (sm.z> f1tex2D (shadowmap,sm.xy))
att=0; // set attenuation to 0
#endif
An
example of this approach is shown in Figure 3. This is compared with a
conventional render using a normal map in conjunction with a shadow
map. Thus, using relief maps in conjunction with shadow maps, we can
implement the following:
- Relief object to world: good silhouette and displacement visible in
shadows.
- World to relief object: Shadows can project on displaced pixels correctly.
- Relief object to relief object: possible if full linear/binary search and
depth correct used when rendering to shadow map.
Listing 4.4
Using relief mapped objects in conjunction with shadow maps.
float ray_intersect_rm_shadow(
in sampler2D reliefmap,
in float2 tx,
in float3 v,
in float f,
in float tmax)
{
const int linear_search_steps=10;
float t=0.0;
float best_t=tmax+0.001;
float size=best_t/linear_search_steps;
// search for first point inside object
for ( int i=0;i<linear_search_steps-1;i++ )
{
t+=size;
float3 p=ray_position(t,tx,v,f);
float4 tex= tex2D (reliefmap,p.xy);
if (best_t>tmax)
if (p.z>tex.w)
best_t=t;
}
return best_t;
}
f2s main_frag_relief_shadow(
v2f IN,
uniform sampler2D rmtex: TEXUNIT0 , // rm texture map
uniform float4 planes, // near and far plane info
uniform float tile, // tile factor
uniform float depth) // depth factor
{
f2s OUT;
// view vector in eye space
float3 view= normalize (IN.vpos);
// view vector in tangent space
float3 v= normalize ( float3 ( dot (view,IN.tangent.xyz),
dot (view,IN.binormal.xyz), dot (-view,IN.normal)));
// mapping scale from object to texture space
float2 mapping= float2 (IN.tangent.w,IN.binormal.w)/tile;
// quadric coefficients transformed to texture space
float2 quadric=IN.curvature.xy*mapping.xy*mapping.xy/depth;
// view vector in texture space
v.xy/=mapping;
v.z/=depth;
// quadric applied to view vector coodinates
float f=quadric.x*v.x*v.x+quadric.y*v.y*v.y;
// compute max distance for search min(t(z=0),t(z=1))
float d=v.z*v.z-4*f;
float tmax=100;
if (d>0) // t when z=1
tmax=(-v.z+ sqrt (d))/(-2*f);
d=v.z/f; // t when z=0
if (d>0)
tmax= min (tmax,d);
#ifndef RM_DEPTHCORRECT
// no depth correct, use simple ray_intersect
float t=ray_intersect_rm_shadow(rmtex,IN. texcoord*tile,v,f,tmax);
if (t>tmax)
discard ; // no intesection, discard fragment
#else
// with depth correct, use full ray_intersect
float t=ray_intersect_rm(rmtex,IN.texcoord*tile,v,f,tmax);
if (t>tmax)
discard ; // no intesection, discard fragment
// compute displaced pixel position in view space
float3 p=IN.vpos.xyz+view*t;
// a=-far/(far-near)
// b=-far*near/(far-near)
// Z=(a*z+b)/-z
OUT.depth=((planes.x*p.z+planes.y)/-p.z);
#endif
return OUT;
}
______________________________________________________
|
