Download pdf - LE PIPELINE GRAPHIQUE - igm.univ-mlv.frigm.univ-mlv.fr/~vnozick/teaching/slides/ensg/01 Pipeline_graphique... · Et D irect 3 D ? § Direct 3D ú Implémente également le pipeline

LE PIPELINE GRAPHIQUE

Cours de synthèse d’images 3D

Plan de la présentation

Le pipeline graphique & OpenGL

Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des données Dessin et shaders Rasterisation et interpolation Textures Etape finale et buffer images

Philosophie pipeline graphique Philosophie pipeline graphique

§  Idée maîtresse : ú  Grande capacité de rendu de triangles ú  Pour chaque image on injecte toute la scène

þ Permet de gérer les occlusions à tout moment notamment pour les éléments mobiles

ý Beaucoup de travail inutile pour les zones occultées et pour les zones statiques non occultées

ú  Organisé en pipeline   Les triangles peuvent être rendus dans n’importe quel ordre

þ Traitement hautement parallélisable ý Problème pour gérer la transparence

Philosophie pipeline graphique

§  Mise en œuvre de la rasterisation §  Rasterisation fondée sur

ú  Algorithme de remplissage des polygones   Quels pixels sont concernés par la projection d’un triangle (ou autre polygone convexe) sur un écran 2D ?

ú  Algorithme du Z-‐buffer ú  En anglais : to rasterize

§  Omniprésent en temps réel ú  Jeux vidéo ú  Simulateurs & RV

Rasterisation : principe

§  Idée générale ú  Chaque polygone convexe (primitive) est projeté sur l’écran (image de pixels)

ú  Les occlusions sont gérées grâce à une image de profondeur : le Z-‐buffer

§  Philosophie orienté objet ú  La complexité est dépendante du nombre de primitive

Rasterisation : algorithme

��

��

��

��

��

��

��

��

��

��

��

��

OpenGL

§  Cartes graphiques implémentent le pipeline graphique

§  OpenGL : API C (C++) ú  Permet de contrôler les cartes graphiques :

  Fournir les données d’entrées (géométrie / matériaux)

  Créer les shaders et leur fournir des données   Gérer le rendu final dans l’image   Fixer l’ensemble des « états internes » de la carte graphique

Et Direct 3D ?

§  Direct 3D ú  Implémente également le pipeline graphique ú  Pilote la carte graphique ú  Philosophie très proche d’OpenGL þ Plus robuste (?) sur plateforme windows, seule possibilité sur Xbox   Utilisé massivement dans le domaine du jeux vidéo

ý Pas multiplateforme, contraint à Windows   Compatibilité avec smartphone, web

OpenGL : généralités

§  Programmation par état ú  Carte graphique = machine électronique à état ú  OpenGL : bibliothèque à état

  Dès que l’on spécifie une propriété (utilisation du Zbuffer...), tant que l’on ne la change pas, c’est cette propriété qui est utilisée

  Chaque propriété a une valeur par défaut   Refixer les valeurs est une bonne idée (ou manager)   Existence de nombreux états   simplifié depuis GL 3.X

OpenGL : généralités

§  Grosse évolution de l'API depuis 2008/2009 ú  Ancienne version OpenGL 1.X & 2.X

  Capacité de rendu simplifié   Un pipeline « fixe »

ú  Nouvelle version OpenGL 3.X & 4.X   Plus de mode de rendu « direct »   Plus de simplicité d'utilisation   Généricité & efficacité étendue   Un pipeline « flexible »

��

��

OpenGL 2-‐ vs 3+

• V2 : envoi spécifique de sommet, normales, textures de coordonnées...

• V3 : tout est dans des buffers génériques. L'utilisation des données par « sommet » est spécifiée par le programmeur

Gestion des données

• V2 : pile de matrice. Fonctions pour les transformations & projections élémentaires

• V3 : entièrement spécifiées par le programmeur

