le pipeline graphique - igm.univ-mlv.frigm.univ-mlv.fr/~vnozick/teaching/slides/ensg/01...
Post on 14-Apr-2018
223 Views
Preview:
TRANSCRIPT
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
Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des données Dessin et shaders Rasterisation et interpolation Textures Etape finale et buffer images
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
���
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
������������������������������������������������������������������������������������������������������������������������������������������
��������������������������������������������������������������������������������������������������������������������������������������������
Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des données Dessin et shaders Rasterisation et interpolation Textures Etape finale et buffer images
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
�����
OpenGLSL : qualifiers
§ 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)
�����
OpenGLSL : qualifiers
§ 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
Utiliser les shaders
§ 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
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
Utiliser les shaders
§ 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 …
Utiliser les shaders
§ 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) :
������
≤≤−≤≤−≤≤−
���
Coordinates transform
2. Projection : mise en oeuvre ú Fixer la pile de matrice courante à PROJECTION ú Projection orthographique
������������������������������������������
ú Projection perspective : ������������������������������������������
�����
Coordinates transform
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 ������������
⎪⎩
⎪⎨
⎧
≤≤−≤≤−≤≤−
���
���
���
���������
Coordinates transform
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
Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des primitives Vertex processing : illumination & transformation Rasterisation et projection image Fragment processing Affichage et tests
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
Le pipeline graphique : OpenGL Philosophie du pipeline Chargement des primitives Vertex processing : illumination & transformation Rasterisation et projection image Fragment processing Affichage et tests
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
Framebuffer: color buffer
§ É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
Framebuffer: color buffer
§ 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)
top related