Prise en main de l’étape d’assembleur d’entrée

Il existe quelques étapes nécessaires pour initialiser l’étape d’assembleur d’entrée (IA). Par exemple, vous devez créer des ressources de mémoire tampon avec les données vertex dont le pipeline a besoin, indiquer à l’étape IA où sont les mémoires tampons et le type de données qu’ils contiennent et spécifier le type de primitives à assembler à partir des données.

Les étapes de base impliquées dans la configuration de la phase IA, présentées dans le tableau suivant, sont abordées dans cette rubrique.

Après avoir compris ces étapes, passez à l’utilisation des valeurs générées par le système.

Créer des mémoires tampons d’entrée

Il existe deux types de mémoires tampons d’entrée : les tampons vertex et les mémoires tampons d’index. Les tampons vertex fournissent des données vertex à l’étape IA. Les mémoires tampons d’index sont facultatives ; elles fournissent des index aux sommets à partir du tampon vertex. Vous pouvez créer un ou plusieurs tampons vertex et, éventuellement, une mémoire tampon d’index.

Après avoir créé les ressources de mémoire tampon, vous devez créer un objet de disposition d’entrée pour décrire la disposition des données à l’étape IA, puis lier les ressources de mémoire tampon à l’étape IA. La création et la liaison de mémoires tampons ne sont pas nécessaires si vos nuanceurs n’utilisent pas de mémoires tampons. Pour obtenir un exemple de nuanceur de vertex et de pixels simple qui dessine un triangle unique, consultez Utilisation de l’étape d’assembleur d’entrée sans mémoire tampon.

Pour obtenir de l’aide sur la création d’un tampon vertex, consultez Guide pratique pour créer un tampon vertex. Pour obtenir de l’aide sur la création d’une mémoire tampon d’index, consultez Guide pratique pour créer une mémoire tampon d’index.

Créer l’objet de disposition d’entrée

L’objet de disposition d’entrée encapsule l’état d’entrée de l’étape IA. Cela inclut une description des données d’entrée liées à l’étape IA. Les données sont diffusées en continu dans l’étape IA à partir de la mémoire, à partir d’un ou plusieurs tampons vertex. La description identifie les données d’entrée liées à partir d’un ou plusieurs tampons vertex et permet au runtime de comparer les types de données d’entrée aux types de paramètres d’entrée du nuanceur. Cette vérification de type vérifie non seulement que les types sont compatibles, mais également que chacun des éléments requis par le nuanceur est disponible dans les ressources de mémoire tampon.

Un objet de disposition d’entrée est créé à partir d’un tableau de descriptions d’éléments d’entrée et d’un pointeur vers le nuanceur compilé (voir ID3D11Device::CreateInputLayout). Le tableau contient un ou plusieurs éléments d’entrée ; chaque élément d’entrée décrit un élément de données vertex issu d’un tampon vertex unique. L’ensemble des descriptions input-element décrit tous les éléments vertex-data de tous les tampons vertex qui seront liés à l’étape IA.

La description de disposition suivante décrit un seul mémoire tampon vertex qui contient trois éléments de données vertex :

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 },
};

Une description d’élément d’entrée décrit chaque élément contenu par un seul vertex dans un tampon vertex, notamment la taille, le type, l’emplacement et l’objectif. Chaque ligne identifie le type de données à l’aide de la sémantique, de l’index sémantique et du format de données. Une sémantique est une chaîne de texte qui identifie la façon dont les données seront utilisées. Dans cet exemple, la première ligne identifie les données de position à 3 composants (xyz, par exemple), la deuxième ligne identifie les données de texture à 2 composants (UV, par exemple) et la troisième ligne identifie les données normales.

Dans cet exemple de description d’élément d’entrée, l’index sémantique (qui est le deuxième paramètre) est défini sur zéro pour les trois lignes. L’index sémantique permet de distinguer deux lignes qui utilisent la même sémantique. Étant donné qu’il n’existe aucune sémantique similaire dans cet exemple, l’index sémantique peut être défini sur sa valeur par défaut, zéro.

