DirectX 11 Comment les Vertex et Pixel Shaders travail

Question

Je lis le livre, "Rendu pratique et calcul avec Direct3D 11" et en regardant le DirectX 11 Exemple:

CPP: https://github.com/walbourn/directx-sdk-samples/blob/master/Direct3D11Tutorials/Tutorial02/Tutorial02.cpp

HLSL: https://github.com/walbourn/directx-sdk-samples/blob/master/Direct3D11Tutorials/Tutorial02/Tutorial02.fx

Qu'est ce que c'est?

D3D11_INPUT_ELEMENT_DESC layout[] = 
{ 
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
}; 

Plus important encore, le Shader - Lorsque, dans le programme-t-il défini cette "Pos"?

float4 VS(float4 Pos : POSITION) : SV_POSITION 
{ 
    return Pos; 
} 

Je ne peux voir que vous liez les données de sommet via:

// Create vertex buffer 
SimpleVertex vertices[] = 
{ 
    XMFLOAT3(0.0f, 0.5f, 0.5f), 
    XMFLOAT3(0.5f, -0.5f, 0.5f), 
    XMFLOAT3(-0.5f, -0.5f, 0.5f), 
}; 
D3D11_BUFFER_DESC bd; 
ZeroMemory(&bd, sizeof(bd)); 
bd.Usage = D3D11_USAGE_DEFAULT; 
bd.ByteWidth = sizeof(SimpleVertex) * 3; 
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; 
bd.CPUAccessFlags = 0; 
D3D11_SUBRESOURCE_DATA InitData; 
ZeroMemory(&InitData, sizeof(InitData)); 
InitData.pSysMem = vertices; 
hr = g_pd3dDevice->CreateBuffer(&bd, &InitData, &g_pVertexBuffer); 
if(FAILED(hr)) 
    return hr; 

// Set vertex buffer 
UINT stride = sizeof(SimpleVertex); 
UINT offset = 0; 
g_pImmediateContext->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset); 

// Set primitive topology 
g_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); 

Et puis vous définissez les shaders et tirer les 3 vertices:

// Render a triangle 
g_pImmediateContext->VSSetShader(g_pVertexShader, nullptr, 0); 
g_pImmediateContext->PSSetShader(g_pPixelShader, nullptr, 0); 
g_pImmediateContext->Draw(3, 0); 

Cette tout a un sens. Mais je suis confus sur ce que cette entrée Pos est, comment il est généré, et pourquoi est-il utilisé? En outre, il existe d'autres exemples qui font la même chose ... (exemple 7) où ils ont utilisé la position et les textures, mais je ne peux pas voir d'où provient cette information. Par exemple ...

struct VS_INPUT 
{ 
    float4 Pos : POSITION; 
    float2 Tex : TEXCOORD0; 
}; 

Nous vous remercions de votre temps!

Answer 1

Le tableau de D3D11_INPUT_ELEMENT_DESC détermine la disposition des données qui seront lues à partir d'un tampon de vertex. Ce tableau est passé à un appel ID3D11Device::CreateInputLayout afin qu'il puisse être utilisé. Il est ensuite défini sur le contexte de rendu via un appel ID3D11DeviceContext::IASetInputLayout (non représenté, mais dans le code que vous avez lié).

Si vous regardez les membres de D3D11_INPUT_ELEMENT_DESC, le premier élément est SemanticName (mis à "POSITION"), qui est comment les éléments de la mémoire tampon de sommet sont adaptés aux entrées dans le shader. Il contient également des données sur le décalage des données et le format (dans ce cas, le décalage est nul, et le format DXGI_FORMAT_R32G32B32_FLOAT correspond à 3x flottants 32bit). Vous remarquerez que dans le shader, après Pos, il y a deux points, suivi de "POSITION" - c'est la sémantique, et correspond à la disposition d'entrée. Le shader sait alors qu'il doit lire les données de position à partir de zéro et le format de ces données.

Les données elles-mêmes sont lues à partir du vertex buffer, défini avec l'appel ID3D11DeviceContext::IASetVertexBuffers. Les paramètres stride indiquent à l'assembleur d'entrée la distance dans le vertex buffer d'un sommet à l'autre, de sorte qu'il sait où commencer à lire le suivant. Le g_pVertexBuffer transmis a été initialisé à partir des données vertices, qui, comme vous pouvez le voir, est un ensemble de 3 flottants 32 bits.

Pour les shaders avec des entrées supplémentaires (par exemple TEXCOORD0), il y aura plus d'entrées dans le tableau D3D11_INPUT_ELEMENT_DESC, correspondant à la sémantique utilisée dans les shaders.