Multi-Threaded Game Engine Design phần 5 pot

To correctly render a mesh we need to add a light source so that the mesh can reflect light realistically while our ambient demo did no such reflection and could only really be seen in w

Ambient Wireframe Shader Demo

The following program demonstrates the Ambient.fx effect with the FillModeproperty set to wireframe You may selectively swap one type of mesh for another to see the sphere, teapot, cylinder, cube, or torus by making minor changes to the code.

camera = new Camera();

camera->setPosition(0, 0.0, 10.0);

camera->setTarget(0,0,0);

//load the ambient.fx effect

effect = new Effect();

//create stock meshes

D3DXCreateTorus(g_engine->getDevice(), 2.0f, 4.0f, 20, 20, &torus, NULL);

D3DXCreateTeapot(g_engine->getDevice(), &teapot, NULL);

D3DXCreateSphere(g_engine->getDevice(), 2.0f, 10, 10, &sphere, NULL);

D3DXCreateBox(g_engine->getDevice(), 2.0f, 2.0f, 2.0f, &cube, NULL);

effect->setViewMatrix( camera->getViewMatrix(), "View");

effect->setProjectionMatrix( camera->getProjMatrix(), "Projection");

//draw the cube

effect->setWorldMatrix( (D3DXMATRIX) matWorld , "World");

The Scene (World Matrix) 221

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

//choose which mesh to render heretorus->DrawSubset(0);

if (font) delete font;

if (effect) delete effect;

if (camera) delete camera;

out "Delta time = "  deltaTime  endl;

out "Update = "  g_engine->getCoreFrameRate()  " fps"  endl;

out "Draw = "  g_engine->getScreenFrameRate()  " fps";

KeyPressEvent* evt = (KeyPressEvent*) e;

if (evt->keycode == DIK_ESCAPE) g_engine->Shutdown();

break;

}

case EVENT_MOUSEMOTION:

{

MouseMotionEvent* evt = (MouseMotionEvent*)e;

camera->Look( evt->deltax/100.0f, evt->deltay/100.0f, 0 );

The ambient light shader in the previous example of this chapter was designed

for illustration, meant to be easy to understand, but it is not very useful for a

game To correctly render a mesh we need to add a light source so that the mesh

can reflect light realistically (while our ambient demo did no such reflection and

could only really be seen in wireframe mode).

Diffuse Lighting 223

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Diffuse light is light that is spread out or scattered over an area (such as the faces

of a mesh), or light that is dim or bright depending on the type of surface it is shining on While ambient light appears to reflect evenly from all surfaces, diffuse light lacks that perfect conciseness, which is precisely why it is a superior form of lighting In a sense, all light other than ambient may be considered diffuse, but it is most often referred to as light from a directional light source.

To render a mesh with a directional light, in addition to the usual World/View/ Projection matrices, we must also supply a vector to the light source, the light ’s color and intensity, and an inverse/transposed matrix When calculating the lighting on the faces of a mesh we must calculate the normal and the light intensity The normal is calculated from an inverse/transposed version of the World matrix The light intensity is calculated by taking the dot product of the normal.

Matrix Inverse/Transpose

Calculating the inverse of a matrix is rather complex, involving some derivation that is beyond the scope of this book In brief, the inverse of a matrix is such that when matrix A is inverted to B, both A times B and B times A will equal the identity matrix As a result of the theory required to explain inverting a matrix, this is a calculation we cannot easily detach from the D3DX library at this time without further research What we can do, however, is make use of theD3DXMatrixInverse function to perform this calculation.

Transposing a matrix involves shifting the rows 90 degrees into the columns as illustrated in Figure 8.6 We can calculate the transposed matrix with the function D3DXMatrixTranspose.

Both the matrix inverse and transpose are needed to calculate how light will

affect the faces of a mesh, taking into account the position of a light source.

Assuming your world matrix represents the transforms for a given mesh, then

this code will perform the calculation:

D3DXMATRIX inverse, wit;

D3DXMatrixInverse( &inverse, 0, &world );

D3DXMatrixTranspose( &wit, &inverse );

Both of these functions return the calculated matrix as a return value as well as

passing the result back through the reference parameter, so the result can be

carried on to a calling function If you wish, you may combine the function calls

like so:

D3DXMatrixTranspose(&wit,D3DXMatrixInverse(&inverse,0,&world));

And, finally, assuming our effect has a global property so named, we can pass

the inverted/transposed World matrix to the effect via our setParam()function:

effect->setParam( "WorldInverseTranspose", wit );

A d v i c e

You will probably not want to calculate inverse/transpose inside your shader because those

calculations will be repeated for every vertex and potentially every pixel being rendered Instead,

calculate the inverse/transpose once in the CPU and pass that calculation on to the effect for an

Dot Product

To calculate a dot product, the X,Y,Z properties of two vectors are multiplied by each other, and those products are then added together The name “dot product” comes from the dot that is used to represent the calculation Figure 8.7 shows an example of calculating using dot product.

Directional Light Shader

This effect source code adds a few more global properties compared to the previous ambient effect, to take into account directional lighting Now we have these globals:

Data Type Global Name

It ’s important to take note of these global properties because they must be set

correctly in our source code —and case sensitivity must be observed.

float4x4 World;

float4x4 View;

float4x4 Projection;

float4x4 WorldInverseTranspose;

float3 LightVector = float3(0, 0, 1);

float4 LightColor = float4(1,1,1,1);

float LightPower = 0.6;

struct MyVertexInput

{

float4 position : POSITION;

float2 texcoord : TEXCOORD0;

float4 normal : NORMAL;

};

struct MyVertexOutput

{

float4 position : POSITION;

float2 texcoord : TEXCOORD0;

float4 color : COLOR0;

float4x4 viewProj = mul(View,Projection);

float4x4 WorldViewProj = mul(World,viewProj);

output.position = mul(input_param.position, WorldViewProj);

//lighting

float4 normal = mul( input_param.normal, WorldInverseTranspose );

float intensity = dot( normal, LightVector );

output.color = saturate( LightColor * LightPower * intensity );

float4 PixelShaderFunction(MyVertexOutput input_param) : COLOR0

vertexShader = compile vs_2_0 VertexShaderFunction();

pixelShader = compile ps_2_0 PixelShaderFunction();

}

}