Le troisième paramètre est le format. Le format (voir DXGI_FORMAT) spécifie le nombre de composants par élément et le type de données, qui définit la taille des données pour chaque élément. Le format peut être entièrement tapé au moment de la création de ressources, ou vous pouvez créer une ressource à l’aide d’un DXGI_FORMAT, qui identifie le nombre de composants dans un élément, mais laisse le type de données non défini.

Emplacements d’entrée

Les données entrent à l’étape IA par le biais d’entrées appelées emplacements d’entrée, comme le montre l’illustration suivante. L’étape IA comporte n emplacements d’entrée, qui sont conçus pour prendre en charge jusqu’à n tampons vertex qui fournissent des données d’entrée. Chaque tampon vertex doit être affecté à un emplacement différent ; ces informations sont stockées dans la déclaration de disposition d’entrée lorsque l’objet de disposition d’entrée est créé. Vous pouvez également spécifier un décalage entre le début de chaque mémoire tampon et le premier élément de la mémoire tampon à lire.

Les deux paramètres suivants sont l’emplacement d’entrée et le décalage d’entrée. Lorsque vous utilisez plusieurs mémoires tampons, vous pouvez les lier à un ou plusieurs emplacements d’entrée. Le décalage d’entrée est le nombre d’octets entre le début de la mémoire tampon et le début des données.

Réutilisation d’objets de disposition d’entrée

Chaque objet de disposition d’entrée est créé en fonction d’une signature de nuanceur ; cela permet à l’API de valider les éléments d’objet de disposition d’entrée en les comparant à la signature d’entrée de nuanceur pour s’assurer qu’il existe une correspondance exacte entre les types et la sémantique. Vous pouvez créer un objet de disposition d’entrée unique pour de nombreux nuanceurs, tant que toutes les signatures d’entrée de nuanceur correspondent exactement.

Lier des objets à l’étape d’assembleur d’entrée

Après avoir créé des ressources de tampon vertex et un objet de disposition d’entrée, vous pouvez les lier à l’étape IA en appelant ID3D11DeviceContext::IASetVertexBuffers et ID3D11DeviceContext::IASetInputLayout. L’exemple suivant montre la liaison d’un tampon vertex unique et d’un objet de disposition d’entrée à l’étape 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 );

La liaison de l’objet de disposition d’entrée nécessite uniquement un pointeur vers l’objet.

Dans l’exemple précédent, un seul tampon vertex lié. Toutefois, plusieurs tampons vertex peuvent être liés par un seul appel à ID3D11DeviceContext::IASetVertexBuffers, et le code suivant montre un tel appel pour lier trois tampons vertex :

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

Une mémoire tampon d’index est liée à l’étape IA en appelant ID3D11DeviceContext::IASetIndexBuffer.

Spécifier le type primitif

Une fois que les mémoires tampons d’entrée ont été liées, l’étape IA doit être informé de la façon d’assembler les sommets en primitives. Pour ce faire, spécifiez le type primitif en appelant ID3D11DeviceContext::IASetPrimitiveTopology. Le code suivant appelle cette fonction pour définir les données en tant que liste de triangles sans contiguïté :

g_pd3dDevice->IASetPrimitiveTopology( D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

Les autres types primitifs sont répertoriés dans D3D_PRIMITIVE_TOPOLOGY.

Appeler des méthodes de dessin

Une fois que les ressources d’entrée ont été liées au pipeline, une application appelle une méthode de dessin pour afficher les primitives. Il existe plusieurs méthodes de dessin, qui sont présentées dans le tableau suivant ; certaines utilisent des mémoires tampons d’index, certaines utilisent des données d’instance et certaines réutilisent les données de l’étape de sortie de streaming comme entrée à l’étape d’assembleur d’entrée.

Chaque méthode de dessin affiche un type de topologie unique. Pendant le rendu, les primitives incomplètes (sans suffisamment de sommets, auxquelles manquent les index, les primitives partielles, etc.) sont abandonnées silencieusement.

Rubriques connexes

Étape de l’assembleur d’entrée