Transformation des données

• V2 : Utilisation du modèle d'éclairement fixé. Possibilité de modification via un shader. Accès aux données via des mots clés.

• V3 : Nécessité d'écriture soi même son modèle d'éclairement. On doit écrire un shader. Accès aux données génériques & uniques. Liberté d'écriture.

Calcul de la couleur

Pipeline graphique OpenGL Données d’entrée

Données de sortie Principe de rendu

§  Le rendu se fait en deux « temps » ú  A l’initialisation : chargement de « toutes » les données   Géométrie, textures…

ú  Lors du rendu   Commande de dessin   Pilotage des shaders


Chargement des données Les buffers

§  Buffers et OpenGL ú  La quasi-‐totalité des données gérées par le GPU sont dans des buffers   Pixels / Texels mais aussi Vertex, Normal, Uniform

ú  Buffers : PBO / VBO / TBO / TFB / UBO ú  Accès aux buffers via des points de lien

  9 points de liens

��

��

��

��

Textures – principe Textures – UT

§  Il existe plusieurs « unités de texture » §  Ces unités gèrent :

ú  L’image (la texture) présente ú  L’accès aux couleurs via les coordonnées de texture

ú  Peuvent être activées ou désactivées indépendamment

ú  Sont indépendantes ú  Gèrent 4 types de texture 1D, 2D, 3D, CUBE_MAP

§  Un sommet peut utiliser plusieurs unités

Textures – chargement

§  Objet texture ú  A un numéro unique : identifiant ú  Suite au chargement initial, permet un accès immédiat

par la carte ú  Créer un objet texture : ��

  � : nombre d’indice à générer   �� : tableau des indices

ú  Lier une texture : ��   �� = ��

Devient alors la texture active (de l’unité de texture active)

Textures – chargement

§  Charger l’image : ��ú  �� : Suivant la texture cible �� et

cas particulier en 2D pour cibler les faces du CUBE_MAP

ú  �� : Pour le mipmapping (mettre 0) ú  �� : Format de la texture à générer

(GL_RGB par exemple) ú  ��, ��, �� : Taille de l’image (depth pour

3D) ú  �� : Bordure de la texture (mettre à 0) ú  ��, �� : Format et type des données de l’image ú  �� : pointeur vers les données de l’image

Exemple

��

��

��

��


Dessin & shaders

Dessiner la scène

§  On va se concentrer sur un « objet » ú  Un maillage plus exactement ú  Dessiner une scène consiste à dessiner plusieurs maillages en changeant certaines propriétés de la scène   Position des maillages   Propriété des matériaux   Textures…

Primitive graphique OpenGL

§  Que dessine t’on ? ú  Données sommets en

buffer : VBO   Coordonnées   Normales   Coordonnées de texture   …

ú  Primitives graphiques

Primitive graphique OpenGL

§  Fournir les attributs ú  Via les Vertex Buffer Object (VBO)

  Stocke les données   Stocke « l'objectif » de ces données : position, normale...

  En fait, lié à l'indice de l'attribute dans le shader

ú  Création & remplissage des VBO   Comme un buffer classique   Via le point de lien : GL_ARRAY_BUFFER

Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des primitives Vertex processing : transformation & calculs Rasterisation et projection image Fragment processing Affichage et tests

Vertex processing

Vertex processing

§  Comprend classiquement : ú  La transformation des points

  Dans le référentiel de base de la caméra

ú  La projection ú  Le calcul « d’information » par sommet

  Ca peut être une partie du calcul de l’illumination par exemple

  Ou n’importe quoi d’autre …

Transformation caméra

§  Transformation dans l’espace caméra ú  Transformer les coordonnées objets dans le référentiel de la caméra   Ce référentiel mets la camera à l’origine et son axe de visée sur l’axe z vers les z négatifs

Les transformations