Directional Light Demo

We have covered quite a bit of new material on diffuse lighting, and our first experiment is with a directional light source (the most common form of lighting after ambient) This example required quite a bit more work beyond the ambient light demo presented earlier in the chapter, including an inverse/transposed World matrix and properties for the directional light source (position vector, intensity value, and color value) Figure 8.8 shows the somewhat overused teapot mesh with a green directional light illuminating it.

This program has some interactivity programmed in By pressing the up/down arrows, you can rotate the mesh The left/right arrows will rotate the light source around the scene (or more accurately, rotate the normalized vector pointing at the directional light) The þ/ keys on the numeric keypad increase and decrease the light intensity, respectively The R, G, B, and A keys on the keyboard adjust the color values used for the directional light ’s color Figure 8.9 shows another stock mesh being rendered.

Engine Enhancement: Color Class

We ’re going to need a new feature in the engine to make working with colored lighting more effective The Direct3D color macros and functions could not be much more confusing to the uninitiated At best you are likely to get the integer and floating-point color macros confused; at worst, nothing but a black scene will reward you for your hard work A new Color class will alleviate these

difficulties by abstracting color at a more basic level —just dealing with the basic

four color components: Red, Green, Blue, Alpha Here is the class definition:

Color( const Color& color );

Color(int R,int G,int B,int A);

Color(float R,float G,float B,float A);

Color& Color::operator=(const Color& c);

void Set(int R,int G,int B,int A);

void Set(float R,float G,float B,float A);

Figure 8.9

The familiar torus mesh is rendered with a directional light shader

void setBackdropColor(Color value)

an overloaded function with a default Color parameter instead:

void Font::Print(int x, int y, string text, D3DCOLOR color)

{

RECT rect = { x, y, 0, 0 };

fontObj->DrawText( NULL, text.c_str(), text.length(), &rect,

DT_CALCRECT, color);

fontObj->DrawText( g_engine->getSpriteObj(), text.c_str(),

text.length(), &rect, DT_LEFT, color);

}

void Font::Print(int x, int y, std::string text, Color color)

{

Print(x, y, text, color.ToD3DCOLOR());

}

Directional Light Demo Source

