Partager via

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

  • Article

La création de mémoires tampons nécessite la définition des données que la mémoire tampon stockera, en fournissant des données d’initialisation et en configurant 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 comment 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 divers indicateurs. 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’accès à l’utilisation et 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. L’utilisation par défaut de cette ressource n’est pas très souvent mise à jour. La définition de l’accès au processeur sur 0 signifie que l’UC 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 les deux processeurs. Par exemple, l’utilisation par défaut sans accès au processeur signifie que la ressource peut être mise à la disposition exclusive du GPU. Cela peut inclure le chargement de la ressource en mémoire non directement accessible par l’UC. 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 est simplement une collection d’éléments et est disposée sous la forme d’un tableau 1D. Par conséquent, l’emplacement de la mémoire système et l’emplacement de la 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 ressources 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 mémoires tampons qui utilisent l’un des autres indicateurs d’utilisation peuvent être mises à 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 (facultatives), 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 de mémoire tampon d’index.

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 une mémoire tampon 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, extraite 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’instance id3D10Effect Interface. Dans ce cas, il est uniquement 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 le tutoriel 7 : Mappage de textures et mémoires tampons constantes.

Ressources (Direct3D 10)