§  Transformations par matrices 4x4 ú  Organisées en pile ú  Données subissent la matrice haut de pile ú  Matrice de flottants stockés en colonnes

§  Il existe (3+n) piles de matrices ú  MODELVIEW, PROJECTION, COLOR ú  Plus une pile par unité de texture (TEXTURE)

⎟⎟⎟⎟⎟⎟

⎠

⎞

⎜⎜⎜⎜⎜⎜

⎝

⎛

��

��

��

��

��

��

��

��

��

Les transformations

§  Opérations courantes sur pile ú  ��

  fixe la pile courante   �� prend les valeurs ��, ��, �� ou ��

§  �� ú  recopie de la matrice haut de pile au sommet de la pile

§  ��ú  enlève la matrice haut de pile

§  �� ú  remplace la matrice haut de pile par la matrice identité

§  �� ú  idem avec une matrice spécifiée par l’utilisateur

��

Les transformations

§  Fixer des transformations : ú  Opérateur calculant une matrice et la multipliant à la matrice haut de pile

ú  Opérateurs :   �� Translation (x,y,z)

  �� Rotation d’angle θ et d’axe (x,y,z)

  �� Homothétie de rapport x, y et z

��

Les transformations

§  Après transformation ú  Coordonnées dans le référentiel caméra de base

ú  Ainsi pour voir le cube unitaire centrée sur l’origine il faut reculer la caméra   Reculer la caméra = avancer la scène   Application de la translation (0,0,-‐ recul)

ú  Déplacer la caméra = faire le déplacement inverse (sur la scène)

��

Exemple : déplacements

§  Dessin de 2 feary hats ��

��

Les transformations

§  OpenGL 3+ ú  C'est le désert ! ú  Aucune fonction prédéfinie ú  Le programmeur doit charger les matrices de

transformation

§  Chargement des uniforms ú  Uniform spécifié dans le shader (cf après) ú  Récupérer 1 identifiant : ��

ú  Charger la donnée : ��

��

Les transformations

§  Exemples typiques ú  Modelview & projection matrix

  Fonction spéciale glUniformMatrix*

ú  Normal matrix   Pourquoi faut il une matrice spéciale ?

ú  ...

��

Exemple : déplacements

§  Dessin d’un feary hats ��

��

Trois types d’illumination

•  Il faut alors spécifier une couleur pour chaque sommet

• Possibilité d’une couleur secondaire

Par une couleur

• Fixer les lumières • Fixer normales & matériaux des objets

En utilisant un modèle d’éclairement

��

Trois types d’illumination

§  Illumination par couleur / flat painting ú  Affection des couleurs via ��ú  Affectation d’une couleur secondaire via ��

§  Illumination par modèle d’éclairement ú  Fondé sur Blinn-‐Phong

��

Par modèle d’éclairement

§  Fixer normale par vertex ú  ��

§  Fixer matériaux par vertex ú  Matériaux fixé par ��

ú  �� : �� , ��, ��

ú  �� : nom de la propriété ú  �� : tableau de n paramètres

��

Propriété n

AMBIANT 4

DIFFUSE 4

AMBIANT_AND_DIFFUSE 4

SPECULAR 4

EMISSION 4

SHININESS 1

COLOR_INDEXES 3

Par modèle d’éclairement

§  Fixer les propriétés de la lumière ú  glLight*

  Fixe l’intensité lumineuse (ambiante, diffuse, spéculaire)

  Fixe sa position   Autres propriétés :   Spotlight   Attenuation

��

Vertex processing en GLSL

§  Partie programmable possible ú  Spécification : OpenGLSL ú  C’est au programmeur de gérer

  La projection dans le référentiel caméra   Le calcul de l’illumination

ú  Mais peut servir à bien d’autres choses   Calculer d’autres valeurs en chaque sommet   Alléger les calculs (Phong)

ú  Spécialité version 2.X (GLSL v1.5)   De nombreux mot clé à disposition : récupération immédiate de position, normale, matrice modelview & projection...

