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

24 Part I

Applying the sequence of transformations in the order scaling, rotating, and translating, we obtain:

One of the key benefits of matricesFis that we can use matrix multiplication to combine several transformations into one matrix. For

Then pQ = [1.707, 2, –3.707, 1].

The ability to combine transformations has performance implications. Suppose that we need to apply the same scaling, rotation, and translation transformations to a large set of vectors (a common task in 3D graphics). Instead of applying a sequence of transformations, as we did in equation (5), per vector, we can combine all three transformations into one matrix, as we did in equation (6). Then we only have to

Team-Fly®

Planes (Optional)

A plane can be described with a vector n and a point on the plane p0. The vector n is called the plane’s normal vector and is perpendicular to the plane (see Figure 11).

Figure 11: A plane defined by a normal vector n and a point on the plane p0

26 Part I

In Figure 12 we see that the graph of a plane is all the points p that satisfy the equation.

(7) n p p0 0

Figure 12: If p0 is a point on the plane, then the point p is also on the plane if the vector formed from (p – p0) is orthogonal to the plane’s normal vector.

When describing a particular plane, the normal n and a known point on the plane p0 are fixed, so it is typical to write equation (7) as:

(8)n p d 0

where d = –n p0.

Note: If the plane’s normal vector n is of unit length, d = –n p0 gives the shortest signed distance from the origin to the plane.

D3DXPLANE

When representing a plane in code, it suffices to store only the normal vector n and the constant d. It is useful to think of this as a 4D vector, which we denote as (n, d). The D3DX library uses the following structure for a plane:

typedef struct D3DXPLANE

{

#ifdef __cplusplus public:

D3DXPLANE() {}

D3DXPLANE( CONST FLOAT* ); D3DXPLANE( CONST D3DXFLOAT16* );

D3DXPLANE( FLOAT a, FLOAT b, FLOAT c, FLOAT d );

//casting operator FLOAT* ();

operator CONST FLOAT* () const;

//unary operators

D3DXPLANE operator + () const;

D3DXPLANE operator - () const;

// binary operators

BOOL operator == ( CONST D3DXPLANE& ) const; BOOL operator != ( CONST D3DXPLANE& ) const;

Point and Plane Spatial Relation

Equation (8) is primarily useful for testing the location of points relative to the plane. For example, given the plane (n, d), we can test how a particular point p is in relation with the plane:

If n p + d = 0, then p is coplanar with the plane.

If n p + d > 0, then p is in front of the plane and in the plane’s positive half-space.

If n p + d < 0, then p is in back of the plane and in the plane’s negative half-space.

Note: If the plane’s normal vector n is of unit length, then n p + d gives the shortest signed distance from the plane to the point p.

This next D3DX function evaluates n p + d for a particular plane and point:

// Test the locality of a point relative to a plane. D3DXPLANE p(0.0f, 1.0f, 0.0f, 0.0f);

Note: We say “approximately equals” due to floating-point imprecision. See the note in the section titled “Vector Equality.”

Note: Methods similar to D3DXPlaneDotCoord are D3DXPlaneDot and D3DXPlaneDotNormal. See the DirectX documentation for details.

Construction

Besides directly specifying the normal and signed distance of a plane, we can calculate these two components in two ways. Given the normal n and a known point on the plane p0, we can solve for the d component:

28 Part I

n p0 d 0 n p0 dn p0 d

The D3DX library provides the following function to perform this calculation:

D3DXPLANE *D3DXPlaneFromPointNormal(

The second way that we can construct a plane is by specifying three points on the plane.

Given the points p0, p1, p2, we can form two vectors on the plane:

up1 p0

vp2 p0

From that we can compute the normal of the plane by taking the cross product of the two vectors on the plane. Remember the left hand thumb rule.

n u v

Then, –(n p0) = d.

The D3DX library provides the following function to compute a plane, given three points on the plane:

Normalizing a Plane

Sometimes we might have a plane and would like to normalize the normal vector. At first thought, it would seem that we could just normalize the normal vector as we would any other vector. But recall that

d = –n p0 in n p + d = 0. We see that the length of the normal vector

influences the constant d. Therefore, if we normalize the normal vector,

d n nn

30 Part I

Figure 13: The point q on the plane (n d) nearest to p. Observe that the shortest signed distance k from p to the plane is positive, since p is in the positive half-space of (n d). If p was behind the plane, then k < 0.

From Figure 13 we can see that q = p + (–kn), where k is the shortest signed distance from p to the plane, which is also the shortest signed distance between the points p and q. Recall that if the plane’s normal vector n is of unit length, then n p + d gives the shortest signed distance from the plane to the point p.

Rays (Optional)

Suppose a player in a game that we are working on fires his gun at an enemy. How would we determine whether the bullet starting from a particular position and aimed in a direction hit the target? One approach would be to model the bullet with a ray and model the enemy with a bounding sphere. (A bounding sphere is simply a sphere that tightly surrounds an object, thus roughly approximating its volume. Bounding spheres are explained more in Chapter 11.) Then mathematically we can determine whether the ray hit the sphere and where. In this section we learn how to model rays mathematically.

Rays

A ray can be described with an origin and a direction. The parametric equation of a ray is:

(9) p t p0 tu

Figure 14: A ray described by an origin p0 and direction u. We can generate points on the ray by plugging in scalars for t that are greater than or equal to zero.

If t is not in the interval [0, ), the ray does not intersect the plane.

If t is in the interval [0, ), the intersection point is found by plugging the parameter that satisfies the plane equation into the ray equation:

32 Part I

Summary

Vectors are used to model physical quantities that possess a magnitude and direction mathematically. Geometrically, we represent a vector with a directed line segment. A vector is in standard position when it is translated parallel to itself so that its tail coincides with the origin of the coordinate system. A vector in standard position can be described algebraically by specifying the coordinates of its head.

We can use 4 4 matrices to represent transformations and 1 4

homogeneous vectors to describe points and vectors. The vectormatrix product of a 1 4 row vector and a 4 4 transformation matrix results in a new transformed 1 4 row vector. Several transformation matrices can be combined into one transformation matrix through matrix-matrix multiplication.

We use 4D homogeneous vectors to represent both vectors and

points. We specify 0 for the w component to denote a vector and 1 for the w component to denote a point. If w 0 and w 1, then we have a vector (x, y, z, w) in homogeneous space that can be mapped back to 3-space by dividing each component by w:

Planes divide 3D space into two parts: a positive half-space, which is the space in front of the plane, and a negative half-space, which is the space behind the plane. Planes are useful for testing the locality of points relative to them (in other words, what half-space a point exists in relative to a particular plane).

Rays are described parametrically with an origin and direction vector. Rays are useful for modeling various physical quantities, such as light rays and projectiles that approximately follow a linear path such as bullets and rockets.