Apprendre OpenGL moderne

OpenGL permet de modifier l’opérateur de comparaison utilisé dans le test de profondeur. Cela permet de contrôler dans quel cas le test de profondeur réussit et dans quel cas les fragments sont abandonnés et quand mettre à jour le tampon. Nous pouvons définir l’opérateur de comparaison (ou fonction de profondeur) en appelant glDepthFunc() :

glDepthFunc(GL_LESS);

Voici la liste des opérateurs de comparaison possibles :

La fonction par défaut est GL_LESS. Cela signifie que tous les fragments dont la valeur de profondeur est supérieure ou égale à la valeur dans le tampon sont abandonnés.

Voyons l’impact de la fonction de profondeur. Nous allons utiliser une nouvelle configuration qui affiche une scène simple avec deux cubes texturés posés sur un sol texturé sans éclairage. Vous pouvez trouver le code source ici.

Dans le code, nous changeons la fonction de profondeur à GL_ALWAYS :

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);

Cela revient à ne pas avoir activé le test de profondeur. Le test réussit toujours, donc les fragments qui sont affichés en dernier seront devant les fragments affichés avant, même s’ils auraient dû être derrière. Comme nous avons dessiné le sol à la fin, ses fragments recouvrent ceux des cubes :

En remettant GL_LESS, cela donne le type de scène auquel nous étions habitués :

Le tampon de profondeur contient des valeurs entre 0.0 et 1.0. Ces valeurs sont comparées avec la composante z des objets de la scène comme vu par le spectateur. Ces valeurs z dans l’espace vue peuvent prendre n’importe quelle valeur entre le plan proche (near) et le plan lointain (far) déterminé par la projection. Nous devons donc trouver une méthode pour transformer ces valeurs provenant de l’espace vue vers l’échelle [0, 1]. Une méthode est de les transformer linéairement. L’équation (linéaire) suivante transforme la valeur z pour obtenir une valeur entre 0.0et 1.0 :

Ici, near et far sont les valeurs que nous avons utilisées pour créer la matrice de projection (voir le chapitre sur les systèmes de coordonnées). L’équation prend une valeur z présente dans le champ de vision et la transpose dans l’échelle [0, 1]. La relation entre la valeur z et la profondeur correspondante est présentée sur ce graphique suivant :

Toutefois, un tampon de profondeur linéaire n’est pratiquement jamais utilisé. Pour obtenir des propriétés de projection correctes, une équation non linéaire proportionnelle à kitxmlcodeinlinelatexdvp\frac{1}{z}finkitxmlcodeinlinelatexdvp est utilisée . Cela permet d’obtenir une très grande précision lorsque le z est petit et une plus faible précision lorsque l’objet est loin. Pensez-y une seconde : avons-nous vraiment besoin de la même précision pour un objet éloigné de 1000 unités et un objet proche ? L’équation linéaire ne fait pas ce genre de considérations.

Comme la fonction non linéaire est proportionnelle à kitxmlcodeinlinelatexdvp\frac{1}{z}finkitxmlcodeinlinelatexdvp, les valeurs entre 1.0 et 2.0 donneront des valeurs entre 1,0 et 0,5, soit la moitié de la précision disponible. De même, des valeurs de z entre 50,0 et 100,0 ne prendront que 2 % de la précision disponible. Voici l’équation permettant de prendre en compte les distances near et far :

Ne vous inquiétez pas si vous ne comprenez pas ce que fait l’équation. La chose à retenir est que les valeurs dans le tampon de profondeur ne sont pas linéaires dans l’espace écran (elles sont linéaires dans l’espace vue, avant que la matrice de projection ne soit appliquée). Une valeur de 0,5 dans le tampon de profondeur ne veut pas dire que la valeur z de l’objet est à la moitié du champ de vision. La valeur z du sommet est en réalité assez proche du spectateur ! Vous pouvez voir la relation entre les valeurs z et leur correspondance dans le graphique suivant :

Comme vous pouvez le voir, les valeurs de profondeur sont principalement déterminées par les petites valeurs de z, donnant ainsi une grande précision pour les objets proches. L’équation pour transformer les valeurs z (du point de vue du joueur) est embarquée dans la matrice de projection. Par conséquent, lors de la transformation des coordonnées de sommets de l’espace vue à l’espace de découpage, puis à l’espace écran, l’équation non linéaire est appliquée. Si vous êtes curieux de comprendre ce que fait réellement la matrice de projection, je vous suggère de lire l’article de .

L’effet de l’équation non linéaire devient très visible lorsque nous essayons d’afficher le tampon de profondeur.

Nous savons que la valeur z de la variable du fragment shader gl_FragCoord contient la valeur de profondeur pour un fragment en particulier. Si nous utilisons la valeur de profondeur du fragment comme une couleur, nous pouvons afficher les valeurs du tampon de profondeur de l’intégralité de la scène. Nous pouvons le faire en retournant une nuance de gris basée sur la valeur de profondeur :