��

Vertex processing en GLSL

§  Partie programmable nécessaire ú  Aucun « raccourci » disponible ú  Tout à programmer

§  GLSL 1.5 & GLSL 4.X ú  GLSL 1.X : ancienne version ú  GLSL 4.X : « nouvelle » version, renommée pour coller aux spécifications GL

��

Shaders : aperçu Shaders : intérêt

§  Intérêt :ú  Adaptabilité du rendu ú  De nouveaux rendus (rapides !) :

  Matériaux réalistes, milieux participants, éclairage par fragment, ombre, éclairage réaliste…

ú  Autres calculs que le rendu   Calcul matriciel, lancer de rayon, silhouette, traitement d’images, animation …

Shaders : intérêt

��

Shaders : intérêt

��

Shaders : intérêt

��

Shaders : intérêt

��

Shaders : intérêt

��

Shaders : intérêt

��

Shaders : intérêt

��

Shaders : intérêt

��

Exemple de shaders

��

��

��

Exemple de shaders

��

Shaders : vertex shader

��

��

��

�

��

��

��

Shaders : fragment program

��

��

��

�

��

��

��

OpenGLSL : introduction

§  Propriétés ú  Lien et intégration simple avec Open GL ú  Flexible aux futures évolutions des cartes graphiques ú  Indépendant du hardware ú  Conserve les performances des cartes graphiques ú  Langage simple à utiliser ú  Convient à la norme OpenGL ARB (Arch. Review

Board) ú  Permet les futures parallélisations dans les cartes

graphiques ú  Simple à optimiser (donc langage simple)

OpenGLSL : introduction

§  Caractéristiques : ú  Syntaxe identique à celle du C / C++ ú  Nouveaux types de données :

  Vecteurs   Matrices   Fragment de texture

ú  Existence de variables et fonctions prédéfinies ú  Opérateurs surchargés ú  Pas de pointeur ni de référence ú  Pas de promotion (cast) implicite ú  Passage d’argument par valeur

OpenGLSL : avantages

§  Colle à OpenGL §  Compilation à l’exécution §  Indépendant du hardware §  Compilation par le driver

ú  Meilleures performances §  Standard open source §  Fonctionne pour tout processus graphiques §  Premier sur les dernières parties non

programmable §  Pas besoin de librairie supplémentaire

OpenGLSL : types

§  Types disponibles : ú  Scalaires : int / uint / float / double / bool ú  int : de –65535 à 65535 ú  bool : true ou false

§  Vecteurs ú  vec2, vec3, vec4 : vecteur en float à 2, 3 ou 4

composantes ú  dvec2, dvec3, dvec4 : idem avec des doubles ú  {iu}vec2, {iu}vec3, {iu}vec4 : idem mais avec des entiers

signés (i) ou non signés (u) ú  bvec2, bvec3, bvec4 : idem mais avec des booléens

OpenGLSL : types

§  Accès aux composantes 1, 2, 3 ou 4 du vecteur vec par ú  vec.r / vec.g / vec.b / vec.a ú  vec.s / vec.t / vec.p / vec.q ú  vec.x / vec.y / vec.z / vec.w ú  Comme un tableau : vec[0] / vec[1] / vec[2] / vec[3]

OpenGLSL : types

§  Matrices ú  mat2, mat3, mat4 : Matrice 2x2, 3x3 et 4x4 de float ú  matnxm : Matrice n colonnes, m lignes ú  Existe aussi en double (dmat*) ú  Organisées en colonne ú  Accès aux colonnes d’une matrice mat :

  mat[0] / mat[1] / mat[2] / mat[3] : 1, 2, 3 et 4ème colonne

ú  Accès à un élément de mat :   mat[0][2] : 3ème élément de la 1ère colonne

OpenGLSL : tableaux

§  Tableaux ú  Déclarés classiquement : ú  La taille est optionnelle, peut être calculée à la compilation :

