Texture Creation in DirectX Graphics

This document covers the fundamental aspects of creating textures within the DirectX Graphics API. Understanding texture creation is crucial for rendering visually rich and complex scenes in your applications.

Introduction to Textures

Textures are images used to add surface detail and color to 3D models. In DirectX, textures are represented by ID3D11Texture2D or similar interface objects. They can range from simple 2D images to complex 3D volumes, cube maps, and more.

Key Concepts for Texture Creation

Creating a 2D Texture

The primary method for creating a texture involves defining a D3D11_TEXTURE2D_DESC structure and then using the ID3D11Device::CreateTexture2D method.

D3D11_TEXTURE2D_DESC Structure

This structure holds all the necessary information for creating the texture: 


typedef struct D3D11_TEXTURE2D_DESC {
    UINT Width;
    UINT Height;
    UINT MipLevels;
    UINT ArraySize;
    DXGI_FORMAT Format;
    DXGI_SAMPLE_DESC SampleDesc;
    D3D11_USAGE Usage;
    UINT BindFlags;
    UINT CPUAccessFlags;
    UINT MiscFlags;
} D3D11_TEXTURE2D_DESC;

ID3D11Device::CreateTexture2D Method

This method creates the texture resource. 


HRESULT CreateTexture2D(
    const D3D11_TEXTURE2D_DESC *pDesc,
    const D3D11_SUBRESOURCE_DATA *pInitialData,
    ID3D11Texture2D **ppTexture2D
);

Example: Creating a Simple 2D Texture

This example demonstrates how to create a basic 512x512 RGBA texture with no mipmaps, intended for shader resource usage. 


// Assume 'pDevice' is a valid ID3D11Device pointer

D3D11_TEXTURE2D_DESC texDesc = {};
texDesc.Width = 512;
texDesc.Height = 512;
texDesc.MipLevels = 1; // No mipmaps for simplicity
texDesc.ArraySize = 1; // Single texture in the array
texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
texDesc.SampleDesc.Count = 1; // No multisampling
texDesc.SampleDesc.Quality = 0;
texDesc.Usage = D3D11_USAGE_DEFAULT; // GPU can read/write
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; // Bind as shader resource
texDesc.CPUAccessFlags = 0; // No CPU access
texDesc.MiscFlags = 0;

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

if (SUCCEEDED(hr)) {
    // Texture created successfully.
    // Now you can create an SRV (Shader Resource View) for this texture.
    // ...
} else {
    // Handle error
}

Providing Initial Data

If you have texture data available on the CPU (e.g., loaded from a file), you can provide it during creation. This is done using the D3D11_SUBRESOURCE_DATA structure.

D3D11_SUBRESOURCE_DATA Structure


typedef struct D3D11_SUBRESOURCE_DATA {
    const void *pSysMem;
    UINT SysMemPitch;
    UINT SysMemSlicePitch;
} D3D11_SUBRESOURCE_DATA;

Example: Creating a Texture with Initial Data

This example shows how to load data from a buffer and use it to initialize a texture. 


// Assume 'pDevice' is a valid ID3D11Device pointer
// Assume 'imageData' is a pointer to your raw pixel data
// Assume 'imageWidth', 'imageHeight' are dimensions

const UINT bytesPerPixel = 4; // For R8G8B8A8_UNORM
const UINT rowPitch = imageWidth * bytesPerPixel;

D3D11_TEXTURE2D_DESC texDesc = {};
texDesc.Width = imageWidth;
texDesc.Height = imageHeight;
texDesc.MipLevels = 1;
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;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;

D3D11_SUBRESOURCE_DATA initData = {};
initData.pSysMem = imageData;
initData.SysMemPitch = rowPitch;
initData.SysMemSlicePitch = 0; // Not needed for 2D texture

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

if (SUCCEEDED(hr)) {
    // Texture initialized from data successfully.
    // ...
} else {
    // Handle error
}

Mipmap Generation

For better visual quality and performance, it's often necessary to generate mipmaps. You can either:

  1. Generate them manually: Calculate and provide data for each mip level.
  2. Use GPU-based generation: Set MipLevels greater than 1 and use GenerateMips() on an ID3D11DeviceContext after the texture has been created and populated.

Further Considerations