TP OpenGL no 2

TP OpenGL no 2
De OpenGL 1.1 vers OpenGL 2.1
Récupérez les sources corrigées du TP précédant ici.
Exo.1 Vertex Buffer Object
Changez la méthode d’affichage et utilisez un Vertex Buffer Object pour afficher votre cube ou votre
sphère. Voir fonction :
bool Render :: init () {
/* * Vertex VBO * */
// g e n e r a t e a new VBO and get the a s s o c i a t e d ID bind VBO in order to use
// upload v e r t i c e s n o r m a l s and t e x t u r e c o o r d o n a t e s to VBO
/* * TO DO * */
...
/* * Index VBO * */
// g e n e r a t e a new VBO and get the a s s o c i a t e d ID
// bind VBO
// upload i n d e x e s to VBO
/* * TO DO * */
}
Pour cela utilisez les données membres vertexVboId indexVboId et les fonctions :
g l G e n B u f f e r s ( GLsizei n , GLuint * buffers ) ;
g l B i n d B u f f e r ( GLenum target , GLuint buffer );
g l B u f f e r D a t a ( GLenum target , GLsizeipt r size , const GLvoid * data , GLenum usage ) ;
g l B u f f e r S u b D a t a ( GLenum target , GLintptr offset , GLsizeiptr size , const GLvoid * data ) ;
Remarque : Utiliser des Vertex Buffer Object n’a pas pour objectif de changer le rendu visuel mais
d’accélérer le temps de rendu.
Exo.2 Mise en place des shaders
Inspectez le répertoire shaders de votre projet. Ce répertoire contient un certain nombre de vertex shader
(.vs) et de fragment shader (.fs). Dans un premier temps vous allez chargez le shader moon (moon.vs et
moon.fs) dans la fonction :
bool Render :: init () {
// s h a d e r s l o a d i n g
/* * TO DO * */
}
Pour chargez les shaders vous allez avoir besoin des fonctions suivantes :
bool Render :: loadShade r ( const char * shaderName , GLuint & s h a d e r P r o g r a m ) ;
g l U s e P r o g r a m // I n s t a l l s a p r o g r a m object as part of c u r r e n t r e n d e r i n g state
g l G e t U n i f o r m L o c a t i o n // R e t u r n s the l o c a t i o n of a u n i f o r m v a r i a b l e
glUniform // s p e c i f y the value of a u n i f o r m v a r i a b l e for the c u r r e n t p r o g r a m object
Cherchez dans la documentation Opengl 2.1 pour plus de précision.
Utilisez le premier élément de tableau shaderPrograms de la classe Rendu pour garder un lien vers votre
programme shader. Dans un premier temps la seul variable à transmettre à votre shader est la position de la
lumière ( lightPos). Vous pouvez utiliser la donnée membre lightEarthLoc de la classe Rendu pour stocker
l’emplacement (location) de votre variable uniforme. Par la suite n’hésitez pas à créer ou à utiliser les données
membres existantes pour les autres variables uniformes que vous aurez a transmettre aux shaders.
1
Exo.3 Illumination de Gouraud
Dans le fichier moon.fs calculez la couleur de chaque vertex en fonction de l’illumination dans le vertex
shader et interpolez les couleurs en les passant au fragment shader.
Utilisez le modèleh d’illumination
suivanth: i
ibs
~ V
~
~
~
~ · L+
I = ia + id · max 0, N · L + is · max 0, N
avec :
~ V
~ ||
||L+
–
–
–
–
–
–
–
–
I : illumination/couleur final.
ia : couleur ambiante.
id : couleur diffuse.
is : couleur spéculaire.
~ : vecteur normal.
N
~ : vecteur lumière.
L
~ : vecteur vision (la caméra est toujours placée à l’origine du repère (0, 0, 0)).
V
bs : brillance spéculaire.
N
L
Les variables pré-intégrées suivantes vous seront utiles :
gl_Vertex // input a t t r i b u t e : c u r r e n t vertex p o s i t i o n ( vec4 )
gl_Normal // input a t t r i b u t e : c u r r e n t vertex normal ( vec3 )
gl_Positi o n // output v a r i a b l e : p o s i t i o n of the c u r r e n t vertex ( vec4 )
g l _ P r o j e c t i o n M a t r i x // input u n i f o r m : p r o j e c t i o n matrix ( mat4 )
g l _ M o d e l V i e w M a t r i x // input u n i f o r m: model view matrix ( mat4 )
g l _ N o r m a l M a t r i x // input u n i f o r m: upper left of the model view matrix ( mat3 )
g l _ F r a g C o l o r // output v a r i a b l e : f r a g m e n t color ( vec4 )
Cherchez dans la spécification de GLSL 1.2 pour plus de précision.
Exo.4 Création de la lune
Affichez une seconde sphère plus petite et qui tourne autour de la première sphère
dans la fonction :
void Render :: display ( const glm :: mat4 & view ) {}
// Moon d i s p l a y
/* * TO DO * */
}
Veillez à a ceux que l’origine de la source lumineuse reste cohérente entre les deux
sphères.
Exo.5 Illumination de Phong
A partir des shaders moon.vs et moon.fs complétez les shaders earth.vs et earth.fs
pour réalisez un modèle d’illumination de Phong. A la différence de l’illumination
de Gouraud, le calcul de l’illumination se fait dans le fragment shader à partir des
vecteurs normaux qui sont calculée dans le vertex shader. Chargez et appliquez
ces shaders dans la fonction :
bool Render :: init () {
// Earth d i s p l a y
// Get u n i f o r m l o c a t i o n s
// Set u n i f o r m s
/* * TO DO * */
}
Modifiez les shaders moon et earth de manière à obtenir deux couleurs différentes.
Quelle différence majeur remarquez vous entre les 2 modèles d’illumination ?
2
V