DirectX 11 Matrice Traduction intérieur Vertex Shader ou CPU

Question

RPC: https://github.com/walbourn/directx-sdk-samples/blob/master/Direct3D11TutorialsDXUT/Tutorial08/Tutorial08.cpp

HLSL: https://github.com/walbourn/directx-sdk-samples/blob/master/Direct3D11TutorialsDXUT/Tutorial08/Tutorial08.fx

A l'intérieur des échantillons DirectX (tutoriel 8), ils sont en cours d'initialisation des sommets avec coords locaux (je pense, pas que la terminologie correcte)

// Create vertex buffer 
    SimpleVertex vertices[] = 
    { 
     { XMFLOAT3(-1.0f, 1.0f, -1.0f), XMFLOAT2(1.0f, 0.0f) }, 
     { XMFLOAT3(1.0f, 1.0f, -1.0f), XMFLOAT2(0.0f, 0.0f) }, 
     { XMFLOAT3(1.0f, 1.0f, 1.0f), XMFLOAT2(0.0f, 1.0f) }, 
     { XMFLOAT3(-1.0f, 1.0f, 1.0f), XMFLOAT2(1.0f, 1.0f) }, 

     { XMFLOAT3(-1.0f, -1.0f, -1.0f), XMFLOAT2(0.0f, 0.0f) }, 
     { XMFLOAT3(1.0f, -1.0f, -1.0f), XMFLOAT2(1.0f, 0.0f) }, 
     { XMFLOAT3(1.0f, -1.0f, 1.0f), XMFLOAT2(1.0f, 1.0f) }, 
     { XMFLOAT3(-1.0f, -1.0f, 1.0f), XMFLOAT2(0.0f, 1.0f) }, 

     { XMFLOAT3(-1.0f, -1.0f, 1.0f), XMFLOAT2(0.0f, 1.0f) }, 
     { XMFLOAT3(-1.0f, -1.0f, -1.0f), XMFLOAT2(1.0f, 1.0f) }, 
     { XMFLOAT3(-1.0f, 1.0f, -1.0f), XMFLOAT2(1.0f, 0.0f) }, 
     { XMFLOAT3(-1.0f, 1.0f, 1.0f), XMFLOAT2(0.0f, 0.0f) }, 

     { XMFLOAT3(1.0f, -1.0f, 1.0f), XMFLOAT2(1.0f, 1.0f) }, 
     { XMFLOAT3(1.0f, -1.0f, -1.0f), XMFLOAT2(0.0f, 1.0f) }, 
     { XMFLOAT3(1.0f, 1.0f, -1.0f), XMFLOAT2(0.0f, 0.0f) }, 
     { XMFLOAT3(1.0f, 1.0f, 1.0f), XMFLOAT2(1.0f, 0.0f) }, 

     { XMFLOAT3(-1.0f, -1.0f, -1.0f), XMFLOAT2(0.0f, 1.0f) }, 
     { XMFLOAT3(1.0f, -1.0f, -1.0f), XMFLOAT2(1.0f, 1.0f) }, 
     { XMFLOAT3(1.0f, 1.0f, -1.0f), XMFLOAT2(1.0f, 0.0f) }, 
     { XMFLOAT3(-1.0f, 1.0f, -1.0f), XMFLOAT2(0.0f, 0.0f) }, 

     { XMFLOAT3(-1.0f, -1.0f, 1.0f), XMFLOAT2(1.0f, 1.0f) }, 
     { XMFLOAT3(1.0f, -1.0f, 1.0f), XMFLOAT2(0.0f, 1.0f) }, 
     { XMFLOAT3(1.0f, 1.0f, 1.0f), XMFLOAT2(0.0f, 0.0f) }, 
     { XMFLOAT3(-1.0f, 1.0f, 1.0f), XMFLOAT2(1.0f, 0.0f) }, 
    }; 

Mais ils traduisent la position par un Vertex Shader:

XMMATRIX mWorldViewProjection = g_World * g_View * g_Projection; 

Ma question est:

1: Si cela était un objet statique (sans bouger/animant), vous voulez toujours de traduire la position mondiale (Je ne sais pas le terminaology correct) ou voudriez-vous placer l'objet dans le bon espace 3D/scène lors de l'initialisation des sommets, par exemple:

{ XMFLOAT3(CorrectWorldX, CorrectWorldY, CorrectWorldZ), XMFLOAT2(1.0f, 0.0f) }, 

un parfait exemple de ce serait un niveau/terrain généré de façon aléatoire.

2: Quelle est la performance atteinte si vous utilisiez le shader pour positionner l'emplacement dans l'espace 3D correct plutôt que de simplement le faire lors de l'initialisation des sommets?

3: Pour l'animation c'est la méthode préférée pour la transformation osseuse des animations de caractères? 4: Lors de la construction d'un niveau (placer des objets), je suppose que vous n'avez pas d'autre choix que de traduire via le shader, mais vous pouvez également sauvegarder la position finale.

J'espère que c'est clair, car j'apprends DirectX 11 et corrige les pratiques!

Answer 1

1. Les objets statiques ne doivent être réellement placés dans les coordonnées réelles que s'ils ne sont pas réutilisés. Alors sa juste géométrie, mais la meilleure pratique est de passer une matrice de traduction pour positionner/orienter l'objet de l'espace local dans l'espace du monde. Par exemple, les arbres que vous utiliseriez plusieurs fois auraient chacun une matrice assignée pour la rotation, l'échelle et la traduction. Non seulement vous utiliserez cette technique, mais vous utiliserez un tampon "instance" pour alimenter rapidement les matrices au GPU et également éviter les décrochages dans le GPU à chaque fois que vous placez un modèle (l'utilisation de tampons constants introduira un léger décrochage). eux pour beaucoup de modèles devient un coup).

2. Les performances enregistrées dans le GPU sont beaucoup moins importantes que dans la CPU. Beaucoup moins, le calcul matriciel dans le GPU est son pain et beurre. De toute évidence, la matrice scale/rotate/translate doit être préparée à l'aide de votre code avant d'être chargée dans le GPU. Le GPU multipliera rapidement vos sommets de l'espace local vers l'espace du monde (dans le vertex shader ou le shader de domaine si vous êtes en mosaïque).

3. L'animation a quelques éléments en jeu, tels que la pondération et l'influence de chaque sommet sur les os. Si un sommet est influencé par plus d'un point d'os, il faut alors lier entre les deux. Mais oui, le GPU est le mieux placé pour le faire. Calculer le shader en streaming dans un tampon d'instance que le vertex shader utilise est le moyen le plus complet et le plus rapide de calculer ceci.

4. Si vous voulez calculer une fois, alors le CPU est correct mais il est préférable de simplement conserver l'instance matricielle pour chaque modèle et laisser le GPU faire le travail autour des calculs de vertex.Je ne voudrais pas essayer d'enregistrer ces données car l'utilisation de la mémoire va augmenter rapidement et vous n'économisez pas beaucoup sur les performances. En fait, cela pourrait être pire car vous devez charger ces données à chaque fois dans le GPU et vous n'aurez pas l'avantage de la mise en cache aussi.

bonne chance