photo par sskennel.
La séance de questions et réponses d’aujourd’hui nous est offerte par SuperUser, une sous-division de Stack Exchange, un groupe de sites Web de questions-réponses animé par la communauté.
La question
Le lecteur superutilisateur Sathya a posé la question:
Ici, vous pouvez voir une capture d'écran d'un petit programme C ++ appelé Triangle.exe avec un triangle tournant basé sur l'API OpenGL.
J'étais simplement curieux et je voulais tout savoir en cliquant deux fois sur Triangle.exe sous Windows XP jusqu'à ce que je puisse voir le triangle tourner sur le moniteur. Que se passe-t-il, comment le processeur (qui gère en premier le fichier.exe) et le processeur graphique (qui affiche finalement le triangle à l'écran) interagissent-ils?
Je suppose que l’affichage de ce triangle rotatif implique principalement le matériel / logiciel suivant, entre autres:
Matériel
- Disque dur
- Mémoire système (RAM)
- CPU
- Mémoire vidéo
- GPU
- affichage LCD
Logiciel
- Système opérateur
- API DirectX / OpenGL
- Pilote Nvidia
Quelqu'un peut-il expliquer le processus, avec peut-être une sorte d'organigramme à titre d'illustration?
Cela ne devrait pas être une explication complexe qui couvre chaque étape (supposez que cela irait au-delà de la portée), mais une explication qu'un informaticien intermédiaire peut suivre.
Je suis presque sûr que beaucoup de personnes qui s’appelleraient même des professionnels de l’informatique ne pourraient pas décrire ce processus correctement.
La réponse
Image de JasonC, disponible en tant que papier peint ici.
Il écrit:
J'ai décidé d'écrire un peu sur l'aspect de la programmation et sur la manière dont les composants se parlent. Peut-être que cela va nous éclairer sur certains domaines.
La présentation
Que faut-il pour avoir cette seule image, que vous avez postée dans votre question, dessinée à l'écran?
Il y a plusieurs façons de dessiner un triangle à l'écran. Par souci de simplicité, supposons qu’aucun tampon de vertex n’a été utilisé. (UNE vertex bufferest une zone de mémoire dans laquelle vous stockez les coordonnées.) Supposons que le programme indique simplement au pipeline de traitement graphique environ chaque sommet (un sommet est simplement une coordonnée dans l’espace) d’une ligne.
Mais, avant de pouvoir dessiner quoi que ce soit, nous devons d'abord exécuter un échafaudage. Nous verrons Pourquoi plus tard:
// Clear The Screen And The Depth Buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Reset The Current Modelview Matrix glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Drawing Using Triangles glBegin(GL_TRIANGLES); // Red glColor3f(1.0f,0.0f,0.0f); // Top Of Triangle (Front) glVertex3f( 0.0f, 1.0f, 0.0f); // Green glColor3f(0.0f,1.0f,0.0f); // Left Of Triangle (Front) glVertex3f(-1.0f,-1.0f, 1.0f); // Blue glColor3f(0.0f,0.0f,1.0f); // Right Of Triangle (Front) glVertex3f( 1.0f,-1.0f, 1.0f); // Done Drawing glEnd();
Alors qu'est-ce que ça a fait?
Lorsque vous écrivez un programme qui veut utiliser la carte graphique, vous choisissez généralement une sorte d’interface avec le pilote. Certaines interfaces bien connues du pilote sont:
- OpenGL
- Direct3D
- CUDA
Pour cet exemple, nous allons nous en tenir à OpenGL. Maintenant votre interface avec le conducteur est ce qui vous donne tous les outils dont vous avez besoin pour réaliser votre programme parler à la carte graphique (ou au pilote, qui ensuite pourparlers à la carte).
Cette interface est destinée à vous donner certaines outils. Ces outils prennent la forme d'une API que vous pouvez appeler depuis votre programme.
Cette API est ce que nous voyons être utilisé dans l'exemple ci-dessus. Regardons de plus près.
L'échafaudage
Avant de pouvoir réellement dessiner, vous devez effectuer une installer. Vous devez définir votre fenêtre d'affichage (la zone qui sera réellement rendue), votre perspective (la caméra dans votre monde), quel anti-aliasing vous utiliserez (pour aplanir les bords de votre triangle)…
Mais nous ne regarderons rien de tout cela. Nous allons simplement jeter un coup d'œil sur ce que vous devez faire chaque image. Comme:
Effacement de l'écran
Le pipeline graphique ne va pas effacer l'écran pour chaque image. Vous devrez le dire. Pourquoi? C'est pourquoi:
Si vous n’effacez pas l’écran, vous devrez simplement attirer c'est chaque image. C’est pourquoi nous appelons
glClear
avec le
GL_COLOR_BUFFER_BIT
ensemble. L'autre bit (
GL_DEPTH_BUFFER_BIT
) demande à OpenGL d'effacer le profondeurtampon. Ce tampon est utilisé pour déterminer quels pixels sont devant (ou derrière) d'autres pixels.
Transformation
La transformation est la partie où nous prenons toutes les coordonnées en entrée (les sommets de notre triangle) et appliquons notre matrice ModelView. C'est la matrice qui explique comment notre modèle (les sommets) sont pivotés, mis à l'échelle et traduits (déplacés).
Ensuite, nous appliquons notre matrice de projection. Cela déplace toutes les coordonnées afin qu'elles soient correctement orientées vers notre caméra.
Maintenant, nous transformons encore une fois, avec notre matrice Viewport. Nous faisons cela pour faire évoluer notre modèle à la taille de notre moniteur. Nous avons maintenant un ensemble de sommets prêts à être rendus!
Nous reviendrons à la transformation un peu plus tard.
Dessin
Pour dessiner un triangle, nous pouvons simplement dire à OpenGL de commencer une nouvelle liste de triangles en appelant
glBegin
avec le
GL_TRIANGLES
constant. Il y a aussi d'autres formes que vous pouvez dessiner. Comme une bande de triangle ou un ventilateur de triangle.Ce sont principalement des optimisations, car elles nécessitent moins de communication entre le processeur et le GPU pour dessiner le même nombre de triangles.
Après cela, nous pouvons fournir une liste d’ensembles de 3 sommets qui devraient constituer chaque triangle. Chaque triangle utilise 3 coordonnées (comme dans l’espace 3D). De plus, je fournis aussi un Couleur pour chaque sommet, en appelant
glColor3f
avant appel
glVertex3f
La nuance entre les 3 sommets (les 3 coins du triangle) est calculée par OpenGL automatiquement. Il interpolera la couleur sur toute la surface du polygone.
Interaction
Maintenant, lorsque vous cliquez sur la fenêtre. L'application doit uniquement capturer le message de la fenêtre signalant le clic. Ensuite, vous pouvez exécuter n’importe quelle action de votre programme.
Cela obtient un lot plus difficile une fois que vous souhaitez commencer à interagir avec votre scène 3D.
Vous devez d’abord savoir clairement à quel pixel l’utilisateur a cliqué dans la fenêtre. Ensuite, en prenant votre la perspectiveen compte, vous pouvez calculer la direction d'un rayon, du point du clic de souris dans votre scène. Vous pouvez ensuite calculer si un objet de votre scène intersecte avec ce rayon. Vous savez maintenant si l'utilisateur a cliqué sur un objet.
Alors, comment faites-vous la rotation?
Transformation
Je connais deux types de transformations généralement appliqués:
- Transformation basée sur la matrice
- Transformation à base d'os
La différence est que des os affecter seul sommets. Les matrices affectent toujours tous les sommets dessinés de la même manière. Regardons un exemple.
Exemple
Plus tôt, nous avons chargé notre matrice d'identité avant de dessiner notre triangle. La matrice d’identité est celle qui fournit simplement pas de transformation du tout. Ainsi, tout ce que je dessine n’est affecté que par mon point de vue. Ainsi, le triangle ne sera pas tourné du tout.
Si je veux le faire pivoter maintenant, je peux soit faire le calcul moi-même (sur le processeur) et simplement appeler
glVertex3f
avecautre coordonnées (qui sont tournés). Ou je pourrais laisser le GPU faire tout le travail, en appelant
glRotatef
avant de dessiner:
// Rotate The Triangle On The Y axis glRotatef(amount,0.0f,1.0f,0.0f);
amount
est, bien sûr, juste une valeur fixe. Si tu veux animer, vous devrez garder une trace de
amount
et l'augmenter chaque image.
Alors, attendez, qu'est-il arrivé à toutes les discussions sur la matrice plus tôt?
Dans cet exemple simple, nous n’avons pas à nous soucier des matrices. Nous appelons simplement
glRotatef
et ça prend soin de tout ça pour nous.
glRotate
produit une rotation de
angle
degrés autour du vecteur x y z. La matrice actuelle (seeglMatrixMode) est multipliée par une matrice de rotation, le produit remplaçant la matrice actuelle. IfglMultMatrix était appelé avec la matrice suivante comme argument:
x 2 1 - c + cx y 1 - c - z sx z 1 - c + y s 0 y x 1 - c + z sy 2 1 - c + cy z 1 - c - x s 0 x z 1 - c - y sy z 1 - c + x sz 2 1 - c + c 0 0 0 0 1
Eh bien, merci pour ça!
Conclusion
Ce qui devient évident, c’est qu’on parle beaucoup à OpenGL. Mais ça ne dit rien nous n'importe quoi. Où est la communication?
La seule chose que OpenGL nous dit dans cet exemple est quand c'est fait. Chaque opération prendra un certain temps. Certaines opérations prennent incroyablement longtemps, d’autres sont incroyablement rapides.
Envoi d'un sommet au GPU sera si rapide, je ne saurais même pas comment l'exprimer. L'envoi de milliers de sommets de la CPU au GPU, chaque image, ne pose aucun problème.
Effacement de l'écran peut prendre une milliseconde ou moins (gardez à l’esprit que vous n’avez généralement que 16 millisecondes pour dessiner chaque image), en fonction de la taille de votre fenêtre. Pour le supprimer, OpenGL doit dessiner chaque pixel de la couleur souhaitée, ce qui peut représenter des millions de pixels.
En dehors de cela, nous ne pouvons quasiment que demander à OpenGL les capacités de notre adaptateur graphique (résolution maximale, anti-aliasing maximum, profondeur de couleur maximale,…).
Mais nous pouvons également remplir une texture avec des pixels ayant chacun une couleur spécifique. Chaque pixel contient donc une valeur et la texture est un «fichier» géant rempli de données. Nous pouvons charger cela dans la carte graphique (en créant un tampon de texture), puis charger un shader, dire à ce shader d'utiliser notre texture en tant qu'entrée et exécuter des calculs extrêmement lourds sur notre «fichier».
Nous pouvons alors "rendre" le résultat de notre calcul (sous la forme de nouvelles couleurs) dans une nouvelle texture.
C’est ainsi que vous pouvez faire en sorte que le processeur graphique fonctionne pour vous d’une autre manière. Je suppose que CUDA fonctionne de manière similaire à cet aspect, mais je n’ai jamais eu l’occasion de travailler avec elle.
Nous n’avons vraiment que légèrement touché le sujet. La programmation graphique 3D est un enfer d'une bête.
Avez-vous quelque chose à ajouter à l'explication? Sound off dans les commentaires. Voulez-vous lire plus de réponses d'autres utilisateurs de Stack Exchange doués en technologie? Découvrez le fil de discussion complet ici.
