Création de ressources de mémoire tampon (Direct3D 10)

  • Article

La création de mémoires tampons nécessite de définir les données que la mémoire tampon stockera, de fournir des données d’initialisation et de configurer les indicateurs d’utilisation et de liaison appropriés. Pour créer des textures, consultez Création de ressources de texture (Direct3D 10).

Créer une mémoire tampon de vertex

Les étapes de création d’une mémoire tampon de vertex sont les suivantes.

Créer une description de mémoire tampon

Lors de la création d’une mémoire tampon de vertex, une description de la mémoire tampon (voir D3D10_BUFFER_DESC) est utilisée pour définir la façon dont les données sont organisées dans la mémoire tampon, comment le pipeline peut accéder à la mémoire tampon et comment la mémoire tampon sera utilisée.

L’exemple suivant montre comment créer une description de mémoire tampon pour un triangle unique avec des sommets qui contiennent des valeurs de position et de couleur.

struct SimpleVertex
{
    D3DXVECTOR3 Position;  
    D3DXVECTOR3 Color;  
};

    D3D10_BUFFER_DESC bufferDesc;
    bufferDesc.Usage            = D3D10_USAGE_DEFAULT;
    bufferDesc.ByteWidth        = sizeof( SimpleVertex ) * 3;
    bufferDesc.BindFlags        = D3D10_BIND_VERTEX_BUFFER;
    bufferDesc.CPUAccessFlags   = 0;
    bufferDesc.MiscFlags        = 0;

Dans cet exemple, la description de la mémoire tampon est initialisée avec presque tous les paramètres par défaut pour l’utilisation, l’accès au processeur et les indicateurs divers. Les autres paramètres concernent l’indicateur de liaison qui identifie la ressource en tant que mémoire tampon de vertex uniquement et la taille de la mémoire tampon.

Les indicateurs d’utilisation et d’accès au processeur sont importants pour les performances. Ces deux indicateurs déterminent ensemble la fréquence d’accès à une ressource, le type de mémoire dans lequel la ressource peut être chargée et le processeur qui doit accéder à la ressource. Utilisation par défaut cette ressource ne sera pas mise à jour très souvent. La définition de l’accès au processeur sur 0 signifie que le processeur n’a pas besoin de lire ou d’écrire la ressource. Pris en combinaison, cela signifie que le runtime peut charger la ressource dans la mémoire la plus performante pour le GPU, car la ressource ne nécessite pas d’accès au processeur.

Comme prévu, il existe un compromis entre les meilleures performances et l’accessibilité à tout moment par l’un ou l’autre des processeurs. Par exemple, l’utilisation par défaut sans accès au processeur signifie que la ressource peut être mise à la disposition du GPU exclusivement. Cela peut inclure le chargement de la ressource dans la mémoire qui n’est pas directement accessible par le processeur. La ressource n’a pu être modifiée qu’avec UpdateSubresource.

Créer les données d’initialisation pour la mémoire tampon

Une mémoire tampon n’est qu’une collection d’éléments et est disposée sous la forme d’un tableau 1D. Par conséquent, le pitch de la mémoire système et le pas de tranche de mémoire système sont tous les deux identiques ; taille de la déclaration de données de vertex. Une application peut fournir des données d’initialisation lorsqu’une mémoire tampon est créée à l’aide d’une description de sous-ressource, qui contient un pointeur vers les données de ressource réelles et contient des informations sur la taille et la disposition de ces données.

Toute mémoire tampon créée avec une utilisation immuable (voir D3D10_USAGE_IMMUTABLE) doit être initialisée au moment de la création. Les tampons qui utilisent l’un des autres indicateurs d’utilisation peuvent être mis à jour après l’initialisation à l’aide de CopyResource, CopySubresourceRegion et UpdateSubresource, ou en accédant à sa mémoire sous-jacente à l’aide de la méthode Map .

Créer la mémoire tampon

À l’aide de la description de la mémoire tampon et des données d’initialisation (ce qui est facultatif), appelez CreateBuffer pour créer une mémoire tampon de vertex. L’extrait de code suivant montre comment créer une mémoire tampon de vertex à partir d’un tableau de données de vertex déclarées par l’application.

struct SimpleVertexCombined
{
    D3DXVECTOR3 Pos;  
    D3DXVECTOR3 Col;  
};


ID3D10InputLayout* g_pVertexLayout = NULL;
ID3D10Buffer*      g_pVertexBuffer[2] = { NULL, NULL };
ID3D10Buffer*      g_pIndexBuffer = NULL;


