Mastering Texturing in DirectX Computational Graphics

Understanding Textures and UV Mapping

A texture is essentially an image that is "wrapped" around a 3D model's surface. This process allows for a vast amount of visual information to be stored in a relatively small amount of memory. To correctly apply a texture, we use a process called UV mapping.

• UV Coordinates: Each vertex of a 3D model is assigned a 2D coordinate (U, V), where U corresponds to the horizontal axis and V to the vertical axis of the texture image. These coordinates tell the rendering engine which part of the texture to sample for each part of the model.
• Texture Atlas: Often, multiple smaller textures are combined into a single larger image, called a texture atlas, to optimize texture sampling and reduce memory overhead.

Visualizing UV Mapping

Loading and Managing Textures in DirectX

DirectX provides powerful tools for loading and managing textures. The most common formats are DDS (DirectDraw Surface), TGA, and PNG. We'll focus on using the DirectX Tex library for efficient loading and processing.

Key DirectX Objects for Textures

• ID3D11ShaderResourceView: This object provides a view into a texture resource, allowing shaders to read from it.
• ID3D11Texture2D: Represents a 2D texture resource itself, holding the pixel data.

Code Snippet: Loading a Texture

// Assuming pDevice and pDeviceContext are valid ID3D11Device and ID3D11DeviceContext pointers

HRESULT hr;
std::unique_ptr<DirectX::ScratchImage> image = std::make_unique<DirectX::ScratchImage>();

// Load texture from file (e.g., a .dds file)
hr = DirectX::LoadFromDDSFile(L"path/to/your/texture.dds", DirectX::DDS_FLAGS_NONE, nullptr, *image);

if (FAILED(hr)) {
    // Handle error
    return hr;
}

// Create a shader resource view from the loaded image
hr = DirectX::CreateShaderResourceView(
    pDevice,
    image->GetImages(), image->GetImageCount(), image->GetMetadata(),
    &m_pTextureSRV // Assume m_pTextureSRV is an ID3D11ShaderResourceView* member
);

// Clean up scratch image memory
image->Release();

if (FAILED(hr)) {
    // Handle error
    return hr;
}
            

This example demonstrates using the DirectX Tex library to load a DDS file and create a shader resource view (SRV) for use in shaders.

Applying Textures in Your Shaders

Once a texture is loaded and an SRV is created, you need to instruct your shaders to sample from it. This involves declaring a texture resource and a sampler state in your pixel shader.

Pixel Shader Example (HLSL)

// Define texture and sampler in your shader
Texture2D txDiffuse : register(t0);
SamplerState samLinear : register(s0);

// In your PS_INPUT struct (per-vertex data passed to pixel shader)
struct PS_INPUT {
    float4 Pos : SV_POSITION;
    float2 Tex : TEXCOORD;
};

// Pixel shader main function
float4 PSMain(PS_INPUT input) : SV_Target {
    // Sample the texture at the given UV coordinates
    float4 texColor = txDiffuse.Sample(samLinear, input.Tex);
    return texColor;
}
            

The txDiffuse object represents our loaded texture, and samLinear is a sampler state that defines how the texture is filtered (e.g., linear, anisotropic). The input.Tex provides the UV coordinates for the current pixel.

Sampler States

Sampler states control how texels are fetched from a texture. Common filtering modes include:

• Point Filtering: Nearest texel is used.
• Linear Filtering: Bilinear interpolation between texels.
• Anisotropic Filtering: Higher quality filtering for surfaces viewed at oblique angles.

You'll typically create an ID3D11SamplerState object in your C++ code and bind it to the pipeline.

Texture Coordinates and Vertex Data

Ensuring correct texture coordinates are passed from your model data to the vertex shader and then to the pixel shader is crucial. This usually involves adding a TEXCOORD semantic to your vertex structure and the corresponding input layout.

Vertex Structure Example (C++)

struct Vertex {
    DirectX::XMFLOAT3 Pos;
    DirectX::XMFLOAT3 Normal;
    DirectX::XMFLOAT2 Tex; // Texture coordinates
};
            

Input Layout Description

When creating your input layout for the vertex shader, you must include an element for texture coordinates:

// Example D3D11_INPUT_ELEMENT_DESC
D3D11_INPUT_ELEMENT_DESC layout[] = {
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 } // Texture Coordinates
};
            

Advanced Texturing Techniques

Beyond basic diffuse texturing, DirectX supports many advanced techniques to enhance visual fidelity:

• Normal Mapping: Simulates surface bumps and details by perturbing surface normals, adding depth without increasing geometry complexity.
• Specular Mapping: Controls the shininess and reflectivity of different parts of a surface.
• Parallax Mapping: An advanced technique that simulates depth by displacing UV coordinates based on the viewing angle, offering more convincing results than normal mapping alone.
• Cube Maps: Used for environment mapping (reflections) and skyboxes.
• Texture Arrays: Allows you to bind multiple textures that can be indexed by shaders, useful for materials that share the same UV layout but have different texture maps.

Parallax Mapping Visualization