ú  Redimensionnement explicite ou implicite illégal :

��

��

��

OpenGLSL : qualifiers

§  attribute : ú  Variables injectées fréquemment dans le

pipe line : sommets, normales … ú  Accessible en lecture uniquement ú  Réservés au vertex program ú  Sont forcément des flottants : float, vecteur ou matrice ú  Certaines variables prédéfinies

§  uniform : ú  Variables correspondant à des données ne changeant pas

fréquemment (au maximum 1 fois par primitive) ú  Accessible en lecture uniquement ú  Certaines variables prédéfinies ú  Commun aux vertex et fragment program

��


§  varying : ú  Interface entre le vertex program et

le fragment program ú  Accessible en écriture dans le vertex shader ú  Accessible en lecture dans le fragment shader ú  Interpolation entre le vertex et le fragment sur la primitive

§  const : ú  Constante : initialisation obligatoire et accessible en lecture

§  sans qualificateur : ú  Variable temporaire : accessible en lecture et écriture ú  Défini pour un program donné (vertex ou fragment)

��


§  Shaders : ú  const : constante (à la compilation) ú  in : donnée d'entrée fourni par l'application ou le shader

précédent ú  out : donnée de sortie ú  none : variable locale ou paramètre

§  Interpolation : ú  smooth / flat / noperspective

§  Paramètre de fonction : ú  in (none) / out / inout

§  Layout qualifiers ú  Evite l’emploi de glBindAttribLocation

��

OpenGLSL : flux d’instructions

§  Chaque programme possède un main §  Quasiment strictement identique au C

ú  if…else / while / do … while / for ú  break / continue ú  Pas de switch, pas de goto

§  Fonctions : identique au C sauf ú  Passage par valeur et référence : qualificateurs

  in : passage par valeur   out : accessible en écriture seulement (copié à la fin)   inout : passage par référence (copié au début et à la fin)   const : ne peut être écrit, utilisable uniquement avec in

OpenGLSL : opérations

§  Similaires à celles du C ú  Arithmétiques : ��ú  Logiques : ��

ú  Affectation : ��ú  Sélection : ��

§  Opérations sur les vecteurs & matrices ú  Pas d’opérateur logique (fonctions prédéfinies) ú  Opérations composante par composante SAUF :

  vecteur * matrice : transposée du vecteur fois la matrice   matrice * vecteur : opération classique matrice vecteur

OpenGLSL : opérations

§  Sélection composantes vecteur : swizling ú  Trois groupes de sélection : xyzw, rgba ou stpq ú  On peut les composer / ordonner / restreindre à loisir

��

Shader & Pipe line

§  Vertex Shader ú  Remplace la partie vertex processing ú  Variables attribute prédéfinies :

  Reçue par des appels standard à des fonctions OpenGL   Prédéfinies :

  gl_Position : correspond à glVertex3f(…)   gl_Normal : correspond à glNormal3f(…)   gl_Color : correspond à glColor3f(…)   gl_SecondaryColor : correspond à glSecondaryColor3f(…)   gl_MultiTexCoord : correspond à glTexCoord2f(…) / glMultiTexCoord(…)

  …

��

Shader & Pipe line

§  Vertex Shader ú  Variables attribute, in définies par l’utilisateur :

  Utilisation de ��   Voir dans la partie suivante

ú  Variables uniform prédéfinies   Uniquement en OpenGL 2-‐

ú  Variable uniform définies par l’utilisateur   Utilisation de ��   Voir dans la partie suivante

Shader & Pipe line

§  Vertex Shader ú  Variables varying / out spéciales :

  Variable ��  Doit impérativement être écrite   C’est un vec4

  Variable ��  Taille du point : optionnel   C’est un float

  Variable ��  Coordonnées du point pour le clipping : optionnel   C’est un vec4

Shader & Pipe line

