Working with Textures in DirectX

Textures are fundamental to creating visually rich and detailed 3D graphics in DirectX. They are essentially 2D images (or 3D/cubemap arrays) that are applied to the surfaces of your models to provide color, detail, and surface properties.

What are Textures?

In DirectX, a texture is a data resource that the GPU samples from during the rendering process. This sampling can be used for various purposes:

• Color (Albedo): Applying realistic surface colors and patterns.
• Normals: Storing normal vectors to simulate surface bumps and details without adding extra geometry (Normal Mapping).
• Roughness/Metallic: Controlling how light reflects off the surface.
• Height/Displacement: Modifying the geometry itself.
• Other data: Such as environmental maps, specular maps, and more.

Texture Formats

DirectX supports a wide array of texture formats, each optimized for different use cases and performance characteristics. Common formats include:

• Uncompressed: DXGI_FORMAT_R8G8B8A8_UNORM (RGBA 8-bit per channel), DXGI_FORMAT_B8G8R8A8_UNORM (BGRA 8-bit per channel).
• Compressed: BCn formats (e.g., DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_BC7_UNORM) offer significant memory and bandwidth savings, often with minimal visual loss.
• HDR: Floating-point formats like DXGI_FORMAT_R16G16B16A16_FLOAT for high dynamic range content.

Choosing the right format is crucial for balancing visual quality, memory usage, and performance.

Creating and Loading Textures

Textures can be created in several ways:

• From Image Files: Using libraries like DirectXTex or the Direct3D 11/12 API to load common image formats (DDS, PNG, JPG).
• Procedurally Generated: Creating textures entirely within your application using code.
• As Render Targets: Textures can also be the destination of rendering operations, commonly used for post-processing effects or reflections.

Loading a Texture (Conceptual Example)

Here's a simplified conceptual look at loading a texture from a file. In practice, you'd use helper functions or libraries.

// Assume 'device' is your ID3D11Device or ID3D12Device

ID3D11ShaderResourceView* LoadTextureFromFile(const std::wstring& filename, ID3D11Device* device)
{
    // Use DirectXTex or similar library to load image data
    // Convert to a suitable DirectX format
    // Create a D3D11_TEXTURE2D_DESC
    // Create the ID3D11Texture2D resource
    // Update the texture with loaded data
    // Create an ID3D11ShaderResourceView

    // Placeholder for actual loading logic
    ID3D11ShaderResourceView* srv = nullptr;
    // ... actual loading and resource creation ...
    return srv;
}
            

Texture Samplers

A sampler is an object that defines how a texture is sampled. It controls aspects like:

• Filtering: How texel values are interpolated (Point, Bilinear, Trilinear, Anisotropic).
• Addressing Mode: What happens when texture coordinates go outside the [0, 1] range (Wrap, Clamp, Mirror, Border).
• MIP Mapping: How different levels of detail (MIPs) are selected.

Creating a Sampler State (Direct3D 11)

// Assume 'device' is your ID3D11Device

D3D11_SAMPLER_DESC samplerDesc = {};
samplerDesc.Filter = D3D11_FILTER_ANISOTROPIC; // High-quality filtering
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; // Wrap coordinates
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 16; // Maximum anisotropic level
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS_GREATER_EQUAL;
samplerDesc.BorderColor[0] = samplerDesc.BorderColor[1] = samplerDesc.BorderColor[2] = samplerDesc.BorderColor[3] = 0.0f;
samplerDesc.MinLOD = 0.0f;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

ID3D11SamplerState* samplerState = nullptr;
HRESULT hr = device->CreateSamplerState(&samplerDesc, &samplerState);
if (FAILED(hr)) {
    // Handle error
}
// Bind samplerState to the pipeline
            

Using Textures in Shaders

In your shaders (HLSL/GLSL), you declare texture objects and then use sampler functions to read from them. The texture data is accessed using texture coordinates (UVs) typically supplied by your vertex shader.

Example HLSL Shader Snippet

// --- Vertex Shader ---
struct VS_INPUT
{
    float4 Pos : POSITION;
    float2 Tex : TEXCOORD;
};

struct VS_OUTPUT
{
    float4 Pos : SV_POSITION;
    float2 Tex : TEXCOORD;
};

VS_OUTPUT VS(VS_INPUT input)
{
    VS_OUTPUT output;
    output.Pos = mul(input.Pos, g_worldViewProjection); // g_worldViewProjection is a constant buffer
    output.Tex = input.Tex;
    return output;
}

// --- Pixel Shader ---
Texture2D      g_Texture : register(t0); // Texture resource
SamplerState   g_Sampler : register(s0); // Sampler state

float4 PS(VS_OUTPUT input) : SV_TARGET
{
    // Sample the texture using the sampler
    float4 texColor = g_Texture.Sample(g_Sampler, input.Tex);
    return texColor;
}
            

MIP Maps

MIP maps are pre-calculated, downscaled versions of a texture. They are essential for performance and visual quality, especially for objects at varying distances. The GPU automatically selects the appropriate MIP level based on the screen-space size of the textured surface, reducing aliasing and improving rendering speed by using smaller textures.

Different levels of a texture's MIP map chain.

Common Texture Maps

• Albedo/Diffuse Map: Base color of the surface.
• Normal Map: Encodes surface normals for bumpiness.
• Specular Map: Controls the intensity and color of specular highlights.
• Roughness Map: Determines how "rough" or "smooth" a surface is, affecting the sharpness of reflections.
• Metallic Map: Defines whether a surface is metallic or dielectric.
• Ambient Occlusion (AO) Map: Simulates shadowing in crevices and ambient areas.
• Emissive Map: Defines areas that emit light.

Effectively utilizing these maps, often in conjunction with physically based rendering (PBR) principles, allows for highly realistic materials.