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

44 Chapter 1

The pixel with the depth value closest to the camera wins, and that pixel gets written. This makes sense because the pixel closest to the camera obscures the pixels behind it.

The format of the depth buffer determines the accuracy of the depth test. That is, a 24-bit depth buffer is more accurate than a 16-bit depth buffer. In general, most applications work fine with a 24-bit depth buffer, although Direct3D also exposes a 32-bit depth buffer.

1.3.7 Vertex Processing

Vertices are the building blocks for 3D geometry, and they can be processed in two different ways, either in software (software vertex processing) or in hardware (hardware vertex processing). Software vertex processing is always supported and can always be used. On the other hand, hardware vertex processing can only be used if the graphics card supports vertex processing in hardware.

Hardware vertex processing is always preferred since dedicated hardware is faster than software. Furthermore, performing vertex processing in hardware unloads calculations from the CPU, which implies that the CPU is free to perform other calculations.

Note: Another way of saying a graphics card supports hardware vertex processing in hardware is to say that the graphics card supports transformation and lighting calculations in hardware.

1.3.8 Device Capabilities

Every feature that Direct3D exposes has a corresponding data member or bit in the D3DCAPS9 structure. The idea is to initialize the members of a D3DCAPS9 instance based on the capabilities of a particular hardware device. Then, in our application, we can check if a device supports a feature by checking the corresponding data member or bit in the D3DCAPS9 instance.

Team-Fly®

Direct3D Initialization 45

46 Chapter 1

processing or not. We need to know if it can in order to create the

IDirect3DDevice9 interface.

3.Initialize an instance of the D3DPRESENT_PARAMETERS structure. This structure consists of a number of data members that allow us to specify the characteristics of the IDirect3DDevice9 interface that we are going to create.

4.Create the IDirect3DDevice9 object based on an initialized

D3DPRESENT_PARAMETERS structure. As said, the IDirect3DDevice9 object is our C++ object that represents the physical hardware device that we use for displaying 3D graphics.

Keep in mind that in this book we use the primary display adapter for drawing 3D graphics. If your system only has one graphics card, that is the primary display adapter. If you have more than one graphics card, then the card you are presently using is the primary display adapter (e.g., the one displaying the Windows desktop, etc.).

1.4.1 Acquiring an IDirect3D9 Interface

Initialization of Direct3D begins by acquiring a pointer to an IDirect3D9 interface. This is easily done using a special Direct3D function, as the following lines of code show:

IDirect3D9* _d3d9;

_d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

The single parameter to Direct3DCreate9 should always be D3D_SDK_VERSION, which guarantees that the application is built against the correct header files. If this function fails, it returns a null pointer.

The IDirect3D9 object is used for two things: device enumeration and creating the IDirect3DDevice9 object. Device enumeration refers to finding out the capabilities, display modes, formats, and other information about each graphics device available on the system. For instance, to create the IDirect3DDevice9 object that represents a physical device, we need to create it using a configuration of display modes and formats that the physical device supports. To find such a working configuration, we must use the IDirect3D9 enumeration methods.

However, because device enumeration can be quite an involved task and we want to get up and running as quickly as possible with Direct3D, we have elected not to perform any enumeration, except for one check as shown in the next section. In order to safely skip

Direct3D Initialization 47

48 Chapter 1

vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

}

Observe that we save the type of vertex processing that we are going to use in the variable vp. This is because we are going to need to specify the vertex processing type that we are going to use later on when we create the IDirect3DDevice9 object.

Note: The identifiers D3DCREATE_HARDWARE_VERTEXPROCESSING and D3DCREATE_SOFTWARE_VERTEXPROCESSING are just predefined values that denote hardware vertex processing and software vertex processing, respectively.

Tip: When developing applications and using new, special, or advanced features (in other words, features that are not widely supported), it is recommended that you always check the device capabilities (D3DCAPS9) to see if the device supports the particular feature before using it. Never assume that a feature is available. Also, be aware that the sample applications in this book generally do not follow this advice — we generally do not check device capabilities.

Note: If a particular sample application isn’t working, it is most likely because your hardware doesn’t support the feature that the sample is using; try switching to the REF device.

1.4.3 Filling Out the D3DPRESENT_PARAMETERS

Structure

The next step in the initialization process is to fill out an instance of the D3DPRESENT_PARAMETERS structure. This structure is used to specify some of the characteristics of the IDirect3DDevice9 object that we are going to create, and is defined as:

typedef struct _D3DPRESENT_PARAMETERS_ {

} D3DPRESENT_PARAMETERS;

Note: In the following data member descriptions for the D3DPRESENT_PARAMETERS structure, we only cover the flags and options that we feel are the most important to a beginner at this point.

Direct3D Initialization 51

Figure 1.7: Screen shot of the sample for this chapter

52 Chapter 1

This sample and all the samples in this book use code from the d3dUtility.h and d3dUtility.cpp files, which can be found on this chapter’s web page on the book’s web site. These files contain functions that implement common tasks that every Direct3D application will need to do, such as creating a window, initializing Direct3D, and entering the application message loop. By wrapping up these common tasks in functions, the samples are more focused on the particular chapter’s topic. In addition, we add useful utility code to these files as we progress through the book.

1.5.1 d3dUtility.h/cpp

Before we get started on this chapter’s sample, let’s spend some time getting familiar with the functions provided by d3dUtility.h/cpp. The d3dUtility.h file looks like this:

//Include the main Direct3DX header file. This will include the

//other Direct3D header files we need.

#include <d3dx9.h>

namespace d3d

{

// [in] Application instance. // [in] Back buffer dimensions. // [in] Windowed (true)or

// full screen (false). D3DDEVTYPE deviceType, // [in] HAL or REF IDirect3DDevice9** device); // [out] The created device.

int EnterMsgLoop(

bool (*ptr_display)(float timeDelta));

LRESULT CALLBACK WndProc(

HWND hwnd,

UINT msg,

WPARAM wParam,

LPARAM lParam);

template<class T> void Release(T t)

{

if( t )

{

t->Release(); t = 0;

}

}

template<class T> void Delete(T t)

{

if( t )

{

delete t;