Direct3D11 (C++): Rendu (base) question

Question

J'ai suivi un livre sur les bases de la programmation de jeux avec D3D11. Je comprends maintenant les bases absolues de Direct3D :)

mais ... j'ai une question. Dans le livre, j'ai toujours dû faire une démo à la fois. Maintenant, j'essaye de faire un jeu en 2D avec ça. Comme je ne veux pas m'habituer aux mauvaises habitudes, j'ai besoin de vos conseils.

Dans le livre, j'ai toujours dû définir un (struct VertexPos avec texcoord et des membres de position) OR (struct VertexPos avec seulement un membre de position XMFLOAT3). Dans le jeu que je fais, je veux être capable de dessiner des surfaces solides sans textures et des surfaces avec des textures. Je ne suis pas sûr de savoir comment faire cela, et encore moins le faire efficacement.

Voici ma fonction de rendu:

void GameSpriteDemo::Render() 
{ 
    if (m_pD3DContext == 0) 
    {return;} 

    float ClearColor[4] = {0.0f, 0.0f, 0.25f, 1.0f}; 
    m_pD3DContext->ClearRenderTargetView(m_pBackBufferTarget,ClearColor); 

    UINT stride = sizeof(VertexPos); 
    UINT offset = 0; 

    m_pD3DContext->IASetInputLayout(m_pInputLayout); 
    m_pD3DContext->IASetVertexBuffers(0,1,&m_pVertexBuffer, &stride, &offset); 
    m_pD3DContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); 

    m_pD3DContext->VSSetShader(m_pSolidColorVS,0,0); 
    m_pD3DContext->PSSetShader(m_pSolidColorPS,0,0); 
    m_pD3DContext->PSSetShaderResources(0,1,&m_pColorMap); 
    m_pD3DContext->PSSetSamplers(0,1,&m_pColorMapSampler); 

    for(int i=0; i < 2; ++i) 
    { 
     XMMATRIX world = m_Sprites[i].GetWorldMatrix(); 
     XMMATRIX mvp = XMMatrixMultiply(world, m_VpMatrix); 
     mvp = XMMatrixTranspose(mvp); 

     m_pD3DContext->UpdateSubresource(m_pMvpCB,0,0,&mvp,0,0); 
     m_pD3DContext->VSSetConstantBuffers(0,1,&m_pMvpCB); 

     m_pD3DContext->Draw(6,0); 
    } 

    m_pSwapChain->Present(0,0); 
} 

Alors, comment dois-je gérer cela efficacement avec des tampons multiples vertex, mises en page d'entrée, Shaders, Blenders, etc?

Dois-je simplement créer plusieurs versions de celles-ci, puis réinitialiser l'ensemble d'entrée, les shaders et autres après l'appel Draw? Ou cela ne fonctionne-t-il pas/n'est-ce pas efficace?

Merci de

Answer 1

La réponse simple est oui, vous devez créer des tampons multiples vertex, mises en page d'entrée, etc., et shaders mis les appropriés avant chaque appel de tirage correspondant. Cela fonctionnera et est raisonnablement efficace (devrait être assez efficace pour un jeu 2D sur du matériel moderne).

Les choses ont tendance à devenir un peu plus compliquées dans un moteur de jeu 3D complet. Généralement, le moteur de rendu disposera de niveaux d'abstraction internes superposés à des objets primitifs tels que des sommets et des index, des entrées, des shaders, etc. à propos de tous les tampons de vertex, tampons d'index, dispositions d'entrée, shaders, textures, etc. qui constituent un peu un modèle 3D qui peut être dessiné dans un seul appel draw et est chargé de tous les définir (souvent avec d'autres bits de l'état de rendu comme les modes de fusion, les modes de sélection, etc.) et l'émission de l'appel de tirage correspondant.

Il y a un coût associé à la modification de l'état d'un périphérique. Les moteurs de rendu sont souvent conçus pour essayer de trier tous les objets nécessitant un dessin particulier afin de minimiser le nombre de changements d'état requis. Dans le moteur de rendu Dawn of War 2, par exemple, nous avons trié toute la géométrie du maillage de sorte que nous puissions dessiner par ex. tous les casques marins spatiaux avec des changements d'état minimaux requis avant de dessiner tous les corps marins spatiaux avec différents tampons de vertex et d'index, textures, etc.

Le matériel 3D moderne et les API ont moins de frais généraux pour changer d'état que par le passé donc trier pour minimiser les changements d'état est un peu moins important que par le passé, mais il est encore pratique courante pour les jeux qui ont besoin d'obtenir des performances maximales sur le PC. Dans un moteur de rendu piloté par les données qui prend en charge un modèle d'éclairage et de matériau flexible avec animation, terrain, systèmes de particules, effets plein écran, interface utilisateur 2D, etc., un design approprié pour gérer tout l'état requis pour dessiner Les objets de jeu et pour le tri afin qu'il puisse être dessiné avec une efficacité maximale peuvent devenir assez complexes et il existe de nombreuses approches différentes pour structurer les choses. Le code pour tout ce qui pourrait être classé comme «gestion d'état de rendu» constitue souvent une partie importante du code dans un moteur de rendu typique.