§  Vertex Shader ú  Variables varying prédéfinies :

  ��   ��

  ��

  ��

  ��

  ��   ��

ú  Variables varying définies par l’utilisateur   Rien à faire coté application. Tout est géré dans le driver

��

Shader & Pipe line

§  Fragment Shader ú  Les varying / in arrivent après interpolation perspective ú  Variables varying / in spéciales :

  �� :   Position du fragment

  ��:   La primitive du fragment est elle face à la caméra

ú  Variables varying prédéfinies :   ��   ��   ��   ��

Shader & Pipe line

§  Fragment Shader ú  Variables uniform : comme pour le vertex shader ú  Variables de sorties :

  ��:   Couleur du fragment à ajouter dans l’image

  ��:   Permet de fixer la profondeur du fragment   Si non fixé, on conserve la valeur de base

Shader & Pipe line

§  Variables uniformes prédéfinies ú  Il y en a énormément :

  Pour les lumières   Pour le brouillard   Pour les matrices de transformation   Pour les paramètres de la caméra   Pour les matériaux utilisés par les objets   Pour les propriétés de point   …

ú  Correspondent à des « états » du pipeline graphique ú  Liste complète sur opengl.org

��

Exemple de shaders

��

��

��

Exemple de shaders

��

Utiliser les shaders

��

§  Méthode en 7 points : 1.  Créer un ou plusieurs shaders

  glCreateShaderObject

2.  Leur donner du code source   glShaderSource

3.  Les compiler   glCompileShader

4.  Créer un objet programme   glCreateProgramObject

5.  Attacher les shaders à cet objet   glAttachObject


§  Méthode en 7 points : 6.  Lier le programme

  Permet par exemple de relier les variables varying …   Similaire à la phase de lien d’une phase de compilation   glLinkProgram

7.  Intégrer le programme dans le pipeline graphique   glUseProgram

8.  Fournir les variables définies par l’utilisateur   glGetUniformLocation, glUniform   glBindAttribLocation, glGetAttribLocation, glVertexAttrib   glEnableVertexAttribArray, glVertexAttribPointer

Exemple : utilisation shader

��

��

Exemple : utilisation shader

��


§  Transmission des variables uniform : ú  Variables prédéfinies :

  Utiliser les instructions classiques OpenGL ú  Variables définies par l’utilisateur

  Récupération de l’indice de stockage du driver : glGetUniformLocation(program,"nom_variable")

  Envoi des valeurs à cette variable : glUniform{1|2|3|4}{s|f|d}{v}(indice,{nb,}valeur)

§  Transmission des variables attribute / in : ú  Par les buffers ú  Variables prédéfinies :

  Utilisation glVertex pour gl_Vertex   Utilisation glNormal pour gl_Normal …


§  Variables définies par l’utilisateur : 1.  Récupérer l’indice de stockage de la variable :

  ind = glGetAttribLocation(program,"nom_variable");   ind = glBindAttribLocation(program,1,"nom_variable");

2.  Envoyer les valeurs :   Une valeur : glVertexAttrib{1234}{s|f|d}{v}(ind,valeur);

  Via VBO : glVertexAttribPointer(indice,size,type,normalized, stride,pointeur);

Conseils

§  Avoir une idée claire de ce que l’on veut ú  Où le shader intervient-‐il dans cela ?

§  Ajouter la complexité progressivement ú  Commencer par les choses simples ú  Tester et complexifier ú  Mettre des commentaires sur les choses qui marchent

§  Faire au plus simple §  Faire au plus modulaire

ú  Utiliser des fonctions ú  Il est préférable de faire une bibliothèque de shaders

simples qu’un grand shader gérant tout !

Optimisations

§  Faire une bonne répartition des calculs entre ú  CPU

  Précalcul dans des textures   Si le CPU est dispo : l’utiliser !

ú  Vertex shader   Pour toute donnée variant peu dans l’image