void main()
{
    FragColor = vec4(vec3(gl_FragCoord.z), 1.0);
}

Si vous exécutez le même programme, vous allez sûrement voir que tout est blanc, comme si toutes les valeurs de profondeur sont à 1.0, soit la valeur de profondeur maximale. Pourquoi ?

Vous devez garder en tête ce que nous avons vu dans la précédente section : les valeurs de profondeur en espace écran ne sont pas linéaire, c’est-à-dire, que la précision est plus importante pour les petites valeurs de z. La valeur de profondeur augmente rapidement suivant la distance, tous les sommets sont donc proches d’une profondeur de 1,0. Si nous nous approchions des objets, nous pourrions éventuellement obtenir des couleurs plus sombres et donc des valeurs de z plus faibles :

Cela met en évidence la non-linéarité des valeurs de profondeur. Les objets proches ont un impact plus important sur les valeurs que les objets au loin. En se déplaçant seulement de quelques millimètres, les couleurs passent du noir au blanc.

Toutefois, nous pouvons transformer les valeurs non linéaires en leur correspondance linéaire. Pour ce faire, nous devons refaire à l’envers le procédé de la projection uniquement pour les valeurs de profondeur. Cela signifie que nous devons repasser les valeurs allant de 0 à 1 en des valeurs allant de -1 à 1 (espace de découpage). Ensuite, nous devons enlever l’aspect non linéaire (deuxième équation) provenant de la matrice de projection et appliquer l’inverse de l’équation à la valeur de profondeur finale. Ainsi, nous obtenons des valeurs de profondeur linéaire. Cela semble-t-il faisable ?

Premièrement, nous transformons les valeurs de profondeur en coordonnées normalisées :

float z = depth * 2.0 - 1.0;

Ensuite, nous prenons le résultat z et appliquons la transformation inverse pour obtenir une valeur de profondeur linéaire :

float linearDepth = (2.0 * near * far) / (far + near - z * (far - near));

Cette équation est déduite à partir de la matrice de projection qui utilise l’équation non linéaire permettant d’obtenir les valeurs de profondeur entre near et far. Cet article mathématiquement imposant explique en détails la matrice de projection. Il explique aussi d’où vient l’équation.

Le fragment shader complet qui transforme la profondeur non linéaire de l’espace écran en profondeur linéaire correspond à :

#version 330 core
out vec4 FragColor;

float near = 0.1; 
float far  = 100.0; 
  
float LinearizeDepth(float depth) 
{
    float z = depth * 2.0 - 1.0; // back to NDC 
    return (2.0 * near * far) / (far + near - z * (far - near));    
}

void main()
{             
    float depth = LinearizeDepth(gl_FragCoord.z) / far; // division par far pour la démonstration
    FragColor = vec4(vec3(depth), 1.0);
}

Comme les valeurs entre near et far sont principalement supérieures à 1,0, elles sont affichées complètement en blanc. En divisant la profondeur linéaire par far dans la fonction main(), nous convertissons la profondeur pour obtenir des valeurs entre 0 et 1. Ainsi, nous pouvons voir les objets proches devenir progressivement plus clairs que les fragments proches du plan lointain.

Si nous exécutons l’application, nous obtenons des valeurs de profondeur linéaire sur la distance. Essayez d’explorer la scène pour voir les valeurs changer.

La scène est principalement noire, car le plan proche est à 0,1 et le plan lointain à 100, ce qui est très éloigné. Le résultat est que les objets sont plutôt proches du plan proche et donc les valeurs de profondeur sont faibles (plus sombres).

Un problème visuel classique peut arriver lorsque deux plans ou triangles sont superposés et que le tampon de profondeur n’a pas assez de précision pour déterminer quel est celui devant l’autre. Les deux formes vont continuellement alterner et donner des artefacts visuels. Cela s’appelle un conflit de profondeur (z-fighting), car les formes semblent se battre pour être par-dessus l’autre.

Dans la scène de ce tutoriel, il y a quelques endroits où le conflit de profondeur peut arriver. Les conteneurs sont exactement placés à la même hauteur que le sol et donc leur face du dessous est coplanaire avec le plan du sol. Les valeurs de profondeur des deux plans sont les mêmes, ce qui fait que le test de profondeur n’a pas de méthode pour déterminer lequel est le bon.

Si vous déplacez la caméra dans l’un des conteneurs, vous allez vous vite en rendre compte : la face du dessous alterne constamment entre la face du conteneur et le sol :

Le conflit de profondeur est un problème courant avec les tampons de profondeur et il est généralement plus fort lorsque les objets sont lointains (car le tampon de profondeur a moins de précision pour ceux-ci). Le conflit de profondeur ne peut pas être complètement supprimé, mais il y a quelques astuces pour l’éviter.

I-D-1. Éviter le conflit de profondeur▲

Ce tutoriel est une traduction réalisée par Alexandre Laurent dont l’original a été écrit par Joey de Vries et qui est disponible sur le site Learn OpenGL.