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

84 Chapter 3

3.4.3 Begin/End Scene

The last bit of information to mention is that all drawing methods must be called inside an IDirect3DDevice9::BeginScene and

IDirect3DDevice9::EndScene pair. For example, we would write:

_device->BeginScene(); _device->DrawPrimitive(...);

_device->EndScene();

Figure 3.3: Objects created and rendered using the D3DXCreate* functions

All six are used similarly and use the D3DX mesh data structure ID3DXMesh as well as the ID3DXBuffer interface. These interfaces are covered in Chapters 10 and 11. For now, we ignore their details and concentrate on using them in the simplest way.

HRESULT D3DXCreateTeapot(

LPDIRECT3DDEVICE9 pDevice, // device associated with the mesh LPD3DXMESH* ppMesh, // pointer to receive mesh LPD3DXBUFFER* ppAdjacency // set to zero for now

);

Team-Fly®

Drawing in Direct3D 85

An example of using the D3DXCreateTeapot function:

ID3DXMesh* mesh = 0;

D3DXCreateTeapot(_device, &mesh, 0);

Once we have generated the mesh data, we can draw it using the ID3DXMesh::DrawSubset method. This method takes one parameter, which identifies a subset of the mesh. The meshes generated by the above D3DXCreate* functions create a mesh with only one subset, so zero can be specified for this parameter. An example of rendering the mesh:

There are four samples located in this chapter’s directory in the book’s companion files, which can be downloaded from the book’s web site.

Triangle—This very simple application demonstrates how to create and render a triangle in the wireframe mode.

Cube—A little more advanced than the triangle sample, this application renders a spinning wireframe cube.

Teapot—This application uses the D3DXCreateTeapot function to create and render a spinning teapot.

D3DXCreate—This application creates and renders several different kinds of 3D objects that can be created with the D3DXCreate* functions.

Let’s briefly discuss the implementation of the Cube sample. You can study the others on your own.

The sample application draws and renders a cube, as shown in Figure 3.4. The project and complete source code for this sample can be found on this chapter’s web page.

86 Chapter 3

Figure 3.4 A screen shot from the CubeApp sample

First we instantiate the following two global variables to hold the vertex and index data of our cube:

IDirect3DVertexBuffer9* VB = 0;

IDirect3DIndexBuffer9* IB = 0;

In addition, we instantiate two constant global variables that define the resolution of our screen:

const int Width = 800;

const int Height = 600;

We then define our vertex structure and the flexible vertex format of that structure. The vertex structure in this sample holds only vertex position information:

struct Vertex

{

Vertex(){}

Vertex(float x, float y, float z)

{

_x = x; _y = y; _z = z;

}

float _x, _y, _z; static const DWORD FVF;

};

const DWORD Vertex::FVF = D3DFVF_XYZ;

Let’s move on to the framework functions. The Setup function creates the vertex and index buffers, locks them, writes the vertices that make up the cube to the vertex buffer, and writes the indices that define the triangles of the cube. It then moves the camera a few units back so that it can see the cube that will be rendered at the origin of the world. Then it sets the projection transform. Finally, it sets the fill mode render state to wireframe mode:

bool Setup()

{

Drawing in Direct3D 87

88 Chapter 3

// bottom

indices[30] = 4; indices[31] = 0; indices[32] = 3; indices[33] = 4; indices[34] = 3; indices[35] = 7;

IB->Unlock();

// position and aim the camera D3DXVECTOR3 position(0.0f, 0.0f, -5.0f); D3DXVECTOR3 target(0.0f, 0.0f, 0.0f); D3DXVECTOR3 up(0.0f, 1.0f, 0.0f); D3DXMATRIX V;

D3DXMatrixLookAtLH(&V, &position, &target, &up);

Device->SetTransform(D3DTS_VIEW, &V);

//set projection matrix D3DXMATRIX proj; D3DXMatrixPerspectiveFovLH(

&proj,

D3DX_PI * 0.5f, // 90 - degree (float)Width / (float)Height, 1.0f,

1000.0f); Device->SetTransform(D3DTS_PROJECTION, &proj);

//set the render states

Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

return true;

}

The Display method has two tasks; it must update the scene and then render it. Since we want to spin the cube, we are going to increment an angle every frame that specifies how much the cube is to rotate that frame. By incrementing it every frame, the cube will be slightly more rotated every frame, making it look like it is spinning. Notice that we use the world transformation to actually orient the cube. Then we draw the cube using the IDirect3DDevice9::DrawIndexedPrimitive method.

bool Display(float timeDelta)

{

if( Device )

{

//

//spin the cube:

D3DXMATRIX Rx, Ry;

//rotate 45 degrees on x-axis D3DXMatrixRotationX(&Rx, 3.14f / 4.0f);

//incremement y-rotation angle each frame static float y = 0.0f; D3DXMatrixRotationY(&Ry, y);

Drawing in Direct3D 89

92 Chapter 4

Note: Do not worry about the alpha component now; it is used for alpha blending—the topic of Chapter 7.

Specifying each component and then inserting it into the proper position in the D3DCOLOR type will require some bit operations. Direct3D provides a macro that performs this for us called D3DCOLOR_ARGB.

There is one parameter for each color component and the alpha component. Each parameter must be in the range 0-255 and is used like so:

D3DCOLOR brightRed = D3DCOLOR_ARGB(255, 255, 0, 0);

D3DCOLOR someColor = D3DCOLOR_ARGB(255, 144, 87, 201);

Alternatively, we can use the D3DCOLOR_XRGB macro, which is similar but does not take the alpha parameter; rather, it sets the alpha to 0xff (255).

#define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b)

Another way to store a color in Direct3D is with the D3DCOLORVALUE structure. With this structure we use a floating-point value to measure the intensity of each component. The range measures from 0 to 1—0 being no intensity and 1 being full intensity.

typedef struct _D3DCOLORVALUE {

float r; // the red component, range 0.0-1.0 float g; // the green component, range 0.0-1.0

float b; // the blue component, range 0.0-1.0 float a; // the alpha component, range 0.0-1.0

} D3DCOLORVALUE;

Alternatively, we can use the D3DXCOLOR structure, which contains the same data members as D3DCOLORVALUE but provides useful constructors and overloaded operators, making color manipulations easy. In addition, since they can contain the same data members, we can cast back and fourth between the two. D3DXCOLOR is defined as:

typedef struct D3DXCOLOR

{

#ifdef __cplusplus public:

D3DXCOLOR() {} D3DXCOLOR( DWORD argb );

D3DXCOLOR( CONST FLOAT * ); D3DXCOLOR( CONST D3DXFLOAT16 * ); D3DXCOLOR( CONST D3DCOLORVALUE& );

D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a );

// casting

operator DWORD () const;

operator FLOAT* ();

operator CONST FLOAT* () const;

Color 93