ú  Fragment shader   Seulement pour des données variant beaucoup et non linéairement !

Optimisations

§  Utilisez les fonctions prédéfinies ú  Liste accessible sur opengl.org (quick ref cards)

§  Utiliser les vecteurs ú  Type native des processeurs électroniques

§  Utiliser des textures ú  Pour encoder des fonctions complexes de 1,2 ou 3 variables

Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des primitives Vertex processing : illumination & transformation Rasterisation et projection image Fragment processing Affichage et tests

Rasterisation & culling

Coordinates transform

1.  Transformations : vue précédemment 2.  Projection :

ú  Projeter les primitives (groupe de sommets) dans le référentiel caméra sur l’image

ú  Plusieurs projections possibles   Projection orthographique, perspective, ...   On conserve l’information de profondeur...   Référentiel écran virtuel (ss coord homogène) :

��

≤≤−≤≤−≤≤−

��


2.  Projection : mise en oeuvre ú  Fixer la pile de matrice courante à PROJECTION ú  Projection orthographique

  ��

ú  Projection perspective :   ��

��


3.  Clipping (Coupe) ú  On peut retirer les parties qui ne se projetteront pas

sur l’image ú  Génère de nouveaux points ú  Clipping d’un sommet si il n’est pas dans l’interval :

ú  Possibilité de rajouter des plans de coupe   ��

⎪⎩

⎪⎨

⎧

≤≤−≤≤−≤≤−

��

��

��

��


4.  Division perspective 5.  Transformation image

ú  Transforme des coordonnées absolues en coordonnées images

ú  On joue sur la zone image à dessiner   �� : spécifie px, py , ox et oy   �� : spécifie n et f

⎟⎟⎟⎟

⎠

⎞

⎜⎜⎜⎜

⎝

⎛

��

−��

�⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

��

��

��

��

�

��

��

�

�

�

⎪⎪⎩

⎪⎪⎨

⎧

��

��

��

��

��

�

�

��

��

��

Exemple : projection

��

��

Rasterisation

§  Une fois les triangles déterminés ú  Sélectionner les pixels

concernés dans l’espace image

ú  Calculer (interpoler) les valeurs

ú  Pixels = Fragments   fragment : position dans

l’image avec des informations (normale, coordonnées de texture, couleur ...)

  Position entière

Rasterisation

§  Effets sur la rasterisation ú  Changer la taille des points

  ��

ú  Antialiasing   Effectué durant la rasterisation   Calcul, pour chaque fragment, le pourcentage de contribution de la primitive pour ce fragment

ú  Culling   Détermination pour chaque surface, si elle est face à la caméra ou non

  Utiliser �� pour enlever un type   �� = ��,�� ou ��

Rasterisation

§  Effets sur la rasterisation ú  Ignorer les surfaces avec

  ��   ��

  �� = ��  Affichage des points des polygones (triangles, quads ...)

  �� = ��  Affichage des lignes des polygones

  �� = ��  Affichage normal   État par défaut


Fragment processing Fragment processing

§  Calcul de la couleur des pixels ú  Via les attributs calculés dans l’étape de vertex processing

ú  Via les textures ú  Via un fragment shader

Fragment illumination

§  Pipeline fixe ú  Par couleur :

  Chaque fragment a une couleur interpolée des couleurs des sommets

ú  Par modèle d’éclairement :   Une couleur a été calculé sur chaque sommet par le modèle d’éclairement

  Ces couleurs ont été interpolées pour donner une couleur pour chaque fragment

��

Textures

§  Principe ú  Chaque sommet a des coordonnées de texture

  Chaque fragment a sa coordonnée de texture

ú  Chaque fragment se voit « attribuer » la couleur correspondant à ses coordonnées de texture

§  Mise en œuvre : 2 étapes 1.  Charger la texture et ses propriétés dans la carte 2.  Fournir les coordonnées de texture pour chaque

sommet

Textures

