Infographie. Pipeline graphique OpenGL, DirectX etc

Transcription

1 OpenGL, DirectX etc 1

2 Approche complémentaire du ray-tracing Beaucoup de versions Implémentation logicielle, ex. Pixar Renderman Implémentation matérielle, e.g. cartes graphiques PC But ici : rapidité sans perdre trop en réalisme (flexibilité) Faire le rendu d'un film de 2 heures en 1 an impose 3 minutes de calcul par image (mais c'est facilement parallélisable) Temps (presque) réel : plusieurs millions de triangles rendus par seconde On va se concentrer sur une «abstraction» d'une implémentation matérielle 2

3 On parle de But ici : opérations facilement parallélisables Groupes de processeurs dédiés permettant d'exécuter de plusieurs dizaines à plusieurs milliers d'opérations en parallèle. performance des GPU ( plusieurs fois celle des CPU à 1/5 de la fréquence d'horloge) Mémoire dédiée 3

4 Performance des échanges (les données ont qq années ) Document Nvidia 4

5 Organisation particulière d'un GPU Document Nvidia 5

6 Pipeline Application Flux de commandes Opérations sur les sommets (vertex processing) On est ici Standards «langage» OpenGL, DirectX etc... Transformations 3D, ombrage Géométrie transformée Rastérisation Fragments ( ~ pixels + données interpolées ) Opérations sur les fragments (fragment processing) Conversion des primitives en fragments Composition, mélange, (ombrage) Mémoire de trame (framebuffer) Affichage Ce que l'utilisateur voit 6

7 Primitives Points (dans l'espace) Segments de droite Triangles Chaînes de triangles C'est tout! Chaînes de segments connectés Courbes? Approchées par des chaînes de segments Polygones? Décomposés en triangles Surfaces courbes? Approchées par des triangles La «mode» actuelle est de se restreindre à un minimum de primitives Simple, uniforme, répétitif bon pour le parallélisme 7

8 Flux de commandes : dépend de l'implémentation Ex: OpenGL 1, DirectX, autres On retrouve toujours un peu les mêmes choses Cf Tps pour OpenGL Avantages d'opengl : Multiplateforme, simple, performant, évolutif et non attaché à une compagnie/architecture. 8

9 Pipeline Application On est ici Flux de commandes Opérations sur les sommets (vertex processing) Transformations 3D, ombrage Géométrie transformée Rastérisation Fragments ( ~ pixels + données interpolées ) Opérations sur les fragments (fragment processing) Conversion des primitives en fragments Composition, mélange, ombrage, Mémoire de trame (framebuffer) Affichage Ce que l'utilisateur voit 9

10 Pipeline des transformations géométriques 10

11 11

12 Clipping Les opérations de rastérisation supposent que les triangles (ou les lignes) sont visibles sur l'écran Ceci est effectué dans l'espace 3D canonique, après l'application de la matrice de projection perspective (cf cours 2 ), mais avant la division perspective. Tout ce qui n'est pas dans le volume w x w w y w w z w est «éliminé» Coupure contre 6 plans 12

13 Clipping Opération de base : couper un triangle en 3 par un plan 4 cas : Tous les points dedans on garde le triangle Tous à l'extérieur on rejette le triangle 1 sommets dedans; 2 dehors 1 triangle reste 2 sommets dedans; 1 dehors 2 triangles restent 13

14 Élimination des faces cachées On a discuté de comment transformer les primitives vers l'écran (géométriquement parlant) La projection perspective donne un indice de profondeur L'élimination des faces cachées donne un autre indice très important. Possibilité de ne dessiner que ce qui est visible (raison : performance accrue) 14

15 Élimination des faces cachées «backface culling» = occlusion des faces arrières Pour des formes fermées et opaques, on ne voit pas ce qui est dedans 15

16 Élimination des faces cachées «backface culling» = occlusion des faces arrières Inutile de tracer les faces «à l'arrière» v n n v 16

17 Élimination des faces cachées «backface culling» = occlusion des faces arrières Inutile de tracer les faces «à l'arrière» v n v n 0 n v 17

18 Élimination des faces cachées «backface culling» = occlusion des faces arrières Dépend de la convention sur la normale En principe, normale extérieure. Le calcul ne se fait correctement que si les triangles sont orientés convenablement s3 s1 s 2 s1 s 3 n= s1 s 2 s1 s 3 s1 s2 18

19 Faces cachées Comment traiter le cas suivant? Algorithme du peintre «simple» Arbre de partitionnement binaire Z-buffer 19

20 Algorithme du peintre Idée : tracer toutes les primitives dans le bon ordre On écrase ce qui se trouve en dessous 20

21 Algorithme du peintre Idée : tracer toutes les primitives dans le bon ordre On écrase ce qui se trouve en dessous 21

22 Algorithme du peintre Idée : tracer les primitives dans le bon ordre On écrase ce qui se trouve en dessous D B A F C A E B E C Revient à effectuer un tri topologique D F ABCDEF ABDCFE CAEBDF... Trouver un chemin dans un graphe orienté 22

23 Algorithme du peintre Impossible en présence de cycles... A A B B C C ABC??? 23

24 Algorithme du peintre Impossible en présence de cycles k a j b,l m c h k f d,g a l b c e o i,n d m g h e Solution : découpage i o n 24

25 Algorithme du peintre Utile lorsqu'un ordre est facile à déterminer Génération de dessins vectoriels Foley et al. 25

26 Algorithme du peintre L'ordre des opérations de dessin dépend du point de vue Le classement des primitives est coûteux (en nlog(n) au mieux ) et doit être refait dès que l'observateur bouge Les primitives doivent être découpées si elles forment des cycles (comment le détecter?) Réponse à ces problèmes : Arbre de partition spatiale binaire (BSP Tree) 26

27 BSP Tree Données d'entrée : Série de segments en 2D Série de triangles en 3D raisonnement identique b a c d e 27

28 Construction du BSP Tree (1) b.1 a + + c - b.2 c d e Prendre un des segments et définir un plan coupant le domaine en deux sous domaines signés Classer les autres segments d'un côté ou de l'autre du plan. Si un segment est à cheval, le partitionner et classer les parties. Dans chaque sous domaine, si il y a plus d'un segment, 28 refaire la même opération récursivement.

29 Construction du BSP Tree (2) b.1 a + b.2 c + c - d e.1 d e.2 e Prendre un des segments et définir un plan coupant le domaine en deux sous domaines Classer les autres segments d'un côté ou de l'autre du plan. Si un segment est à cheval, le partitionner et classer les parties. Dans chaque sous domaine, si il y a plus d'un segment, 29 refaire la même opération récursivement.

30 Construction du BSP Tree (3) - + b.1 a + b.2 c + c d e.1 b.1 a d e.2 e Prendre un des segments et définir un plan coupant le domaine en deux sous domaines Classer les autres segments d'un côté ou de l'autre du plan. Si un segment est à cheval, le partitionner et classer les parties. Dans chaque sous domaine, si il y a plus d'un segment, 30 refaire la même opération récursivement.

31 Construction du BSP Tree (4) - + b.1 a + b.2 c + c d + e.2 e.1 b.1 a d e.2 e b.2 Prendre un des segments et définir un plan coupant le domaine en deux sous domaines Classer les autres segments d'un côté ou de l'autre du plan. Si un segment est à cheval, le partitionner et classer les parties. Dans chaque sous domaine, si il y a plus d'un segment, 31 refaire la même opération récursivement.

32 Comment choisir le «bon» plan de découpage à chaque étape? Un choix aléatoire n'est pas mauvais... Algorithme complet Soit S un ensemble de segments (ou triangles en 3D) Build(S,BSP) { Si (Card(S) <=1) BSP est un arbre avec un seul noeud, contenant l'éventuel segment de S Sinon { Utiliser un segment aléatoire s de S comme ligne de coupure et découper les autres segments S+ = segments appartenant à H+ (demi espace «positif») (sans s) S- = segments appartenant à H- (demi espace «négatif») (sans s) Build(S+,BSP+) Build(S-,BSP-) Cree un arbre avec comme racine BSP, enfants BSP+ et BSP-, la racine contient s } } 32

33 Utilisation du BSP Tree Comment parcourir l'arbre afin d'obtenir l'ordre d'affichage correct? - + b.1 a + b.2 c + c d + e.2 e.1 b.1 a d b.2 e.2 e Observateur O Prenons O c+ Il est clair que les entités de c- doivent être affichées AVANT les entités sur c, qui doivent être affichées AVANT celles contenues dans c+ 33

34 Utilisation du BSP Tree Comment parcourir l'arbre afin d'obtenir l'ordre d'affichage correct? - + b.1 a + b.2 c + c d + e.2 e b a d e.2 e b.2 c- c c+ La question se repose pour c- (puis c+) O b.1- donc les entités de b.1+ doivent être affichées AVANT les entités sur b.1, qui doivent Observateur être affichées AVANT celles contenues dans 34 O b.1-

35 Utilisation du BSP Tree Comment parcourir l'arbre afin d'obtenir l'ordre d'affichage correct? b.1 a + b.2 c + c d + e.2 e b a d e.2 e b.2 a b.1 (b.1-) c c+ La question se repose pour c+ O d+ donc les entités de d- doivent être affichées AVANT les entités sur d, qui doivent Observateur être affichées AVANT celles contenues dans d+ 35 O

36 Utilisation du BSP Tree Comment parcourir l'arbre afin d'obtenir l'ordre d'affichage correct? b.1 a + b.2 c d 8 c b.1 e.2 e a d b.2 e.2 e a b.1 (b.1-) c d- d d+ Observateur O 36

37 Utilisation du BSP Tree Comment parcourir l'arbre afin d'obtenir l'ordre d'affichage correct? b.1 a + b.2 c + + d e.2 e d c 7 e.2 e.1 11 b b a 10 a b.1 (b.1-) c e.1 d d+ La question se repose pour d+ O e.2+ donc les entités de e.2- doivent être affichées AVANT les entités sur e.2, qui doivent Observateur être affichées AVANT celles contenues dans 37 O e.2+

38 Utilisation du BSP Tree Comment parcourir l'arbre afin d'obtenir l'ordre d'affichage correct? b.1 a + b.2 c + + d e.2 e.1 d c b.2 5 b.1 e.2 e a 10 a b.1 (b.1-) c e.1 d b.2 e.2 (e.2+) Observateur O Ordre final : a b.1 c e.1 d b.2 e.2 38

39 Algorithme de parcours récursif Draw(BSP,ViewPoint) { Si BSP est une feuille (pas d'enfants) Dessine les primitives contenues dans BSP Sinon { Soit BSP+ et BSP- les enfants de BSP Si ViewPoint est dans H- (demi espace «negatif») { Draw(BSP+,ViewPoint) Dessine les primitives contenues dans BSP Draw(BSP-,ViewPoint) } Sinon Si ViewPoint est dans H+ (demi espace «positif») { Draw(BSP-,ViewPoint) Dessine les primitives contenues dans BSP Draw(BSP+,ViewPoint) } Sinon (on est juste sur le plan de jonction) { (Dessine les primitives contenues dans BSP) /pas obligatoire Draw(BSP+,ViewPoint) Draw(BSP-,ViewPoint) } } } BSP BSP+ BSP- 39

40 L'arbre BSP n'est généralement pas utilisé directement dans les cartes graphiques. Construction relativement lente (au mieux en nlogn si l'arbre final est balancé), structure de données complexe Z-buffer : cf plus loin Il peut par contre être utilisé dans certains cas de façon logicielle pour «faciliter» le travail des cartes graphiques Ex. Jeux vidéos «FPS» ou les décors sont fixes, mis à part quelques parties animées «Doom» est un jeu vidéo qui fut précurseur dans cette utilisation Il peut aussi être utilisé en ray-tracing... 40

41 Pipeline Application On est ici Flux de commandes Opérations sur les sommets (vertex processing) Transformations 3D, ombrage Géométrie transformée Rastérisation Fragments ( ~ pixels + données interpolées ) Opérations sur les fragments (fragment processing) Conversion des primitives en fragments Composition, mélange, ombrage, Mémoire de trame (framebuffer) Affichage Ce que l'utilisateur voit 41

42 Rastérisation Première étape : énumérer les pixels couverts par la primitive «continue» Seconde étape : Interpoler des valeurs connues aux sommets de la primitive Exemple : la couleur connue aux sommets d'un triangle doit être «distribuée» sur chaque pixel du triangle. D'autres grandeurs peuvent être interpolées. Par exemple, les normales si elles sont connues aux sommets 42

43 Rastérisation Transformation des primitives «continues» en pixels Exemple : tracé d'une droite Point délicat : aliasing 43

44 Algorithme trivial Ligne = rectangle de largeur unité On spécifie les deux points Cas considéré : noir à l'intérieur du rectangle, blanc à l'extérieur 44

45 Algorithme naïf Ligne = rectangle de largeur unité On spécifie les deux points Cas considéré : noir à l'intérieur du rectangle, blanc à l'extérieur 45

46 Échantillonnage de points On approche le rectangle en traçant tous les pixels dont le centre est situé dans le rectangle 46

47 Échantillonnage de points On approche le rectangle en tracant tous les pixels dont le centre est situé dans le rectangle Problème : parfois, on allume des pixels deux fois adjacents 47

48 48

49 Algorithme de Bresenham (point milieu) On va définir l'épaisseur de la ligne parallèlement aux axes... 49

50 Algorithme de Bresenham (point milieu) On va définir l'épaisseur de la ligne parallèlement aux axes... On allume un seul pixel par colonne Les lignes à 45 seront en apparence plus fines. 50

51 Algorithme de Bresenham (point milieu) On va définir l'épaisseur de la ligne parallèlement aux axes... On allume un seul pixel par colonne Les lignes à 45 seront en apparence plus fines. 51

52 52

53 Algorithme de tracé de ligne Equation : y=mx b On évalue l'equation à chaque colonne On allume un seul pixel par colonne x 0 x 1 0 m 1 for x = ceil(x0) to floor(x1) y=b+m*x plot(x,round(y)) y=0.49x

54 Optimisation Multiplications et arrondis sont des opérations lentes y=mx b mx b y=0 Pour chaque pixel, les seules options sont E et NE On calcule l'erreur commise d =m x 1 b y d > 0.5 décide 7 NE entre E et NE x, y 3 E

55 Optimisation d =m x 1 b y On doit seulement mettre à jour avec des pas entiers en x et y Utilisation exclusive de l'addition (pas de multiplication ni division d > 0.5 décide 7 entre E et NE 6 On parle d' «analyseur digital différentiel» 5 d =d 1 d =d m

56 Optimisation x=ceil(x0) y=round(m*x+b) d=m*(x+1)+b-y While (x<floor(x1)) { If d>0.5 { y=y+1 d=d-1 } x=x+1 d=d+m plot(x,y) } // arrondi sup. // arrondi // arrondi inf

57 En général on dispose des points extrémité G x, y 0 dy y= x +b dx x0 y0 x1 y1 G x, y =0 G x, y 0 dx= x 1 x 0 dy= y 1 y 0 Forme implicite : G x, y =dy x dx y dx b F x, y =2 dy x 2 dx y 2 dx b 57

58 Calcul de la valeur de F au point M d i = F x i 1, y i 1/2 =2 dy x i 1 2 dx y i 1/2 2 dx b d i 0 : M est sous la droite choix NE d i 0 : M est au dessus choix E NE? M xi, yi Q E? 58

59 Premier point: que vaut d 0? d 0=F x 0 1, y 0 1/2 =2 dy x dx y 0 1/ 2 2 dx b =2 dy x 0 2 dx y 0 2 dx b 2 dy dx =F x 0, y 0 2 dy dx Comme x 0, y 0 fait partie de la droite, F x 0, y 0 =0 d 0=2 dy dx 59

60 Récurrence : que vaut d i 1? Si d i 0 alors on est allé à l' E : x i 1, y i 1 = x i 1, y i d i 1= F x 2, y 1/ 2 =d i 2 dy Sinon on est allé au NE : x i 1, y i 1 = x i 1, y i 1 d i 1= F x 2, y 3/2 =d i 2 dy 2 dx 60

61 Algorithme valable pour un octant Bresenham( x1, y1, x2, y2 ) { dx = x2 x1 dy = y2 y1 d = 2*dy dx plot( x1, y1 ) while (x1 < x2 ) { if (d <= 0) // EST d = d + 2*dy else // NORD-EST { d = d + 2*(dy-dx) y1 = y1 + 1 } x1 = x1 + 1 plot( x1, y1 ) } } 61

62 Que faire si l'on ne se trouve pas dans le bon octant? Intervertir x et y Intervertir les points de départ et d'arrivée Remplacer y par -y 62

63 Il existe le même genre d'algorithme pour tracer les cercles (cf littérature) Qu'en est il de l'aliasing? Existence d'algorithmes dérivés de celui de Bresenham permettant de traiter l'aliasing directement Cf. Algorithme de X. Wu Oversampling discrétisation sur une grille plus fine, puis moyenne dans les «gros» pixels. Bresenham, Jack E. "Algorithm for computer control of a digital plotter", IBM Systems Journal, Vol. 4, No.1, pp , 1965 Wu, Xiaolin. "An efficient antialiasing technique". Computer Graphics 25 (4): ,

64 64

65 Interpolation On attribue des valeurs aux sommets (couleur, normale, etc...) On souhaite disposer d'une valeur représentative le long de la ligne, pour chaque pixel «allumé» On aimerait une variation progressive d'une valeur à l'autre le long de la ligne 1D : f x = 1 f 0 f 1 = x x 0 / x1 x 0 2D,3D : est simplement la fraction de distance entre les points de départ et d'arrivée. 65

66 Interpolation Les pixels ne sont pas situés exactement sur la ligne On définit une fonction par projection sur la ligne C'est linéaire Donc on peut utiliser les résultats précédents pour interpoler P1 = v x / L P0 v = v y / L =v Q P 0 / L L=v P 1 P 0 66

67 Interpolation Les pixels ne sont pas situés exactement sur la ligne On définit une fonction par projection sur la ligne C'est linéaire Donc on peut utiliser les résultats précédents pour interpoler P1 = v x / L P0 v = v y / L =v Q P 0 / L L=v P 1 P 0 67

68 Interprétation alternative On met à jour d et de pixel en pixel d nous dit à quelle distance on se trouve de la ligne nous dit à quelle position on se trouve le long de la ligne d et sont des coordonnées par rapport à un repère lié avec la ligne 68

69 Interprétation alternative La boucle signifie la visite des pixels par lesquels passe la ligne Interpolation de d et pour chaque point Émission d'un fragment si le pixel est dans la bande P1 L'interpolation devient l'opération primaire P0 v u 69

70 Interprétation alternative x=ceil(x0) y=round(m*x+b) d=m*(x+1)+b-y etc... while (x<floor(x1)) { if (d>0.5) { y=y+1 d=d-1 etc... } else { x=x+1 d=d+m etc... } If (-0.5 < d <= 0.5) plot(x,y, ) } P1 P0 v u 70

71 Rastérisation des triangles Cas le plus commun dans la plupart des applications Avec un bon antialiasing, cela peut être le seul cas! Certains systèmes effectuent le rendu d'une ligne avec deux triangles très allongés Triangle représenté par 3 sommets L'algorithme se présente sous la même forme que l'algorithme de rasterisation d'une ligne On marche de pixel en pixel Calcul de fonctions linéaires au fur et à mesure Celles ci nous permettent de savoir si on est dedans... ou dehors 71

72 Rastérisation des triangles En entrée : Trois points 2D x 0, y 0 ; x1, y 1 ; x 2, y 2 Des valeurs à interpoler à chaque pixel q00,, q 0 n ; q 10,, q1 n ; q20,, q2 n En sortie : une liste de fragments, avec : Les coordonnées entières des pixels x, y Les valeurs interpolées q 0,, q n 72

73 Rastérisation des triangles Évaluation incrémentale de fonctions linéaires sur les pixels de la grille Fonctions définies par des valeurs spécifiées aux les sommets Utilisation de fonctions spécifiques pour déterminer l'ensemble des fragments à renvoyer sommet fragment x 0, y 0 q 00,, q 0 n x 2, y 2 q 20,, q 2 n (x, y) q 0,, q n x 1, y 1 q10,, q1 n 73

74 Evaluation linéaire incrémentale Une fonction linéaire (affine) sur le plan est : q x, y =c x x c y y c k Il est efficace de l'évaluer sur une grille : q x 1, y =c x x 1 c y y c k =q x, y c x q x, y 1 =c x x c y y 1 c k =q x, y c y +cy +cy... +cx+cx +cx... 74

75 Interpolation des valeurs aux sommets Déterminer c x, c y, c k qui définissent la fonction linéaire unique qui donne les valeurs correctes aux sommets 3 paramètres, trois équations : c x x 0 c y y 0 c k =q 0 x0 y0 1 cx q0 c x x 1 c y y 1 c k =q1 x1 y1 1 c y = q1 c x x 2 c y y 2 c k =q 2 x2 y2 1 ck q2 Matrice singulière si le triangle est dégénéré (trois points alignés) 75

76 Interpolation des valeurs aux sommets Translation de l'origine des axes vers x 0, y 0 q x, y =c x x x 0 c y y y 0 q 0 q x 1, y 1 =c x x 1 x 0 c y y 1 y 0 q 0 =q 1 q x 2, y 2 =c x x 2 x 0 c y y 2 y 0 q 0=q 2 Système linéaire 2x2 x 1 x 0 y 1 y 0 c x q 1 q 0 = x 2 x 0 y 2 y 0 c y q 2 q 0 Solution en utilisant la règle de Cramer c x= q 1 y 2 q 2 y 1 / x 1 y 2 x 2 y 1 c y = q 2 x 1 q1 x 2 / x 1 y 2 x 2 y 1 76

77 Quels sont les fragments à considérer? Ceux dont ceux dont les coordonnées barycentriques sont positives,, Algébriquement, on a p= a b c =1 À l'intérieur si 0 ; 0 ; 0 c a b Pineda, Juan, " A parallel algorithm for polygon rasterization" Computer Graphics 22 (4): 17-20,

78 Les coordonnées barycentriques sont des fonctions interpolées Chaque coordonnée vaut 1 sur un sommet, 0 sur les autres Elles sont une représentation implicite des équations des cotés du triangle... 78

79 Rasterisation pixel par pixel (Algorithme de Pineda ) On visite conservativement un super-ensemble des pixels à afficher Interpolation des fonctions linéaires Utilisation des fonctions coordonnées barycentriques pour savoir quand émettre un fragment x 2, y 2 q 20,, q 2 n x 0, y 0 q 00,, q 0 n x 1, y 1 q10,, q1 n 79

80 Rasterisation des triangles Attention aux arrondis et décisions arbitraires On doit visiter ces pixels au moins une fois... (sinon il y a un trou) Mais pas deux fois! (ils prendraient alors une couleur arbitraire en fonction de l'ordre du tracé) Solution élégante : antialiasing... 80

81 Pipeline Application On est ici Flux de commandes Opérations sur les sommets (vertex processing) Transformations 3D, ombrage Géométrie transformée Rastérisation Fragments ( ~ pixels + données interpolées ) Opérations sur les fragments (fragment processing) Conversion des primitives en fragments Composition, mélange, ombrage, Mémoire de trame (framebuffer) Affichage Ce que l'utilisateur voit 81

82 Le z-buffer (mémoire de profondeur) Dans beaucoup d'applications, maintenir un classement en profondeur est trop coûteux Le classement change avec le point de vue. Il existe l'algorithme de partition binaire de l'espace Indépendant du point de vue; mais : Structures de données associées relativement complexes (difficile à implémenter directement dans le matériel) Découpage des primitives Construction et initialisation lente On doit généralement connaître l'ensemble des primitives en avance 82

83 Solution utilisée habituellement: faire le tracé dans n'importe quel ordre, en gardant trace du plus proche Utiliser un canal de plus par pixel pour conserver la profondeur la plus faible tracée jusqu'à présent Quand on trace à nouveau un pixel, on compare la profondeur actuelle avec celle stockée. On ne trace effectivement que si cette dernière est supérieure. 83

84 Le z-buffer Exemple de technique de «force brute» utilisant beaucoup de mémoire mais qui est devenu un standard Foley et al. 84

85 Le z-buffer De façon évidente, limité aux images bitmap (non vectorielles) Un peu plus difficile à implémenter pour tenir compte d'un canal alpha...(transparence) 85

86 Z-buffer et transparence On sépare les objets opaques des autres. 1) Tracer les objets opaques avec mise à jour du zbuffer activée. 2) Ensuite, classer les entités partiellement transparentes dans un arbre BSP 3) Dessiner les entités transparentes dans l'ordre de profondeur décroissante (utiliser le BSP), en tenant compte du z-buffer mais sans mettre celui ci à jour (c'est inutile) On tient compte du z-buffer car les faces transparentes situées derrière les faces opaques ne sont pas visibles. 86

87 Le z-buffer : précision limitée Le canal supplémentaire est généralement codé sous forme d'un entier (comme un canal couleur) : * 0 z N 1 Cause : Implémentation hardware (simple et rapide) Il est possible d'avoir des objets distincts qui sont confondus (vus à la même distance) si la valeur (un entier = arrondi) dans le z-buffer est la même La précision est répartie entre n (le plan proche) et f (le plan lointain) Ceux ci on déjà servi à définir le volume observable, cf cours 2. 87

88 Le z-buffer Plan n * Plan f z *= N 1 z =0 88

89 Le z-buffer Soit une représentation entière à b bits (8 ou 16...) Quelle est la précision du z-buffer? Si le z stocké dans le z-buffer est proportionnel à la distance réelle (cas des projections orthogonales): On dispose de N=2b cases pour une distance de f-n La précision (indépendante de la distance) est donc de z= f n : pour maximiser la précision, il faut minimiser f-n 2b Si une projection perspective est utilisée, le z stocké dans le z-buffer est proportionnel au résultat obtenu après la division perspective. La dimension des cases est variable en fonction de la profondeur 89

90 Le z-buffer Plan n * z =0 Plan f z *= N 1 Cas orthographique Cas perspectif 90

91 Le z-buffer Dans le cours 2, on avait calculé zc après la transformation perspective et la division : 2 n r l 0 x, y, z,1 r l r l n 0 0 f n 2 f n t b = X,Y, z, z n f n f t b f n 1 t b n f f n 2 f n 2 f n z c= 0 0 n f f n z f n M proj _ persp _ OpenGL z c= f n 2fn f n z f n en comptant f, n et z positivement 91 et avec f >n

92 Le z-buffer L'intervalle pour zc est 2 (de -1 à 1) et on a toujours N cases. f n 2fn z c= f n z f n 2 z f n 2 z c 2 = z f n N On veut connaître la taille des cases dans l'espace réel, on inverse... z 2 f n z= N fn f f n La case la plus large est pour z=f : z max = Nn 92

93 Le z-buffer Exemple: n est à 1 mètre, f à 100 mètres, le z-buffer dispose de 8 bits N=256, quelle est la répartition des case? z 2 f n z = f f n = =39 m 0.15 m avec 16 bits z= max Nn N fn n f n 1 99 z min = = = m N f Avec n=10 : f f n z max = = =3.5 m m avec 16 bits Nn n f n z min = = =0.035 m 93 N f

94 Le z-buffer Pour un bon fonctionnement du z-buffer, il faut donc maximiser n et minimiser f. Ne surtout pas poser n=0 équivalent à désactiver le z-buffer. En général, le nombre de bits b est imposé par l'architecture matérielle (habituellement 16, 24 ou 32 bits) Le plus est le mieux mais cela prend autant de mémoire que l'image (habituellement codée sur 24 bits) 94

95 Interpolation en projection perspective Plan de projection œil Projection des extrémités 95

96 Interpolation en projection perspective Plan de projection p2 œil p 1 p 2 2 p1 Projection du milieu du segment milieu des projection des points extrémités Interpolation linéaire dans l'espace de l'écran de l'interpolation dans l'espace de l'œil. 96

97 Interpolation en projection perspective Plan de projection œil Se projette au milieu... z1 z 1 z 2 /2 z2 Projection du milieu du segment milieu des projection des points extrémités Interpolation linéaire dans l'espace de l'écran de l'interpolation dans l'espace de l'œil. 97

98 Interpolation en projection perspective Plan de projection œil répartition équitable sur z (distance) Projection du milieu du segment milieu des projection des points extrémités Interpolation linéaire dans l'espace de l'écran de l'interpolation dans l'espace de l'œil. 98

99 Interpolation en projection perspective Plan de projection œil Se projette au milieu... z c1 z c1 z c2 / 2 z c2 Projection du milieu du segment milieu des projection des points extrémités Interpolation linéaire dans l'espace de l'écran de l'interpolation dans l'espace de l'œil. 99

100 Interpolation en projection perspective Plan de projection œil répartition équitable sur z c (profondeur écran) La grandeur reliée à la profondeur que l'on doit interpoler (au niveau pixel) est zc (profondeur écran) obtenue après la division perspective, et non z, la coordonnée réelle 100

101 La correction de perspective (utilisation de zc au lieu de z ) permet d'éviter les problèmes avec les textures appliquées sur des surfaces inclinées F0 wikipedia F1 F u = 1 u F 0 u F 1 F0 1 u u z c0 F u= 1 1 u u z c0 F1 z c1 1 z c1 101

102 Pipeline minimal Etape «sommets» (input : positions 3D / sommet et couleur / triangle) Etape «Rasterisation» Transformation de la position (espace objet espace œil) Transformation de la position (espace œil espace écran) Passage de la couleur (pas d'interpolation = constante sur le triangle) Liste de pixels Passage de la couleur Etape «fragments» (output : couleur) Ecrire directement sur les plans couleur de la mémoire de trame 102

103 103

104 Pipeline minimal avec z-buffer Etape «sommets» (input : positions 3D / sommet et couleur / triangle) Transformation de la position (espace objet espace œil) Transformation de la position (espace œil espace ecran) Passage de la couleur (pas d'interpolation = constante sur le triangle) Etape «Rasterisation» Interpolation de zc (z dans l'espace écran) Passage de la couleur Etape «fragments» (output : couleur, zc) (Ecrire sur les plans couleur et mettre à jour le z-buffer) si z c < zc courant 104

105 105

106 Ombrage plat Utilisation de la «vraie» normale du triangle Apparence facettisée Vue la plus réaliste de la vraie géométrie Foley et al.106

107 Pipeline avec z-buffer et ombrage plat Etape «sommets» (input : positions 3D / sommet et couleur + normale / triangle) Transformation de la position (espace objet espace œil) Calcul de la couleur (ombrage plat) avec la normale (une couleur par triangle) Transformation de la position (espace œil espace écran) Etape «Rasterisation» Interpolation de zc (z dans l'espace écran) Passage de la couleur Etape «fragments» (output : couleur, zc) (Ecrire sur les plans couleur et mettre à jour le z-buffer) si z c < zc courant 107

108 Ombrage plat 108

109 Observateur et illumination locaux vs. lointains Illumination de Phong requiert de l'info géométrique Vecteur lumière (fonction de la position) Vecteur observateur (fonction de la position) Normale à la surface (obtenu par calcul) Les vecteurs observateur et lumière changent Ils doivent être calculés et normalisés pour chaque facette lumière observateur 109

110 Observateur et illumination locaux vs. lointains Cas ou ceux ci sont lointains Illumination parallèle Projection presque orthographique Dans les deux cas, les vecteur lumière et observateur changent très peu Une optimisation possible ( et fréquente ) est de les considérer comme lointains. 110

111 Lumière directionnelle Le vecteur lumière pointe toujours dans la même direction lumière [ x y z 0] observateur Dans beaucoup de cas, cela accélère le traitement (matériel) de l'illumination 111

112 Observateur à l'infini Projection orthographique? Projection selon un angle constant modifie la géométrie On peut faire cela aussi pour la projection perspective, uniquement pour le calcul de l'illumination Le vecteur observateur est considéré constant (par exemple c'est la normale au plan image) Produit des résultats bizarres si camera grand angle Ombrage de Blinn-Phong : vecteur observateur, vecteur source de lumière et vecteur bisecteur (cf cours 4) tous constants 112

113 Lumière directionnelle + observateur lointain lumière [ x y z 0] observateur [ x o y o z o 0] Seule la normale varie. Cela signifie que la teinte de chaque facette (à normale constante) est constante. 113

114 Interpolation de Gouraud On veut souvent une apparence lisse, sans pour autant augmenter la résolution de la discrétisation Se souvenir du mapping : sensibilité aux normales plus importante que la sensibilité aux positions Idée : couleur calculée aux sommets des facettes Interpolation pour avoir la couleur de chaque pixel lors de la rasterisation 114

115 Interpolation de Gouraud Foley et al.115

116 Pipeline avec z-buffer et interpolation de Gouraud Etape «sommets» (input : positions 3D / sommet et couleur + normale / sommet ) Etape «Rasterisation» Transformation de la position (espace objet espace œil) Calcul de la couleur par sommet (peu importe le modèle d'ombrage...) Transformation de la position (espace œil espace écran) Interpolation de zc (z dans l'espace écran), couleur r,g,b Etape «fragments» (output : couleur, zc) (Ecrire sur les plans couleur et mettre à jour le z-buffer) si z c < zc courant 116

117 Interpolation de gouraud 117

118 Interpolation de Gouraud Normales aux sommets Mathématiquement indéfinies Si la tessellation (triangulation) est obtenue à partir d'une surface mathématiquement lisse (sphère, NURBS, etc..), on peut prendre la normale à la vraie surface en ce point Si on n'y a pas accès, on doit trouver une approximation Schéma simple : moyenner les normales des triangles adjacents N1 Ni N5 Ns N4 N3 N s= N2 i Ni i 118

119 Interpolation de Gouraud On peut l'appliquer à n'importe quel modèle d'illumination Diffuse Blinn-Phong Etc... Toutefois, pour les modèles spéculaires cela ne fonctionne pas bien Variations trop brusques de la luminosité (si le point spéculaire est de taille très inférieure à un triangle) 119

120 Ombrage de Blinn et interpolation de Gouraud Foley et al.120

121 Interpolation de Phong Consiste en l'interpolation des normales Aussi facile que l'interpolation des couleurs Mais on calcule le modèle d'illumination à chaque pixel plutôt que à chaque sommet (après renormalisation des normales) Dans le pipeline graphique, cela signifie que l'on déplace le traitement de l'illumination depuis l'étape «traitement des sommets» vers l'étape «traitement des fragments» 121

122 Pipeline Application Flux de commandes Opérations sur les sommets (vertex processing) On est ici Standards «langage» OpenGL, etc... Transformations 3D, ombrage Géométrie transformée Rastérisation Fragments ( ~ pixels + données interpolées ) Opérations sur les fragments (fragment processing) Conversion des primitives en fragments Composition, mélange, ombrage, Mémoire de trame (framebuffer) Affichage Ce que l'utilisateur voit 122

123 Pipeline avec z-buffer et interpolation de Phong Etape «sommets» (input : positions 3D / sommet et couleur + normale / sommet ) Etape «Rasterisation» Transformation de la position (espace objet espace œil) Transformation de la position (espace œil espace écran) Passage de la couleur Interpolation de zc (z dans l'espace écran), couleur r,g,b, normale x,y,z Etape «fragments» (output : couleur, zc) Calcul de l'ombrage en utilisant la couleur et la normale interpolées (Ecrire sur les plans couleur et mettre à jour le z-buffer) si z c < zc courant 123

124 Interpolation de Phong 124

125 OpenGL Certains modèles d'ombrage et d'interpolation font partie du standard (typiquement : Phong, Lambert, Gouraud, Blinn-Phong ), il n'y a rien à faire. Pour les autres, il existe une API permettant de coder d'autres modèles soit au niveau du «vertex shader» (traitement au niveau des sommets), Soit au niveau du «fragment shader» (traitement après la rasterisation, pixel par pixel) Les cartes graphiques récentes permettent de réellement programmer (en langage pseudo C) le «vertex shader» ou le «fragment shader» (P.ex. Nvidia CUDA, OpenCL) 125

126 Programmable! Non / peu programmable 126

127 GPGPU GPGPU Utilisation des capacités de calcul des GPU pour effectuer autre chose que du rendu graphique... Les GPUs récents sont relativement polyvalents (mais moins que les CPUs) Branchements possibles Accès mémoire aléatoire Mais ils restent faits pour les opérations vectorielles Existence de standards de fait Open Computing Language (OpenCL, ouvert) Common Unified Device Architecture (CUDA, Nvidia) Direct Compute (Microsoft) 127

128 GPGPU OpenCL langage similaire au C Programme hôte en C++ (par exemple) Le code OpenCL est sous forme d'une chaîne de caractères (char[] ou string ) Le code OpenCL est compilé par le «driver» de la carte graphique, et chargé sur le GPU par l'appel de fonctions spécifiques Pour l'utilisation, le programme hôte lui passe des paramètres par tableaux en mémoire principale Le calcul est effectué sur le GPU Le résultat est rendu au programme hôte, également en mémoire principale 128

129 GPGPU Exemple de code OpenCL kernel void VectorAdd( global float* c, global float* a, global float* b, constant float *cst { // Index of the elements to add unsigned int n = get_global_id(0); unsigned int nl = get_local_id(0); unsigned int gsz = get_global_size(0); unsigned int lsz = get_local_size(0); unsigned int gid = get_group_id(0); // do some math from vectors a and b and store in c private float res; res=0.; int i; for (i=0;i<100;++i) // not a loop over elements of the arrays { res=a[n]+sin(a[n])+b[n]; if (res>5.5) res=a[n]* (*cst) ; } c[n] = res; 129 }

130 GPGPU Dans le programme hôte initialisation std::string Src ; // programme source (cf slide precedent) std::vector<cl::platform> platforms; cl::platform::get(&platforms); cl_context_properties properties[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(), 0}; cl::context context(cl_device_type_all, properties); std::vector<cl::device> devices = context.getinfo<cl_context_devices>(); cl::program::sources source(1,std::make_pair(src.c_str(),src.size())); cl::program program = cl::program(context, source); program.build(devices); // compilation! 130

131 GPGPU Dans le programme hôte appel cl::commandqueue queue(context,devices[0],0,&err); cl::buffer GPUOutVec(context, CL_MEM_WRITE_ONLY,sizeof(float)*SIZE, NULL, &err); float cst=1; cl::buffer GPUVec1(context,CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR,sizeof(float)*SIZE,HostVec1,&err); cl::buffer GPUVec2(context,CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR,sizeof(float)*SIZE,HostVec2,&err); cl::buffer GPUCst1(context,CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR,sizeof(float),&cst,&err); cl::event event1; cl::kernel kernel(program_, "VectorAdd", &err); kernel.setarg( 0, GPUOutVec);kernel.setArg( 1, GPUVec1); kernel.setarg( 2, GPUVec2);kernel.setArg( 3, GPUCst1); queue.enqueuendrangekernel(kernel,cl::nullrange, cl::ndrange(size_test),cl::nullrange,null,&event1); event1.wait(); // a ce point, le calcul a ete fait. 131

132 GPGPU Dans le programme hôte collecte // a ce point, le calcul a ete fait. cl::event event2; queue.enqueuereadbuffer(gpuoutvec,cl_true,0, SIZE_TEST*sizeof(float),HostOutVec, NULL, &event2); event2.wait(); // on dispose dans HostOutVec du resultat for (int Rows = { for (int c = std::cout std::cout << } 0; Rows < SIZE_TEST/32; Rows++) 0; c <32; c++) << HostOutVec[Rows * 32 + c] << " " ; std::endl; Exemple complet disponible sur le site du cours 132

133 GPGPU OpenCL est multiplateforme Le programme précédent peut être compilé sut tout ordinateur (disposant d'un driver GPGPU) Le code peut même être exécuté sur...cpu. (en l'absence de carte graphique récente) Il existe de «faux» drivers qui compilent et exécutent le code OpenCL sur le CPU. Performance : facteur 2 à 100 en faveur du GPU pour des opérations vectorielles (sur de gros tableaux) Core i7 6 cœurs 3,33 Ghz (très performant) vs. Nvidia Quadro FX 580 (carte assez peu performante) : 110 s. vs 55 s. Sur une carte spécialisée Nvidia Tesla C2075 : 11 s. 133