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

114 Chapter 6

Example:

Device->SetTexture(0, _stonewall);

Note: In Direct3D, you can set up to eight textures that can be combined to create a more detailed image. This is called multitexturing. We do not use multitexturing in this book until Part IV; therefore we always set the textures stage to 0, for now.

To disable a texture at a particular texturing stage, set pTexture to 0. For instance, if we don’t want to render an object with a texture, we would write:

Device->SetTexture(0, 0); renderObjectWithoutTexture();

drawTrisUsing ex1();

As mentioned previously, textures are mapped to triangles in screen space. Usually, the texture triangle is not the same size as the screen triangle. When the texture triangle is smaller than the screen triangle, the texture triangle is magnified to fit. When the texture triangle is larger than the screen triangle, the texture triangle is minified to fit. In both cases, distortion will occur. Filtering is a technique Direct3D uses to help smooth out these distortions.

Direct3D provides three different types of filters; each one provides a different level of quality. The better the quality, the slower it is, so you must make the trade-off between quality and speed. Texture filters are set with the IDirect3DDevice9::SetSamplerState method.

Nearest point sampling—This is the default filtering method and produces the worst-looking results, but it is also the fastest to compute. The following code sets nearest point sampling as the minification and magnification filter:

Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);

Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);

Linear filtering—This type of filtering produces fairly good results and can be done very fast on today’s hardware. It is

Team-Fly®

Texturing 115

recommended that you use linear filtering as a minimum. The following code sets linear filtering as the minification and magnification filter:

Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);

Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);

Anisotropic filtering—This type of filtering produces the best results but also takes the longest to compute. The following code sets anisotropic filtering as the minification and magnification filter:

6.4 Mipmaps

As said in section 6.3, the triangle on the screen is usually not the same size as the texture triangle. In an effort to make the size difference less drastic, we can create a chain of mipmaps for a texture. The idea is to take a texture and create a series of smaller lower resolution textures but customize the filtering for each of these levels so it preserves the detail that is important for us (see Figure 6.4).

Figure 6.4: A chain of mipmaps; notice that each successive mipmap is half the size of the previous mipmap.

116 Chapter 6

6.4.1 Mipmap Filter

The mipmap filter is used to control how Direct3D uses the mipmaps. You can set the mipmap filter by writing:

Device->SetSamplerState(0, D3DSAMP_MIPFILTER, Filter);

where Filter is one of the following three options:

D3DTEXF_NONE—Disables mipmapping

D3DTEXF_POINT—By using this filter, Direct3D will choose the mipmap level that is closest in size to the screen triangle. Once that level is chosen, Direct3D will filter that level based on the specified min and mag filters.

D3DTEXF_LINEAR—By using this filter, Direct3D will take the two closest mipmap levels, filter each level with the min and mag filters, and linearly combine these two levels to form the final color values.

6.4.2Using Mipmaps with Direct3D

Using mipmaps with Direct3D is easy. If the device supports mipmaps, D3DXCreateTextureFromFile will generate a mipmap chain for you. In addition, Direct3D automatically selects the mipmap that matches the screen triangle the best. So mipmapping is pretty much used and set up automatically.

6.5 Address Modes

Previously, we stated that texture coordinates must be specified in the range [0, 1]. Technically, that is not correct; they can go outside that range. The behavior for texture coordinates that go outside the [0, 1] range is defined by the Direct3D address mode. There are four types of address modes: wrap, border color, clamp, and mirror, which are illustrated in Figures 6.5, 6.6, 6.7, and 6.8, respectively.

Figure 6.5: Wrap mode

118 Chapter 6

Device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);

}

// set mirror address mode

if( ::GetAsyncKeyState('M') & 0x8000f )

{

Device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_MIRROR); Device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_MIRROR);

}

6.6 Sample Application: Textured Quad

The sample for this chapter demonstrates how to texture a quad and set a texture filter (see Figure 6.9). A mipmap chain is created automatically with the D3DXCreateTextureFromFile function if the device supports mipmapping.

Figure 6.9:

A screen shot of a textured quad taken from the TexQuad sample

