Geometric Transformations in DirectX

Understanding and implementing 2D and 3D transformations for graphical rendering.

What are Geometric Transformations?

Geometric transformations are fundamental operations in computer graphics used to manipulate the position, orientation, and size of objects within a 2D or 3D scene. DirectX provides powerful tools and matrix-based operations to efficiently perform these transformations.

Key Transformation Types

1. Translation

Translation involves moving an object from one point to another without changing its orientation or size. In 2D, a point (x, y) is translated by (tx, ty) to a new position (x + tx, y + ty). In 3D, this extends to (x + tx, y + ty, z + tz).

In matrix form, using homogeneous coordinates, translation can be represented as:

[ x' ] [ 1 0 0 tx ] [ x ]
[ y' ] = [ 0 1 0 ty ] [ y ]
[ z' ] [ 0 0 1 tz ] [ z ]
[ 1 ] [ 0 0 0 1 ] [ 1 ]

2. Rotation

Rotation changes the orientation of an object around a specific point (the origin by default) by a given angle. DirectX typically uses counter-clockwise rotation.

For 2D rotation around the origin by an angle θ:

[ x' ] [ cos(θ) -sin(θ) ] [ x ]
[ y' ] = [ sin(θ) cos(θ) ] [ y ]

For 3D, rotations can occur around the X, Y, or Z axes, each with its own matrix representation. Combined rotations can be achieved by multiplying their respective matrices.

3. Scaling

Scaling alters the size of an object. It can be uniform (scaling equally in all directions) or non-uniform (scaling differently along different axes).

For 2D scaling by factors sx and sy:

[ x' ] [ sx 0 ] [ x ]
[ y' ] = [ 0 sy ] [ y ]

In 3D, this extends to three scaling factors: sx, sy, and sz.

Combining Transformations: The World Matrix

In DirectX, transformations are typically combined into a single matrix, often referred to as the world matrix. This matrix encapsulates all the translation, rotation, and scaling operations applied to an object in its local coordinate system to place it correctly within the 3D world.

The order of matrix multiplication is crucial. Generally, transformations are applied in the reverse order they appear in the matrix multiplication:

WorldMatrix = TranslationMatrix * RotationMatrix * ScalingMatrix

This means that scaling is applied first to the object's local coordinates, then rotation, and finally translation to position it in the world.

Implementing Transformations in DirectX

DirectX uses the D3DXMATRIX structure (or the newer DirectX::XMMATRIX in DirectXMath) to represent matrices. Functions like D3DXMatrixTranslation, D3DXMatrixRotationX, D3DXMatrixScaling, and D3DXMatrixMultiply are used to construct and combine these transformation matrices.

Example: Translating a Cube

To translate a cube 5 units along the X-axis and 2 units along the Z-axis, you would create a translation matrix and multiply it with the current world matrix:


#include <d3dx9.h> // Or <DirectXMath.h>

D3DXMATRIX matTranslation;
D3DXMatrixTranslation(&matTranslation, 5.0f, 0.0f, 2.0f);

// Assume pMatWorld is the current world matrix
D3DXMATRIX matWorld;
// ... initialize matWorld ...

D3DXMatrixMultiply(&matWorld, &matWorld, &matTranslation);

// Set the transformed world matrix for rendering
pDevice->SetTransform(D3DTS_WORLD, &matWorld);