Introdução à Etapa Input-Assembler

Há algumas etapas necessárias para inicializar o estágio de montagem de entrada (IA). Por exemplo, você precisa criar recursos de buffer com os dados de vértice de que o pipeline precisa, informar o estágio de IA onde os buffers estão e que tipo de dados eles contêm e especificar o tipo de primitivos a serem montados a partir dos dados.

As etapas básicas envolvidas na configuração do estágio de IA, mostradas na tabela a seguir, são abordadas neste tópico.

Depois de entender essas etapas, vá para Usando System-Generated Valores.

Criar buffers de entrada

Existem dois tipos de buffers de entrada: buffers de vértice e buffers de índice. Os buffers de vértice fornecem dados de vértice para a fase IA. O buffer de índice é opcional; ele fornece índices para vértices a partir do buffer de vértice. Você pode criar um ou mais buffers de vértice e, opcionalmente, um buffer de índice.

Depois de criar os recursos de buffer, você precisa criar um objeto de layout de entrada para descrever o layout de dados para o estágio IA e, em seguida, você precisa vincular os recursos de buffer ao estágio IA. Criar e vincular buffers não é necessário se os sombreadores não usarem buffers. Para obter um exemplo de um sombreador de vértices e pixels simples que desenha um único triângulo, consulte Usando a Input-Assembler Etapa sem Buffers.

Para obter ajuda com a criação de um buffer de vértice, consulte Como criar um buffer de vértice. Para obter ajuda com a criação de um buffer de índice, consulte Como criar um buffer de índice.

Criar o objeto Input-Layout

O objeto input-layout encapsula o estado de entrada do estágio IA. Isso inclui uma descrição dos dados de entrada que estão vinculados ao estágio de IA. Os dados são transmitidos para o estágio IA a partir da memória, de um ou mais buffers de vértice. A descrição identifica os dados de entrada vinculados a partir de um ou mais buffers de vértice e dá ao tempo de execução a capacidade de verificar os tipos de dados de entrada em relação aos tipos de parâmetros de entrada do sombreador. Essa verificação de tipo não apenas verifica se os tipos são compatíveis, mas também se cada um dos elementos que o sombreador requer está disponível nos recursos de buffer.

Um objeto de layout de entrada é criado a partir de uma matriz de descrições de elementos de entrada e um ponteiro para o sombreador compilado (consulte ID3D11Device::CreateInputLayout). A matriz contém um ou mais elementos de entrada; Cada elemento de entrada descreve um único elemento de dados de vértice de um único buffer de vértice. O conjunto inteiro de descrições de elementos de entrada descreve todos os elementos de dados de vértice de todos os buffers de vértice que serão associados ao estágio IA.

A descrição de layout a seguir descreve um único buffer de vértice que contém três elementos de dados de vértice:

