DirectX Computational Graphics

Textures and Samplers in DirectX

Textures are fundamental to modern computer graphics, providing visual detail and realism to 3D models. In DirectX, textures are image resources that can be applied to surfaces. The process of reading from these textures within a shader is controlled by sampler states.

What are Textures?

A texture is essentially a 2D, 3D, or even array of 2D images that represent surface properties such as color, bumpiness, reflectivity, or normal direction. In DirectX, texture resources are typically managed using objects like ID3D11Texture2D. Key aspects of textures include:

• Dimensions: Width, height, and depth (for 3D textures).
• Format: The pixel data format (e.g., DXGI_FORMAT_R8G8B8A8_UNORM for 32-bit RGBA).
• Mipmaps: Pre-calculated, smaller versions of the texture used for rendering at different distances, improving performance and visual quality.
• Array Slices: For texture arrays, allowing multiple textures to be stored in a single resource.

What are Samplers?

A sampler object defines how a texture is accessed. It specifies crucial parameters like filtering, addressing modes, and LOD (Level of Detail) bias. Samplers are separate from the texture resource itself, allowing multiple samplers to be applied to the same texture with different access methods.

Key Sampler States:

• Filtering:
  • D3D11_FILTER_MIN_MAG_MIP_POINT: Nearest neighbor filtering (blocky).
  • D3D11_FILTER_MIN_MAG_MIP_LINEAR: Bilinear filtering for magnification, trilinear for minification and mipmapping (smoother).
  • D3D11_FILTER_ANISOTROPIC: Advanced filtering that considers the viewing angle, providing the best quality for surfaces at oblique angles.
• Addressing Modes: How texture coordinates outside the [0, 1] range are handled.
  • D3D11_TEXTURE_ADDRESS_WRAP: Repeats the texture.
  • D3D11_TEXTURE_ADDRESS_CLAMP: Clamps coordinates to the edge.
  • D3D11_TEXTURE_ADDRESS_BORDER: Uses a specified border color.
  • D3D11_TEXTURE_ADDRESS_MIRROR: Mirrors the texture.
• Level of Detail (LOD): Controls which mipmap level is used.
• Border Color: The color to use when D3D11_TEXTURE_ADDRESS_BORDER is active.

Shader Access

In HLSL shaders, textures are accessed using Texture objects (e.g., Texture2D, Texture3D) and samplers are accessed using SamplerState objects. These are bound to the graphics pipeline via shader resource views (SRVs) and sampler states.

Example HLSL Code:

// Texture resource
Texture2D myTexture;

// Sampler state
SamplerState mySampler;

// Vertex Shader Output (example)
struct VS_OUTPUT {
    float4 pos : SV_POSITION;
    float2 tex : TEXCOORD;
};

// Pixel Shader Input
struct PS_INPUT {
    float4 pos : SV_POSITION;
    float2 tex : TEXCOORD;
};

// Pixel Shader
float4 PSMain(PS_INPUT input) : SV_TARGET {
    // Sample the texture using the sampler
    float4 texColor = myTexture.Sample(mySampler, input.tex);
    return texColor;
}
            

Creating and Binding Resources

In your C++ DirectX application, you'll create texture resources (e.g., from image files using libraries like DirectXTex) and sampler state objects. These are then bound to the pipeline at specific shader stages.

Typical Binding Steps:

1. Create the texture resource (ID3D11Texture2D).
2. Create a Shader Resource View (SRV) for the texture (ID3D11ShaderResourceView).
3. Create a Sampler State Description (D3D11_SAMPLER_DESC) and use it to create a Sampler State object (ID3D11SamplerState).
4. In your rendering loop, bind the SRV to a pixel shader slot (e.g., psShaderResources[0]) and the sampler state to a corresponding sampler slot (e.g., psSamplers[0]).

Understanding and effectively utilizing textures and samplers is crucial for achieving visually rich and performant graphics in DirectX applications.