Quelques définitions

Illumination globale

Les techniques d’illuminations globales (GI) visent à améliorer le rendu d’une scène 3D, en prenant en compte aussi bien la lumière directe (les sources de lumières qui éclairent les objets) que la lumière indirecte (réflexion de la lumière sur les objets, qui éclaire d’autres objets). Ces techniques permettent d’obtenir des rendus réalistes, au prix d’un temps de calcul relativement long (parfois trop pour être compatible avec du rendu en temps réel). Un domaine de la recherche actuelle vise à développer de nouveaux algorithmes d’illumination globale compatible avec le temps réel (jeux 3D).

(source : Wikipédia – Illumination globale)

Illumination indirecte

Dans l’illumination directe (à gauche sur l’illustration suivante), la lumière provenant d’une source est directement réfléchie sur une surface, puis renvoyé vers la caméra. C’est le modèle classique de calcul de la lumière en 3D, que l’on retrouve par exemple dans le modèle de Phong. La lumière est alors décomposée en plusieurs composantes : la lumière ambiante (qui représente une illumination globale constante), la lumière diffuse (qui représente une diffusion de la lumière sur la surface) et la lumière spéculaire (qui représente une réflexion sur la surface).

(Source : Real-Time Global Illumination for Point Cloud Scenes)

Dans l’illumination indirecte, on considère que chaque surface qui reçoit de la lumière va à son tour en renvoyer. Il n’y a donc plus qu’une seule source de lumière, mais une infinité, correspondant à chaque surface qui renvoie de la lumière. Pour réaliser le rendu d’une scène, il faut donc procéder de la façon suivante :

1. pour chaque surface S1 visible par la caméra ;
2. pour chaque surface S2 visible depuis la surface S1 ;
3. calculer la lumière reçue par la surface S2 provenant de la source ;
4. calculer la lumière renvoyée par la surface S2 vers la surface S1 ;
5. calculer la lumière reçue par la surface S1 provenant de la surface S2 ;
6. calculer la lumière totale renvoyée par la surface S1 vers la caméra.

Chaque étape doit prendre en compte plusieurs paramètres. Pour (3), il faut par exemple prendre en compte la distance entre la source et la surface S2 et l’atténuation de la lumière en fonction de la distance. Pour (4), il faut prendre en compte les caractéristiques de la surface et sa capacité à réfléchir la lumière. Pour (5), il faut prendre en compte la distance entre les surfaces S1 et S2 et l’angle d’incidence. Pour (6), les capacités de réflexion de la surface S1 et la distance entre la surface S1 et la caméra.

Cette première approche simple peut largement être améliorée (et complexifiée), en prenant en compte par exemple que la lumière peut se réfléchir plusieurs fois sur des surfaces avant d’atteindre la caméra (particulièrement important lorsque les surfaces sont très réfléchissantes, comme du verre ou du métal poli), de la diffusion de la lumière dans le brouillard ou la poussière (lumière volumétrique, éclat lumineux), la présence de plusieurs sources lumineuses (voir des milliers de sources lumineuses dans le cas de particules incandescentes).

Lancé de rayons

Il existe plusieurs techniques de « lancés ». Elles reposent sur l’idée que la lumière est constituée de rayons qui vont partir de des sources lumineuses, se réfléchir, diffuser et réfracter sur les différentes surfaces (chaque surface pouvant renvoyer plusieurs rayons), puis atteindre la caméra. Dans les techniques de photon mapping, on part des sources lumineuses, on émet des rayons et on les suit jusqu’à la caméra (cette technique est décrite dans un autre article du blog de Simon et fera l’objet d’une traduction). Dans les techniques de lancé de rayons, on part de la caméra, on lance un rayon pour chaque pixel de l’image finale et l’on remonte jusqu’aux sources de lumière (illustration suivante).

(Source : Wikipédia – Raytracing)

Dans la technique du lancé de cônes (Cone Tracing), présentée dans l’article traduit, on remplace simplement les rayons par des cônes pour le calcul de l’illumination.

Occlusion ambiante

Cette technique fera également l’objet de plusieurs traductions du blog de Simon, je la détaillerai à ce moment là.

