Introduction to 3D Game Programming with DirectX.9.0 - F. D. Luna

314 Chapter 17

The first two components are straightforward, but we see two additional normal vectors, namely faceNormal1 and faceNormal2. These vectors describe the two face normals of the faces that share the edge the vertex lies on, namely face0 and face1.

The actual mathematics of testing if a vertex is on a silhouette edge is as follows. Assume we are in view space. Let v be a vector from the origin to the vertex we are testing—Figure 17.8. Let n0 be the face normal for face0 and let n1 be the face normal for face1. Then the vertex is on a silhouette edge if the following inequality is true:

(1) v n0 v n1 % 0

We define such an edge to always be a silhouette edge. To ensure that the vertex shader processes such edges as silhouette edges, we let faceNormal2 = –faceNormal1. Thus, the face normals face in opposite directions and inequality (1) will be true, indicating the edge is a silhouette edge.

17.5.3.3 Edge Generation

Generating the edges of a mesh is trivial; we simply iterate through each face in the mesh and compute a quad (degenerate, as in Figure 17.6) for each edge on the face.

Note: Each face has three edges since there are three edges to a triangle.

For the vertices of each edge, we also need to know the two faces that share the edge. One of the faces is the triangle the edge is on. For instance, if we’re computing an edge of the ith face, then the ith face

Team-Fly®

Introduction to Vertex Shaders 315

shares that edge. The other face that shares the edge can be found using the mesh’s adjacency info.

//Compute a vector in the direction of the vertex

//from the eye. Recall the eye is at the origin

//in view space - eye is just camera position.

316 Chapter 17

vector eyeToVertex = input.position;

//transform normals to view space. Set w

//components to zero since we're transforming vectors.

//Assume there are no scalings in the world

//matrix as well.

//compute the cosine of the angles between

//the eyeToVertex vector and the face normals. float dot0 = dot(eyeToVertex, input.faceNormal1); float dot1 = dot(eyeToVertex, input.faceNormal2);

//if cosines are different signs (positive/negative)

//then we are on a silhouette edge. Do the signs

//differ?

if( (dot0 * dot1) < 0.0f )

{

//yes, then this vertex is on a silhouette edge,

//offset the vertex position by some scalar in the

//direction of the vertex normal.

input.position += 0.1f * input.normal;

}

//transform to homogeneous clip space output.position = mul(input.position, ProjMatrix);

//set outline color

output.diffuse = Black;

return output;

}

17.6Summary

Using vertex shaders, we can replace the transformation and lighting stages of the fixed function pipeline. By replacing this fixed process with our own program (vertex shader), we can obtain a huge amount of flexibility in the graphical effects that we can achieve.

Vertex declarations are used to describe the format of our vertices. They are similar to flexible vertex formats (FVF) but are more flexible and allow us to describe vertex formats that FVF cannot describe. Note that if our vertex can be described by an FVF, we can still use them; however, internally they are converted to vertex declarations.

Introduction to Pixel Shaders 319

18.1 Multitexturing Overview

320 Chapter 18

Note: As with blending in Chapter 7, the resulting image depends on how the textures are blended. In the fixed function multitexturing stage, the blending equation is controlled through texture render states. With pixel shaders we can write the blend function programmatically in code as a simple expression. This allows us to blend the textures in any way we want. We elaborate on blending the textures when we discuss the sample application for this chapter.

Blending the textures (two in this example) to light the crate has two advantages over Direct3D’s lighting:

The lighting is precalculated into the spotlight light map. Therefore, the lighting does not need to be calculated at run time, which saves processing time. Of course, the lighting can only be precalculated for static objects and static lights.

Since the light maps are precalculated, we can use a much more accurate and sophisticated lighting model than Direct3D’s model. (Better lighting results in a more realistic scene.)

Remark: The multitexturing stage is typically used to implement a full lighting engine for static objects. For example, we might have a texture map that holds the colors of the object, such as a crate texture map. Then we may have a diffuse light map to hold the diffuse surface shade, a separate specular light map to hold the specular surface shade, a fog map to hold the amount of fog that covers a surface, and a detail map to hold small, high frequency details of a surface. When all these textures are combined, it effectively lights, colors, and adds details to the scene using only lookups into precalculated textures.

Note: The spotlight light map is a trivial example of a very basic light map. Typically, special programs are used to generate light maps given a scene and light sources. Generating light maps goes beyond the scope of this book. For the interested reader, Alan Watt and Fabio Policarpo describe light mapping in 3D Games: Real-time Rendering and Software Technology.

18.1.1 Enabling Multiple Textures

Recall that textures are set with the IDirect3DDevice9::SetTexture method and sampler states are set with the IDirect3DDevice9::SetSamplerState method, which are prototyped as:

HRESULT IDirect3DDevice9::SetTexture(

DWORD Stage, // specifies the texture stage index IDirect3DBaseTexture9 *pTexture

);

HRESULT IDirect3DDevice9::SetSamplerState(

DWORD Sampler, // specifies the sampler stage index

D3DSAMPLERSTATETYPE Type,

Introduction to Pixel Shaders 321

DWORD Value

);

Note: A particular sampler stage index i is associated with the ith texture stage. That is, the ith sampler stage specifies the sampler states for the ith set texture.

The texture/sampler stage index identifies the texture/sampler stage to which we wish to set the texture/sampler. Thus, we can enable multiple textures and set their corresponding sampler states by using different stage indices. Previously in this book, we always specified 0, denoting the first stage because we only used one texture at a time. So for example, if we need to enable three textures, we use stages 0, 1, and 2 like this:

322 Chapter 18

that index into the three enabled textures. Thus, a vertex structure for multitexturing with three textures would look like this:

struct MultiTexVertex

{

MultiTexVertex(float x, float y, float z, float u0, float v0,

float u1, float v1, float u2, float v2)

{

_x = x; _y = y; _z = z; _u0 = u0; _v0 = v0;

_u1 = u1; _v1 = v1; _u2 = u2; _v2 = v2;

}

float _x, _y, _z;

float _u0, _v0; // Texture coordinates for texture at stage 0. float _u1, _v1; // Texture coordinates for texture at stage 1. float _u2, _v2; // Texture coordinates for texture at stage 2.

static const DWORD FVF;

};

const DWORD MultiTexVertex::FVF = D3DFVF_XYZ | D3DFVF_TEX3;

Observe that the flexible vertex format flag D3DFVF_TEX3 is specified denoting the vertex structure contains three sets of texture coordinates. The fixed function pipeline supports up to eight sets of texture coordinates. To use more than eight, you must use a vertex declaration and the programmable vertex pipeline.

Note: In the newer pixel shader versions, we can use one texture coordinate set to index into multiple textures, thereby removing the need for multiple texture coordinates. Of course this assumes the same texture coordinates are used for each texture stage. If the texture coordinates for each stage are different, then we will still need multiple texture coordinates.

18.2 Pixel Shader Inputs and Outputs

Two things are input into a pixel shader: colors and texture coordinates. Both are per pixel.

Note: Recall that vertex colors are interpolated across the face of a primitive.

A per pixel texture coordinate is simply the (u, v) coordinates that specify the texel in the texture that is to be mapped to the pixel in question. Direct3D computes both colors and texture coordinates per pixel, from vertex colors and vertex texture coordinates, before entering the pixel shader. The number of colors and texture coordinates

Introduction to Pixel Shaders 323