§  Il existe plusieurs « unités de texture » §  Ces unités gèrent :

ú  L’image (la texture) présente ú  L’accès aux couleurs via les coordonnées de texture ú  La combinaison de ces couleurs avec la couleur du

fragment ú  Peuvent être activées ou désactivées

indépendamment ú  Sont indépendantes ú  Gèrent 4 types de texture 1D, 2D, 3D, CUBE_MAP

§  Un sommet peut utiliser plusieurs unités ú  On appelle ça le multitexturing


Affichage et tests

Affichage et tests

§  Dernière étape : ú  Décider du sort du fragment :

  Le garder ou le détruire

ú  Comment mêler sa couleur avec celle déjà présente   Dans le buffer image : le framebuffer

§  Framebuffer ? ú  Collection de logical buffer : color buffer, stencil buffer,

depth buffer ú  Color buffer séparé en 4 buffers :

  front-‐left, front-‐right, back-‐left, back-‐right et auxiliaires

Framebuffer

§  Intérêt des buffers logiques : ú  Color Buffer : celui qui stocke l’image

  Contient 4 buffers d’affichage permettant l’affichage fluide (front and back) et la stéréoscopie (left et right)

ú  Stencil Buffer :   permet de fixer des conditions, par pixel, permettant l’écriture ou non dans le color buffer

ú  Depth Buffer :   Gestion des occlusions

Framebuffer: color buffer

§  Lecture du framebuffer ú  Attention : opération coûteuse ú  Sélection d’un buffer de lecture

  ��  �� : NONE, FRONT_LEFT, FRONT_RIGHT, BACK_LEFT, BACK_RIGHT, FRONT, BACK, LEFT, RIGHT, FRONT_AND_BACK, et AUXi

ú  Lecture dans le buffer :   ��

  �,� : coordonnées en bas à gauche de la partie du buffer à récupérer

  �,�,�� : identique à glDrawPixels


§  Écriture dans un framebuffer ú  Opération pouvant être coûteuse : Pixel rate ú  Sélection d’un buffer d’écriture

  Vu ci après : ��   A l’exception de l’écriture dans depth et stencil buffer

ú  Écriture avec   ��

  � et � : taille de l’image à écrire   �� : type de données image à « remplir »   �� : type informatique des données data   �� : pointeur sur le tableau 1D image de type type


§  Programmation avancée : ú  Écriture directe dans des multiples buffers

  Avec ��  � : nombre de buffers où écrire   ��: tableau contenant les noms symboliques vus précédemment à l’exception de FRONT, BACK, LEFT, RIGHT et FRONT_AND_BACK.

ú  A savoir : Les fragment shaders peuvent écrire des données différentes sur chaque buffer de sortie   �� ou ��

Framebuffer: effacement

§  Choix de la couleur d’effacement : ú  Color Buffer : ��

  Flottant clampés à [0..1]   Par défaut à 0.0, 0.0, 0.0, 0.0

ú  Depth Buffer : ��   Ramené à [0..1]. Par défaut à 1.0

ú  Stencil Buffer : ��   Par défaut à 0

Framebuffer Object : FBO

§  On peut faire du rendu « offline » ú  Dans des framebuffer séparés ú  Gérés par la carte graphique et non par le serveur graphique

ú  Possibilité étendues : compression, rendu en texture, rendus multiples

FBO: création

§  Création de framebuffer ú  glGenFrameBuffers(n,ids)

§  Binding classique ú  glBindFrameBuffer(target,id)

  target : draw / read

§  Détruire ú  glDeleteFramebuffers(n,ids)

FBO: usage

§  On attache des buffers à rendre ú  Des render buffers : generation, binding, destruction classique   glFramebufferRenderbuffer(targer,attach,rendertarget,id)   attach : depth_attachment, stencil_attachment, color_attachment

ú  Des textures   glFrameBufferTexture(target,attach,id,level)