Simplement pour comprendre l’idée générale : lorsque deux surfaces sont proches (dans une fissure, un trou), la lumière indirecte diminue fortement et l’on observe des ombres douces. Plus les surfaces sont proches et fermées, plus l’ombrage sera important. L’illustration suivante représente la même scène sans (en haut) et avec l’occlusion ambiante (en bas). Remarquez en particulier l’ombre dans l’angle du mur et du sol et entre la sphère dans l’image du bas.

Cette technique améliore fortement la qualité du rendu et commence à être très utilisée dans les jeux. Un de ses points forts est que pour un objet statique (ou peu dynamique), l’occlusion ambiante ne varie pas (ou peu) et il est possible de la pré-calculer, le résultat étant mis dans une texture. Il suffit ensuite d’appliquer la texture sur l’objet lors du rendu, comme n’importe quelle autre texture.

Il existe plusieurs algorithmes de calcul de l’occlusion ambiante, mais pour comprendre le principe, voyons un exemple simple représenté dans l’illustration suivante. Pour chaque point d’une surface, on va lancer un nombre fixé de rayons qui vont parcourir une distance fixée aussi dans toutes les directions. On compte ensuite le nombre de rayons qui ne rencontrent pas une autre surface et on calcul le rapport entre le nombre de rayons ayant rencontrés une surface et le nombre de rayons lancés. Ainsi, dans l’illustration suivante, pour le point A, sur les six rayons lancés, aucun ne rencontre de surfaces, le rapport est de 0/6 = 0 %. Pour le point B, seul quatre rayons ne rencontrent pas de surfaces sur les six lancés, le rapport est de 4/6 = 66 %. Pour le point C, deux rayons ne rencontrent pas de surfaces, le rapport est de 2/6 = 33 %.

Il suffit ensuite d’atténuer la lumière pour chaque point en fonction du rapport calculé. Plus le rapport est proche de 0 %, plus la surface sera sombre et plus le rapport est proche de 100 %, plus la surface est claire.

Pour obtenir un bon rendu, on pourra augmenter le nombre de point et le nombre de rayons lancés, mais l’impact sur les performances sera important.

Partitionnement de l’espace

Voxel

Le principe des voxels est relativement simple : ils sont l’équivalent en 3D des pixels pour la 2D. Un exemple bien connu d’utilisation des voxels est le jeu Minecraft, dans lequel chaque élément (terrain, objets) sont représentés par des cubes.

(Source : Wikiépdia – Minecraft)

Les voxels sont particulièrement gourmand en termes de performances et sont encore peu utilisés pour les jeux vidéos. Ils sont particulièrement adaptés pour le rendu de volumes transparents (verre, liquide, fumée, nuage) ou de géométries très complexes (pour le rendu d’un mesh complexe, une approche utilisant une version low poly du mesh et une texture des Displacement/Normal/Bump mapping).

Octree

Un octree est une structure permettant de partitionner l’espace dans un arbre, permettant par exemple de faciliter la recherche d’un élément par rapport à sa position 3D. La construction d’un tel arbre est simple : à chaque itération, le cube représentant une partie de l’espace est divisé en 8 cubes.

(Source : GPU Gems 2 – Octree Textures on the GPU)

L’intérêt des octrees avec les voxels est que l’on va pouvoir utiliser une structure « creuse » : les zones qui sont vides ne seront pas divisées en cubes plus petits, simplifiant ainsi les algorithmes de recherche et la mémoire.