Note: There are two additional samples on the web page for this chapter. One sample textures a cube with the crate texture, as shown in Figure 6.1. The second demonstrates texture address modes.

The tasks required for adding textures to a scene are:

1.Construct the vertices of the objects with the texture coordinates specified.

2.Load a texture into an IDirect3DTexture9 interface using the

D3DXCreateTextureFromFile function.

3.Set the minification, magnification, and mipmap filters.

4.Before you draw an object, set the texture that is associated with the object with IDirect3DDevice9::SetTexture.

Texturing 119

We begin by instantiating several global variables; one is the vertex buffer that stores the vertices of the quad and the other is the texture that we map to the quad:

IDirect3DVertexBuffer9* Quad = 0;

The Setup routine is fairly straightforward; we construct a quad from two triangles with texture coordinates defined. We then load the bitmap file dx5_logo.bmp into an IDirect3DTexture9 interface. Next we enable the texture using the SetTexture method. Finally, we set the minification and magnification filters to linear filtering, and we also set the mipmap filter to D3DTEXF_POINT:

120 Chapter 6

&proj,

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

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

// don't use lighting for this sample Device->SetRenderState(D3DRS_LIGHTING, false);

return true;

}

We can now render our quad as normal, and the currently set texture is mapped to it:

bool Display(float timeDelta)

{

if( Device )

{

Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);

Device->BeginScene();

Device->SetStreamSource(0, Quad, 0, sizeof(Vertex));

Device->SetFVF(Vertex::FVF);

// Draw primitives using presently enabled texture. Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

Device->EndScene(); Device->Present(0, 0, 0, 0);

}

return true;

}

6.7Summary

Texture coordinates are used to define a triangle on the texture that gets mapped to the 3D triangle.

We can create textures from image files stored on disk using the

D3DXCreateTextureFromFile function.

We can filter textures by using the minification, magnification, and mipmap filter sampler states.

Address modes define what Direct3D is supposed to do with texture coordinates outside the [0, 1] range. For example, should the texture be tiled, mirrored, clamped, etc.?

122 Chapter 7

Suppose that we want to draw the teapot with a level of transparency so that we could see the background crate through the teapot (see Figure 7.2).

Figure 7.2: A transparent teapot

How would we accomplish this? As we are rasterizing the teapot’s triangles on top of the crate, we need to combine the pixel colors being computed for the teapot with the pixel colors of the crate in such a way that the crate shows through the teapot. The idea of combining the pixel values that are currently being computed (source pixel) with the pixel values previously written (destination pixel) is called blending. Note that the effect of blending is not limited to ordinary glass-like transparency. We have a variety of options that specify how the colors are combined, as seen in section 7.2.

It is important to realize that the triangles currently being rasterized are blended with the pixels that were previously written to the back buffer. In the example figures, the crate image is drawn first so that the crate’s pixels are on the back buffer. We then draw the teapot so that the teapot’s pixels are blended with the crate’s pixels. Thus, the following rule should be followed when using blending:

Rule: Draw objects that do not use blending first. Then sort the objects that use blending by their distance from the camera; this is most efficiently done if the objects are in view space so that you can sort simply by the z-component. Finally, draw the objects that use blending in a back-to-front order.

The following formula is used to blend two pixel values:

OutputPixel = SourcePixel SourceBlendFactor + DestPixel DestBlendFactor

7.2 Blend Factors

By setting different combinations of source and destination blend factors, you can create dozens of different blending effects. Experiment with different combinations to see what they do. You can set the source blend factor and the destination blend factor by setting the D3DRS_ SRCBLEND and D3DRS_DESTBLEND render states, respectively. For example, we can write:

Device->SetRenderState(D3DRS_SRCBLEND, Source);

Device->SetRenderState(D3DRS_DESTBLEND, Destination);

where Source and Destination can be one of the following blend factors:

D3DBLEND_ZERO—blendFactor=(0, 0, 0, 0)

D3DBLEND_ONE—blendFactor=(1, 1, 1, 1)

D3DBLEND_SRCCOLOR—blendFactor=(rs, gs, bs, as)