Let ’s now go over the source code for this slightly more complex example Since

we now have quite a few new shader parameters to pass, a detailed analysis of

the source code is needed at this stage Later examples might gloss over these

details once they have been sufficiently explained First, we ’ll begin with the

program ’s header code which contains the global variables Of particular interest

here is the use of many high-level engine classes with fewer and fewer

Direct3D-specific constructs in use Our examples will become even more abstracted with

each new chapter.

There ’s quite a bit of new code in the initialization function that demands an explanation First, we create a font like usual, but now we ’re also creating a camera using the new Camera class The camera is very easy to initilaize since only the position and target (or look at point) are needed here Next, an effect file is loaded (directional_light.fx), and then the sample meshes are created You may render any of these meshes you wish, as all are created and destroyed

by the program but not all are used.

//load the ambient.fx effect

effect = new Effect();

return true;

}

Rendering is slightly more complex than the ambient light demo covered earlier.

We ’ve already gone over the new shader globals that are required for directional

lighting, and now those parameters are actually used as the mesh is being

rendered Although you can render two or more of the meshes with this

example, since we are only modifying the world matrix once—to represent

transforms—the shapes will all draw over each other If you want to see more

than one shape in the scene, you will have to create a new transform and render

them separately, each in a new effect rendering block.

void game_render3d()

{

effect->setTechnique("DirectionalLight");

effect->setViewMatrix( camera->getViewMatrix(), "View");

effect->setProjectionMatrix( camera->getProjMatrix(), "Projection");

//draw the mesh

{

matWorld.rotateX(objectAngle);

effect->Begin();

effect->setWorldMatrix( (D3DXMATRIX) matWorld , "World");

//calculate combined inverse transpose matrix

D3DXMATRIX inverse, wit;

D3DXMatrixInverse( &inverse, 0, &matWorld );

D3DXMatrixTranspose( &wit, &inverse );

effect->setParam( "WorldInverseTranspose", wit );

//move the light source

//set the light colorlightColor.r = Math::wrapValue(lightColor.r, 0.0, 1.0);

if (font) delete font;

if (effect) delete effect;

if (camera) delete camera;

font->Print(w-200,0,"left/right : light angle");

font->Print(w-200,20,"up/down : mesh angle");

font->Print(w-200,40,"+/- : light intensity");

font->Print(w-200,60,"rgba : cycle color values");

KeyPressEvent* evt = (KeyPressEvent*) e;

switch(evt->keycode){

case DIK_ESCAPE: g_engine->Shutdown(); break;

//left/right arrow keys rotate light sourcecase DIK_LEFT: lightAngle -= 0.1f; break;

case DIK_RIGHT: lightAngle += 0.1f; break;

//up/down arrow keys rotate the meshcase DIK_UP: objectAngle -= 0.02f; break;

case DIK_DOWN: objectAngle += 0.02f; break;

//+/- keys change light powercase DIK_NUMPADPLUS: lightPower += 0.01f; break;

case DIK_NUMPADMINUS: lightPower -= 0.01f; break;

//rgba keys cycle color valuescase DIK_R: lightColor.r += 0.01f; break;

case DIK_G: lightColor.g += 0.01f; break;

case DIK_B: lightColor.b += 0.01f; break;

case DIK_A: lightColor.a += 0.01f; break;

}break;

}case EVENT_MOUSEMOTION:

{MouseMotionEvent* evt = (MouseMotionEvent*)e;

camera->Look( evt->deltax/100.0f, evt->deltay/100.0f, 0 );

break;

}case EVENT_MOUSEWHEEL:

{MouseWheelEvent* evt = (MouseWheelEvent*) e;

camera->Move(0, 0, (float)(-evt->wheel/200.0f) );

break;

}}

}

This hefty chapter covered a lot of ground, as a full-blown effect-based renderer

was added to the engine! While ambient wireframe and colored directional light

shaders are nothing to jump up and down with excitement over, they do have

their uses, and it has been extremely helpful to start with these very basic

examples for anyone who is new to shader programming One of the most

important components of rendering is missing, though—textured meshes I did

not get into texture mapping in this chapter because it requires a loaded mesh

with defined textures, which we’ll get into in the next chapter.

This page intentionally left blank

Mesh Loading and

Rendering

