MSDN Documentation

Core Concepts in DirectX Computational Graphics

This section delves into the fundamental building blocks and concepts that underpin DirectX computational graphics. A strong understanding of these principles is essential for developing efficient and visually stunning graphics applications.

1. The Graphics Pipeline

The graphics pipeline is a series of programmable stages that transform 3D geometric data into a 2D image displayed on your screen. DirectX provides a highly flexible and programmable pipeline, allowing developers fine-grained control over each step.

• Input Assembler: Reads geometric data (vertices, indices) from memory.
• Vertex Shader: Processes each vertex individually, transforming its position, calculating lighting, and passing data to the next stage.
• Tessellation Stages (Optional): Subdivides geometry for increased detail.
• Geometry Shader (Optional): Generates or modifies entire primitives (points, lines, triangles).
• Rasterizer: Converts geometric primitives into pixels.
• Pixel Shader (Fragment Shader): Determines the color of each pixel, often involving texturing, lighting, and complex effects.
• Output Merger: Combines the output from the pixel shader with the existing frame buffer, performing depth testing, stencil testing, and blending.

2. Resources: Buffers and Textures

DirectX manages graphical data through various resource types. The primary ones are buffers and textures.

Buffers

Buffers are contiguous blocks of memory used to store data. Common buffer types include:

• Vertex Buffer: Stores vertex data (position, color, UV coordinates, normal vectors).
• Index Buffer: Stores indices that define the order in which vertices are drawn, enabling efficient reuse of vertices.
• Constant Buffer: Stores constant data that is shared across multiple shader invocations (e.g., transformation matrices, material properties).
• Structured Buffer: A flexible buffer that can be accessed by shaders using a defined structure.

Example of vertex data definition:

struct Vertex {
    float3 position : POSITION;
    float4 color : COLOR;
    float2 texCoord : TEXCOORD;
};

Textures

Textures are 2D (or 3D, or array) images used to add detail and visual richness to models. They are sampled by pixel shaders to determine surface properties.

• Diffuse Map: Defines the base color of a surface.
• Normal Map: Simulates surface detail and lighting by storing surface normals.
• Specular Map: Controls the intensity and color of specular highlights.
• Ambient Occlusion Map: Adds subtle shadowing to crevices and corners.

3. Data Types and Precision

DirectX uses specific data types for graphics programming, particularly for shader languages like HLSL (High-Level Shading Language).

• float, half, double: Single, half-precision, and double-precision floating-point numbers. Half-precision is often preferred for performance.
• int, uint: Signed and unsigned integers.
• bool: Boolean values.
• Vectors: Types like float2, float3, float4 are fundamental for representing positions, colors, directions, and texture coordinates.
• Matrices: Types like float4x4 (or matrix) are used for transformations (world, view, projection).

Precision modifiers (e.g., lowp, mediump, highp in some contexts) can be used to optimize performance by reducing the precision of calculations, though this is more explicit in OpenGL ES and can be implicit or managed differently in DirectX depending on the shader model and target hardware.

4. Coordinate Systems

Understanding coordinate systems is crucial for positioning objects, applying transformations, and correctly rendering scenes.

• Local (Object) Space: The coordinate system of an individual model, with its origin typically at the model's center or pivot point.
• World Space: A single, global coordinate system where all objects in the scene are positioned and oriented.
• View (Camera) Space: The coordinate system from the perspective of the camera. Objects are transformed so that the camera is at the origin, looking down a particular axis (often the negative Z-axis).
• Clip Space: The coordinate system after projection. Objects are transformed into a canonical view volume.
• Screen Space (Normalized Device Coordinates - NDC): The space after perspective division, typically ranging from -1 to 1 on X and Y axes.
• Viewport Space: The final 2D pixel coordinates on the screen, where the NDC coordinates are mapped to the actual resolution of the rendering target.

5. Transformations

Transformations are mathematical operations used to manipulate the position, orientation, and scale of objects in 3D space. These are typically represented by matrices.

• Translation: Moving an object.
• Rotation: Rotating an object around an axis.
• Scaling: Resizing an object.

These transformations are often combined into a single Model-View-Projection (MVP) matrix to efficiently transform vertices from local space directly to clip space.

By mastering these core concepts, you will build a solid foundation for tackling more complex techniques in DirectX computational graphics.