Quelques rappels
Les geometry shaders sont optionnels et s’intercalent entre les vertex shaders et les fragment shaders. Ils travaillent sur des primitives (triangle, ligne, points, avec un maximum de 6 vertices) et permettent de générer d’autres primitives. Ils sont disponibles dans le Core depuis OpenGL 3.2 / GLSL 1.5 ou avant avec l’extension GL_ARB_geometry_shader4 (en ajoutant le code #extension GL_EXT_geometry_shader4 : enable dans le geometry shader).

Lors de l’appel à glDrawArray ou glDrawElement, il faut que le type spécifié corresponde au type d’entrée du geometry shader. Les correspondances autorisées sont :

1. points : GL_POINTS
2. lines : GL_LINES, GL_LINE_LOOP ou GL_LINE_STRIP
3. triangles : GL_TRIANGLES, GL_TRIANGLE_FAN ou GL_TRIANGLE_STRIP
4. lines_adjacency : GL_LINES_ADJACENCY
5. triangles_adjacency : GL_TRIANGLES_ADJACENCY

Les nouveaux types ADJACENCY (GL_LINES_ADJACENCY, GL_LINE_STRIP_ADJACENCY, GL_TRIANGLES_ADJACENCY et GL_TRIANGLE_STRIP_ADJACENCY) permettent d’accéder aux vertices des primitives voisines de la primitive en cours de traitement.

Un exemple simple
L’exemple choisit est tres tres classique. Il permet d’afficher le mailage d’un mesh, les vecteurs normaux des faces et de calculer les vecteurs normaux de chaque face (flat mode). Cet exemple me permet également d’introduire quelques classes simples, pour lire un fichier .obj (version simplifiee), calculer les vecteurs normaux, initialiser un contexte GL avec Qt.

Pour l’affichage des vecteurs normaux et des triangles, on a besoin des positions et des normales, que l’on passent donc aux shaders en attributs.

Pour afficher les vecteurs normaux dans le geometry shader, on prend un seul vertex en entree (input = points) et l’on retourne une ligne (output = lignes, size = 2), dont le premier point est la position du vertex et le second point est la position du vertex auquel on ajoute le vecteur normal (multiplie par une constante, passee comme uniform, pour modifier la longueur du vecteur)

Pour afficher les triangles, on recupere un triangle en entree (input = triangles) et l’on retourne 3 lignes (output = lignes, size = 6). Chaque points correspond a la position d’un vertex decale legerement par le vecteur normal (pour que les lignes soient bien visibles et ne soient pas cachees par les triangles).

Télécharger le projet d’exemple

A suivre…

1. Shrink, explosion, subdivision, silhouette, hedgehog
2. Explosion, cheveux
3. Instanciation et culling
4. Instanciation et culling

L’instanciation
Lorsque l’on souhaite afficher de nombreux objets, la première approche pourrait être de faire plusieurs appels à glDrawArrays et glDrawElements. Le nombre d’appels aux fonctions de dessin peut cependant diminuer fortement les performances. Une optimisation possible est d’utiliser glMultiDrawArrays ou glMultiDrawElements, qui prennent des tableaux de données et permettent donc de faire qu’un seul appel. Cependant, il est nécessaire d’envoyer les données correspondantes à tous les objets que l’on souhaite créer, ce qui peut saturer la bande passante du GPU.

L’instanciation proprement dite permet de créer plusieurs instances d’un objet. On envoie les données que pour un seul objet, ce qui réduit la bande passante.

Pour personnaliser chaque instance, on fournit un tableau de données (Instanced Array), chaque élément du tableau correspondant à une instance. On pourra passer ainsi modifier la position des instances, les paramètres de texture pour personnaliser les instances, ajouter du bruit, etc. Le paramètre divisor permet de spécifier quand on passe à l’élément suivant dans un buffer. Pour divisor = 0, chaque vertex lit un nouvel élément dans le buffer. Avec divisor = 1, chaque instance lit un nouvel élément. Avec divisor = 2, un nouvel élément est lu toutes les 2 instances, etc.

Un exemple simple
Le code d’exemple affiche des cubes en utilisant glDrawElementsInstanced. Le curseur permet de sélectionner le nombre d’instances à créer. Le bouton permet de basculer entre la vue des cubes pleins et en fil de fer. Les FPS et le nombre d’instances sont indiqués dans le titre de la fenêtre. Je peux obtenir plus de 10 000 instances en même temps à 30 FPS (soit plus de 120 000 triangles) sur mon portable équipé d’une 8600M GT.

Pour ceux qui testeraient avec du matériel plus puissant, il est possible d’augmenter le nombre d’instance maximal en modifiant le facteur multiplicateur à la ligne 127 du fichier glwidget.cpp ou la valeur maximale du QSlider à la ligne 22 du fichier mainwindow.cpp. J’ai pu ainsi créer plus de 400 000 instances (4,8 millions de triangles) avant d’arriver à 30 FPS sur une tour équipée d’une GTX 460.

Télécharger le projet d’exemple

Au suivre…
* gpu gems chap 7
* http://sol.gfxile.net/instancing.html