This chapter adds to the code base begun in the previous chapter on based lighting with some new techniques, such as texture-mapped lighting shaders, while exploring basic mesh loading and rendering.

shader-The following topics are covered in this chapter:

n .X Files

n Mesh class

n Textured ambient light rendering

n Lighting texture-mapped meshes

n Textured directional light shader

Mesh Loading and Rendering

Now we need to write the code for a new class that will load up a mesh from a X file, because in order to explore texturing we cannot use the stock meshes generated by theD3DXCreate?functions There are two ways to load a mesh with Direct3D—either as a hierarchical mesh with bone data and animation or as a simple static mesh without these features We’ll begin by writing a simple mesh loader that will not handle bone or animation data, and then return to these subjects in Chapter 13 and go over them with the full treatment At this point,

chapter 9

241Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

I ’m more concerned with shader code to light the scene, and we just need meshes to test our lighting effects.

.X Files

The primary way to get a mesh asset into the Direct3D rendering pipeline is by way of the X file format This is the standard Direct3D mesh file format, but it is not widely supported among the popular modeling and animation software packages (3DS Max and Maya being the most popular) There are exceptions, however The Game Creators (www.thegamecreators.com) sell a number of products that work well with the native X mesh file format, including Cartography Shop (Figure 9.1) and 3D World Studio.

Figure 9.1

Cartography Shop is a freewaremodeling package that can export directly to the X format

3D World Studio (http://leadwerks.com) is a great little environment modeling

package With a price tag of only $50, it will import and export files in the

.X format, as well as other popular formats such as Half-Life and Quake 3 files.

See Figure 9.2 for a screenshot.

Whether you create your own game level and character mesh assets or use free

assets from one of the many resources on the web that share Half-Life, Quake

III, 3DS, or DirectX mesh files, you will need to ultimately convert them to the

.X format for use in a Direct3D-based engine such as Octane (until such time

that you are willing and/or able to write reader code to support those file formats

internally) Later in this chapter is an example that renders a crate mesh,

which is just a cube and a wooden crate texture that is repeated on all six sides.

Figure 9.3 shows the crate mesh in the DirectX Viewer.

Figure 9.2

3D World Studio is an affordable modeling program with terrific features

Mesh Loading and Rendering 243

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Some X files contain ASCII text, which is readable and editable, while some X mesh files are binary and cannot be edited by hand, only with a modeling package that supports it (such as 3D World Studio).

Crate Mesh Internals

Below are the contents of thecrate.x file, which I have renamed tocrate_text.x

in the upcoming textured directional light demo After the templates, you will see the first Material definition, which contains vertex colors and a texture filename Beyond that is a single-frame animation set containing the crate vertex and face definitions Take note of the Mesh section itself, which contains theFigure 9.3

A wooden crate mesh rendered by the DirectX Viewer utility

vertices The values, or extents, in this mesh are quite large, in the range of 25 to

50 This tells me that the scenes this crate were designed for are also quite large in

scale It is perfectly acceptable to use dimensions for the crate in 3D space on the

order of 1 to þ1, if the environment is similarly scaled When you have a really

huge mesh like this, however, be sure to scale back your camera ’s position to take it

into account or you may assume that the mesh is not being rendered —when, in

fact, it is just not showing up because the camera resides inside it!

Mesh Loading and Rendering 245

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Mesh Loading and Rendering 247

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

to read in a X file, in either text mode or binary Note that each structure begins with a counter to tell you how many values are following in the file; this counter value will make loading a X file that much easier, as long as your loading function looks for blocks without expecting them in any particular order, since the X format does not define a rigid, sequential format Seeing the file laid out

on the page like this also helps to visualize how you might work with mesh data

in your own game engine, perhaps with the use of your own custom data format (along with a converter for X, of course!).

Asteroid Mesh Internals

Now let’s look at a less uniform mesh that is not quite as clean-cut as a boxy

crate—an asteroid with a lot of jagged edges Figure 9.4 shows the asteroid mesh

in the DirectX Viewer utility I’ll skip most of the definitions for the mesh since

it’s quite lengthy, and I just want you to see what the mesh’s internal

composition looks like.

Figure 9.4

An asteroid mesh rendered by the DirectX Viewer utility

Mesh Loading and Rendering 249

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com