SimpleVertexCombined verticesCombo[] =
{
    D3DXVECTOR3( 0.0f, 0.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.0f, 0.5f ),
    D3DXVECTOR3( 0.5f, -0.5f, 0.5f ),
    D3DXVECTOR3( 0.5f, 0.0f, 0.0f ),
    D3DXVECTOR3( -0.5f, -0.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.5f, 0.0f ),
};


    D3D10_BUFFER_DESC bufferDesc;
    bufferDesc.Usage            = D3D10_USAGE_DEFAULT;
    bufferDesc.ByteWidth        = sizeof( SimpleVertexCombined ) * 3;
    bufferDesc.BindFlags        = D3D10_BIND_VERTEX_BUFFER;
    bufferDesc.CPUAccessFlags   = 0;
    bufferDesc.MiscFlags        = 0;
    
    D3D10_SUBRESOURCE_DATA InitData;
    InitData.pSysMem = verticesCombo;
    InitData.SysMemPitch = 0;
    InitData.SysMemSlicePitch = 0;
    hr = g_pd3dDevice->CreateBuffer( &bufferDesc, &InitData, &g_pVertexBuffer[0] );

Créer une mémoire tampon d’index

La création d’une mémoire tampon d’index est très similaire à la création d’une mémoire tampon de vertex ; avec deux différences. Une mémoire tampon d’index contient uniquement des données 16 bits ou 32 bits (au lieu de la large gamme de formats disponibles pour une mémoire tampon de vertex. Une mémoire tampon d’index nécessite également un indicateur de liaison index-tampon.

L’exemple suivant montre comment créer une mémoire tampon d’index à partir d’un tableau de données d’index.

ID3D10Buffer *g_pIndexBuffer = NULL;

    // Create indices
    unsigned int indices[] = { 0, 1, 2 };

    D3D10_BUFFER_DESC bufferDesc;
    bufferDesc.Usage           = D3D10_USAGE_DEFAULT;
    bufferDesc.ByteWidth       = sizeof( unsigned int ) * 3;
    bufferDesc.BindFlags       = D3D10_BIND_INDEX_BUFFER;
    bufferDesc.CPUAccessFlags  = 0;
    bufferDesc.MiscFlags       = 0;

    D3D10_SUBRESOURCE_DATA InitData;
    InitData.pSysMem = indices;
    InitData.SysMemPitch = 0;
    InitData.SysMemSlicePitch = 0;
    hr = g_pd3dDevice->CreateBuffer( &bufferDesc, &InitData, &g_pIndexBuffer );
    if( FAILED( hr ) )
        return hr;
  
    g_pd3dDevice->IASetIndexBuffer( g_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );

Créer une mémoire tampon constante

Direct3D 10 introduit une mémoire tampon constante. Une mémoire tampon constante, ou mémoire tampon constante de nuanceur, est une mémoire tampon qui contient des constantes de nuanceur. Voici un exemple de création d’une mémoire tampon constante, tirée de l’exemple HLSLWithoutFX10.

ID3D10Buffer*   g_pConstantBuffer10 = NULL;

struct VS_CONSTANT_BUFFER
{
    D3DXMATRIX mWorldViewProj;      //mWorldViewProj will probably be global to all shaders in a project.
                                    //It's a good idea not to move it around between shaders.
    D3DXVECTOR4 vSomeVectorThatMayBeNeededByASpecificShader;
    float fSomeFloatThatMayBeNeededByASpecificShader;
    float fTime;                    //fTime may also be global to all shaders in a project.
    float fSomeFloatThatMayBeNeededByASpecificShader2;
    float fSomeFloatThatMayBeNeededByASpecificShader3;
};

    D3D10_BUFFER_DESC cbDesc;
    cbDesc.ByteWidth = sizeof( VS_CONSTANT_BUFFER );
    cbDesc.Usage = D3D10_USAGE_DYNAMIC;
    cbDesc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
    cbDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
    cbDesc.MiscFlags = 0;
    hr = g_pd3dDevice->CreateBuffer( &cbDesc, NULL, &g_pConstantBuffer10 );
    if( FAILED( hr ) )
       return hr;

    g_pd3dDevice->VSSetConstantBuffers( 0, 1, g_pConstantBuffer10 );

Notez que lors de l’utilisation de l’interface ID3D10Effect, le processus de création, de liaison et de comitting d’une mémoire tampon constante est géré par l’interface ID3D10Effect instance. Dans ce cas, il est nécessaire d’obtenir la variable à partir de l’effet avec l’une des méthodes GetVariable telles que GetVariableByName et de mettre à jour la variable avec l’une des méthodes SetVariable telles que SetMatrix. Pour obtenir un exemple d’utilisation de l’interface ID3D10Effect pour gérer une mémoire tampon constante , consultez tutoriel 7 : Mappage de textures et tampons constants.

Ressources (Direct3D 10)