D3D11_INPUT_ELEMENT_DESC layout[] =
{
    { L"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, 
          D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { L"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, 
          D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { L"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, 
          D3D11_INPUT_PER_VERTEX_DATA, 0 },
};

Uma descrição do elemento de entrada descreve cada elemento contido por um único vértice em um buffer de vértice, incluindo tamanho, tipo, local e finalidade. Cada linha identifica o tipo de dados usando a semântica, o índice semântico e o formato de dados. Uma semântica é uma cadeia de caracteres de texto que identifica como os dados serão usados. Neste exemplo, a primeira linha identifica dados de posição de 3 componentes (xyz, por exemplo); a segunda linha identifica dados de textura de 2 componentes (UV, por exemplo); e a terceira linha identifica dados normais.

Neste exemplo de uma descrição de elemento de entrada, o índice semântico (que é o segundo parâmetro) é definido como zero para todas as três linhas. O índice semântico ajuda a distinguir entre duas linhas que usam a mesma semântica. Como não há semântica semelhante neste exemplo, o índice semântico pode ser definido como seu valor padrão, zero.

O terceiro parâmetro é o formato . O formato (consulte DXGI_FORMAT) especifica o número de componentes por elemento e o tipo de dados, que define o tamanho dos dados para cada elemento. O formato pode ser totalmente digitado no momento da criação do recurso, ou você pode criar um recurso usando um DXGI_FORMAT, que identifica o número de componentes em um elemento, mas deixa o tipo de dados indefinido.

Slots de entrada

Os dados entram no estágio de IA por meio de entradas chamadas slots de entrada , conforme mostrado na ilustração a seguir. O estágio IA tem n slots de entrada, que são projetados para acomodar até n buffers de vértice para fornecer dados de entrada. Cada buffer de vértice deve ser atribuído a um slot diferente; Essas informações são armazenadas na declaração Input-Layout quando o objeto Input-Layout é criado. Você também pode especificar um deslocamento desde o início de cada buffer até o primeiro elemento no buffer a ser lido.

Os dois parâmetros seguintes são o slot de entrada e o deslocamento de entrada . Ao usar vários buffers, você pode vinculá-los a um ou mais slots de entrada. O offset de entrada é o número de bytes entre o início do buffer e o início dos dados.

Reutilizando objetos Input-Layout

Cada objeto de layout de entrada é criado com base em uma assinatura de sombreador; isso permite que a API valide os elementos input-layout-object em relação à assinatura de entrada de sombreador para garantir que haja uma correspondência exata de tipos e semântica. Você pode criar um único objeto de layout de entrada para muitos sombreadores, desde que todas as assinaturas de entrada de sombreador correspondam exatamente.

Vincular objetos ao palco Input-Assembler

Depois de criar recursos de buffer de vértice e um objeto de layout de entrada, você pode vinculá-los ao estágio IA chamando ID3D11DeviceContext::IASetVertexBuffers e ID3D11DeviceContext::IASetInputLayout. O exemplo a seguir mostra a ligação de um único buffer de vértice e um objeto de layout de entrada ao estágio IA:

UINT stride = sizeof( SimpleVertex );
UINT offset = 0;
g_pd3dDevice->IASetVertexBuffers( 
    0,                // the first input slot for binding
    1,                // the number of buffers in the array
    &g_pVertexBuffer, // the array of vertex buffers
    &stride,          // array of stride values, one for each buffer
    &offset );        // array of offset values, one for each buffer

// Set the input layout
g_pd3dDevice->IASetInputLayout( g_pVertexLayout );

A vinculação do objeto input-layout requer apenas um ponteiro para o objeto.

No exemplo anterior, um único buffer de vértice é vinculado; no entanto, vários buffers de vértice podem ser vinculados por uma única chamada para ID3D11DeviceContext::IASetVertexBuffers, e o código a seguir mostra essa chamada para vincular três buffers de vértice:

UINT strides[3];
strides[0] = sizeof(SimpleVertex1);
strides[1] = sizeof(SimpleVertex2);
strides[2] = sizeof(SimpleVertex3);
UINT offsets[3] = { 0, 0, 0 };
g_pd3dDevice->IASetVertexBuffers( 
    0,                 //first input slot for binding
    3,                 //number of buffers in the array
    &g_pVertexBuffers, //array of three vertex buffers
    &strides,          //array of stride values, one for each buffer
    &offsets );        //array of offset values, one for each buffer

Um buffer de índice é associado ao estágio IA ao chamar ID3D11DeviceContext::IASetIndexBuffer.

Especificar o tipo primitivo

Depois de os buffers de entrada terem sido ligados, o estágio IA deve ser instruído sobre como montar os vértices em primitivas. Isto é feito especificando o tipo primitivo ao chamar ID3D11DeviceContext::IASetPrimitiveTopology; o código a seguir chama esta função para definir os dados como uma lista de triângulos sem adjacência:

g_pd3dDevice->IASetPrimitiveTopology( D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

O resto dos tipos primitivos estão listados em D3D_PRIMITIVE_TOPOLOGY.

Métodos Call Draw

Depois que os recursos de entrada foram vinculados ao pipeline, um aplicativo chama um método draw para renderizar primitivos. Existem vários métodos de desenho, que são mostrados na tabela a seguir; alguns usam buffers de índice, outros usam dados de instância e alguns reutilizam dados da fase de streaming-output como entrada para a fase de montagem de entrada.

Cada método de desenho renderiza um único tipo de topologia. Durante a renderização, primitivos incompletos (aqueles sem vértices suficientes, sem índices, primitivos parciais e assim por diante) são silenciosamente descartados.

Tópicos relacionados

Input-Assembler Estágio