Texturing in DirectX

Texturing is a fundamental technique in computer graphics used to add detail, color, and surface properties to 3D models. It involves applying 2D images (textures) to the surfaces of polygons. DirectX provides a robust set of tools and APIs for managing and utilizing textures effectively.

What are Textures?

A texture is essentially a bitmap image that is mapped onto the surface of a 3D object. This allows for the creation of complex and realistic appearances without the need to model intricate geometric details. Common uses of textures include:

Adding color and patterns (e.g., wood grain, brickwork).
Simulating surface properties like roughness, shininess, and bumpiness.
Creating intricate details like logos, text, or fine patterns.

Texture Mapping Process

The process of applying a texture to a 3D model involves several key steps:

UV Coordinates: Each vertex of a 3D model is assigned a set of UV coordinates. These coordinates represent a point on the 2D texture image, effectively telling the rendering engine which part of the texture should be mapped to that vertex. 'U' corresponds to the horizontal axis and 'V' to the vertical axis of the texture.
Texture Sampling: During the rendering process, for each pixel on the screen that covers a part of the 3D model, the GPU samples the texture using the interpolated UV coordinates. This involves retrieving the color or other data from the texture image at the calculated location.
Filtering: To ensure smooth transitions and prevent aliasing when textures are magnified or minified, various filtering techniques are applied. Common methods include point sampling, bilinear filtering, and anisotropic filtering.

Illustration of UV coordinates mapping a texture onto a 3D cube.

DirectX Texture Resources

In DirectX, textures are represented by objects derived from the ID3D11Resource interface, most commonly:

ID3D11Texture1D: For 1D textures.
ID3D11Texture2D: For 2D textures (most common for diffuse maps, normal maps, etc.).
ID3D11Texture3D: For 3D textures (used for volumetric data, like smoke or fog).

These resources are created with specific D3D11_TEXTURE2D_DESC structures that define their dimensions, format, mipmap levels, and other properties.

Mipmaps

Mipmaps are pre-calculated, downscaled versions of a texture. They are crucial for performance and visual quality, especially when objects are viewed at different distances. DirectX supports automatic mipmap generation and management.

Texture Samplers

Texture samplers are shader resources that define how a texture is sampled. They control parameters such as filtering modes (magnification, minification, mipmap filtering), addressing modes (how texels outside the [0,1] range are handled), and comparison functions.

                
// Example of creating a 2D texture resource
D3D11_TEXTURE2D_DESC texDesc;
ZeroMemory(&texDesc, sizeof(texDesc));
texDesc.Width = 256;
texDesc.Height = 256;
texDesc.MipLevels = 0; // Generate all mip levels
texDesc.ArraySize = 1;
texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
texDesc.CPUAccessFlags = 0;

ID3D11Texture2D* pTexture = nullptr;
HRESULT hr = pDevice->CreateTexture2D(&texDesc, nullptr, &pTexture);

// Create a Shader Resource View to access the texture in shaders
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory(&srvDesc, sizeof(srvDesc));
srvDesc.Format = texDesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = texDesc.MipLevels;

ID3D11ShaderResourceView* pShaderResourceView = nullptr;
hr = pDevice->CreateShaderResourceView(pTexture, &srvDesc, &pShaderResourceView);

pTexture->Release(); // Release the texture resource after creating the SRV
                
            

Common Texture Types

Diffuse Maps (Albedo Maps): Store the base color of the surface.
Normal Maps: Store surface direction information to simulate fine surface detail and lighting effects without adding geometry.
Specular Maps: Control the intensity and color of specular highlights.
Gloss Maps: Control the sharpness of specular highlights.
Height Maps (Displacement Maps): Store height information to actually displace the geometry.
Emissive Maps: Define areas of the surface that emit their own light.

Shader Integration

Textures are accessed within shaders using sampler and texture objects. Pixel shaders typically perform texture lookups to determine the final color of a pixel.

                
// Example HLSL pixel shader code
Texture2D txDiffuse : register(t0);
SamplerState ssLinear : register(s0);

float4 PSMain(float4 pos : SV_POSITION, float2 tex : TEXCOORD) : SV_TARGET
{
    // Sample the diffuse texture using the linear sampler
    float4 color = txDiffuse.Sample(ssLinear, tex);
    return color;
}
                
            

By mastering texturing techniques, developers can significantly enhance the visual fidelity and realism of their DirectX applications.