Dessiner des objets géométriques

Pour rappel, les primitives supportées sous OpenGL sont les points, lignes, polygones, triangles, ...

Pour dessiner ces primitives, vous utilisiez glVertex, glColor, glNormal ou glTexCoord entre glBegin et glEnd.

Ces fonctions sont encore appelées des fonctions immédiates. L'avantage étant de pouvez manipuler rapidement et donc de comprendre rapidement comment fonctionne OpenGL. Mais la multiplication des appels pour dessiner un objet graphique en 3D ne permet pas vraiment une optimisation des traitements.

C'est fonctions immédiates sont même carrément rendues indisponibles à partir d'OpenGL 3.x dans le profil "core". Il faut donc les remplacer par celles qui vont suivrent. Cela ne va pas simplifier la tâche à ceux voulant apprendre OpenGL...

OpenGL 2.0

Une solution est apparu dans OpenGL 2.0 qui permettait de transmettre un tableau de vertice (glVertexPointer) et les informations associées (glTexCoordPointer, glNormalPointer, glColorPointer). L'avantage:une instruction pour passer l'ensemble des informations.

Mais une autre solution est préférée: glVertexAttribPointer.

OpenGL 3.0

Vous devez passer par glVertexAttribPointer.

C'est donc cette solution que je vais expliquer maintenant.

Buffer object

Une nouvelle solution consiste à utiliser un buffer object et de transmettre les vertice dans ce buffer. Ce buffer object est une zone mémoire ou tampon que vous réservez directement dans la mémoire de la carte graphique. Vous en faîtes ensuite ce que vous voulez. L'avatange: vous ne transférez l'information qu'une fois à la carte graphique, vous pouvez donc supprimer ces informations de la mémoire côté CPU (en laissant le carbage collector oeuvrer pour vous). D'où un gain de temps dans les traitements.

L'allocation mémoire est très basique: Allocation et libération de la mémoire allouée. Ne compter donc pas modifier la taille du bloc mémoire. Il faudra supprimer ce bloc puis le recréer.

VBO

La solution qui est préconisée consiste à passer une fois pour toute, dans la mémoire de la carte graphique, les coordonnées des vertice mais aussi leur couleurs, texels, ... et autres qui seront traités plus tard.

Restons en aux coordonnées des vertice pour le moment.

Les cartes graphiques ont donc de la mémoire (si si !). Pour pouvoir transférer les informations de vertice, il faudra d'abord se réserver de la mémoire appelée buffer object. N'ayant pas accès directement à ces buffers objects (le programme tourne côté client càd CPU de votre machine, le buffer est sur la carte graphique côté GPU donc), il faudra passer par des noms ou identifiants de buffers:

void glGenBuffers(GLsizei n, GLuint * buffers);

En entrée:

GLsizei pour indiquer le nombre d'identifiant de buffer object à générer.

buffers: tableau qui va contenir les différents identifiants générés.

En sortie:

GL_INVALID_VALUE si n est < 0

Les identifiants des buffers étant connus, il sera possible de réserver une zone mémoire et d'alimenter ceux-ci avec les données que vous voulez:

Pour cela, il faut indiquez sur quel buffer vous voulez travailler grâce à la maintenant traditionnelle commande bind mais pour les buffers:

void glBindBuffer(GLenum target, GLuint buffer);

En entrée:

target indique le type de cible souhaité pour le buffer: GL_ARRAY_BUFFER.
buffer est le nom/identifiant du buffer objet.

Il reste à demander le transfert des données vers la carte graphique:

void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);

En entrée:

target est toujours la cible pour laquelle le buffer sera utilisée donc toujours GL_ARRAY_BUFFER ici.

size est la taille en octet qui sera occupée en mémoire graphique

data buffer contenant les données (côté client donc là où il y a le CPU / votre code C++) ou null si vous ne voulez pas transmettre de data

usage GL_STATIC_DRAW car le contenu de la mémoire graphique ne va pas évoluer ensuite.

Des erreurs peuvent remonter:

GL_INVALID_ENUM si target n'est pas valide ou si usage n'est pas une valeur suivante:

GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY,
GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY,
GL_DYNAMIC_DRAW, GL_DYNAMIC_READ ou GL_DYNAMIC_COPY.

GL_INVALID_VALUE si size est négatif

GL_INVALID_OPERATION si utilisation du buffer particulier dont l'identifiant/nom est 0

GL_OUT_OF_MEMORY Pas suffisement de mémoire.

Enfin indiquez que vous n'allez plus utiliser dans l'immédiat la ressource buffer. Pour cela, il suffit d'indiquer un nom/identifiant particulier: le 0.

void glBindBuffer(GLenum target, 0);

A mettre impérativement, sinon vous allez avoir des surprises (désagréables) !

Ensuite, tout se passe lors de la phase du rendu de l'image

Il faut refaire un bind sur le buffer

glBindBuffer(GL_ARRAY_BUFFER, bufferId);

Puis indiquer à OpenGL comment est construit le buffer pour pouvoir alimenter correctement vPosition dans le vertex shader.

void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);

void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);

En entrée

index correspond à l'index de l'attribut du vertex shader qui recevra ici les positions des vertice
size Le nombre de composants (ici 3 ou 4 par coordonnées)

type: A priori, vous utiliserez du float, donc GL_FLOAT

normalized: laissons le à false pour le moment...

stride: un pas, à calculer en octet ! Permet à OpenGL de connaitre le déplacement à faire pour trouver les positions du vertice suivant.

pointer A voir plutôt comme un offset: le point de départ dans le buffer. A priori 0 si les coordonnées sont au début du buffer.

Vous commencez à voir que les coordonnées pourraient être suivies d'autres informations grace au stride et à l'offset...

Oui, les coordonnées peuvent être composées de 3 voire 4 éléments (4 coordonnées).

Des codes erreurs éventuelles:

GL_INVALID_VALUE si l'index est supérieur ou égal à GL_MAX_VERTEX_ATTRIBS, si size n'est pas une valeur parmis 1, 2, 3, 4 or GL_BGRA. si le type est invalide ou enfin si stride est < 0

GL_INVALID_OPERATION :

• si size est GL_BGRA et type n'est pas positionné à GL_UNSIGNED_BYTE, GL_INT_2_10_10_10_REV ou GL_UNSIGNED_INT_2_10_10_10_REV.
• si type est GL_INT_2_10_10_10_REV ou GL_UNSIGNED_INT_2_10_10_10_REV et que size n'est pas égal à 4 ou GL_BGRA.
• si size est positionné à GL_BGRA et noramlized vaut GL_FALSE.
• si le bind GL_ARRAY_BUFFER est sur un id null et que le pointeur n'est pas NULL.

Effacer les buffer objects

Cette fonction permet d'effacer les buffer objects à partir de leur nom/identifiant:

void glDeleteBuffers( GLsizei n, const GLuint * buffers);

Cette fonction ignore l'identifiant 0 (réservé par le système) et tous ceux qui ne correspondent pas à des buffer objects.

En entrée:

n spécifie le nombre de buffer objects à supprimer

buffers est un tableau contenant les idenfiants des buffer objects à supprimer

En sortie, les buffer objects sont supprimés ou GL_INVALID_VALUE est généré si n est négatif.

Compléments

glIsBuffer permet d'indiquer qu'un nom/identifiant correspond à un buffer object

GLboolean glIsBuffer(GLuint buffer);

Exemple de code

Le main dont le role est d'initialiser OpenGL, de permettre le rendu et de créer une instance Triangle qui va dessiner une objet.

#include <cstring> #include <iostream> using namespace std; #define GL_GLEXT_PROTOTYPES 1 #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #include "Shader.h" #include "ProgramGLSL.h" #include "FactoryShader.h" #include "FactoryProgramGLSL.h" #include "Triangle.h" ProgramGLSL * prg; GLuint vertex_array_object; Triangle *triangle, *triangle1; void affichage (void) { cout << "Aff...."<<endl; /* glClearColor( 7.0f, 7.0f, 7.0f, 0.0f ); glClear( GL_COLOR_BUFFER_BIT);*/ const GLfloat color[] = { 0.0f, 0.0f, 0.0f, 1.0f}; glClearBufferfv(GL_COLOR, 0, color); glEnable (GL_VERTEX_PROGRAM_POINT_SIZE); glUseProgram(prg->getNumProgram()); cout << "Aff. triangle..."<<endl; triangle->draw(); triangle1->draw(); cout << "Fin Aff. triangle..."<<endl; glutSwapBuffers(); } main(int argc,char **argv) { /* initialisation de glut et création de la fenetre */ glutInit(&argc,argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE ); glutInitWindowPosition(100,200); glutInitWindowSize(800,600); glutCreateWindow("OpenGL"); glGenVertexArrays(1, &vertex_array_object); glBindVertexArray(vertex_array_object); glutDisplayFunc(affichage); cout < "Version:%s"<<glGetString (GL_VERSION); // Chargement du source char vertexSource[]="#version 130\n" "attribute vec4 aPosition;\n" "void main() {\n" " gl_Position = aPosition;\n [gl_VertexID];\n" " gl_PointSize = 40.0;\n" "}\n\0"; fragSource[]="#version 130\n" "precision mediump float;\n" "main() {\n" " gl_FragColor =vec4(1.0, 1.0, 1.0);\n" "}\n\0"; // puis transfert dans le shader cout<<"Vertex shader..."<<endl; Shader * sh =FactoryShader::vertexShaderUnSource(vertexSource); cout < "Erreur:"<<sh->getError(0)<<endl; if (sh->getError(0)!=0) { int taille=sh->getTailleError (); char * log=new char [taille]; sh->getError(log); cout<<"Log:"<<log<<endl; delete log; } cout<"Fragment shader..."<<endl; Shader * sh1 =FactoryShader::fragmentShaderUnSource(fragSource); cout < "Erreur:"<<sh1->getError(0)<<endl; if (sh1->getError(0)!=0) { int taille=sh1->getTailleError (); char * log=new char [taille]; sh1->getError(log); cout<<"Log:"<<log<<endl; delete log; } cout<"Compilation..."<<endl; Shader* tabsh[]={sh, sh1,0}; cout<"Génération Compilation..."<<endl; prg =FactoryProgramGLSL::genererProgramGLSL(tabsh); cout<"Après Génération Compilation..."<<endl; cout < "PRG="<<prg<<endl; if (prg->getError(0) != 0) { cout << "Erreur suite factory !" << endl; } // Création d'une instance Triangle triangle=new Triangle (prg); float triangleCoords[12] = { 0.0f, 0.5f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f }; triangle1=new Triangle (prg, triangleCoords); /* Entree dans la boucle principale glut pour gérer la fenêtre */ glutMainLoop(); return 0; }

D'où la classe Triangle (très basique et à compléter pour une meilleure gestions des erreurs):

La méthode la plus importante étant la méthode draw qui va transmettre à OpenGL la façon de construire le triangle qui passera par un VBO.

#define GL_GLEXT_PROTOTYPES 1 #include <GL/gl.h> #include <cstring> #include <iostream> #include "Triangle.h" using namespace std; Triangle::Triangle (ProgramGLSL *program) { initVariables(program); float constTriangleCoords[NB_VERTEX*NB_COORDS_PAR_VERTEX] = { 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f }; setTriangle (constTriangleCoords); } Triangle::Triangle (ProgramGLSL *program, float* newTriangleCoords) { initVariables(program); setTriangle (newTriangleCoords); } void Triangle::setTriangle (float* newTriangleCoords) { if (vboTriangle!=0) { delete vboTriangle; } // Chargement d'un triangle par défaut for (int i=0; i < NB_COORDS_PAR_VERTEX*NB_VERTEX; i++) { ((float*)triangleCoords)[i]=((float*)newTriangleCoords)[i]; } vboTriangle= new VBO(triangleCoords, NB_VERTEX); } void Triangle::initVariables(ProgramGLSL *program) { indexAPosition=0; prgGLSL=program; } void Triangle::draw() { cout << "draw..."<<endl; int mProgram=prgGLSL->getNumProgram(); // Indiquer les programmes shader à utiliser... glUseProgram(mProgram); // Création d'un attribut aPosition à l'index 0 glBindAttribLocation(mProgram, 0, "aPosition"); // Récupération de l'index, c'est juste pour l'exemple, puisqu'ici, il est déjà connu ! indexAPosition = glGetAttribLocation(mProgram, "aPosition"); vboTriangle->bindBuffer(); // Et précision sur la construction du buffer vboTriangle->initVertexAttribPointer (indexAPosition, 0); // Indiquer que l'attribut du shader va pointer sur un buffer VA glEnableVertexAttribArray(indexAPosition); // Ok, on peut dessiner maintenant ! glDrawArrays(GL_LINE_LOOP, 0, NB_VERTEX); vboTriangle->unBindBuffer(); // Disable de l'attribut du vertex array glDisableVertexAttribArray(indexAPosition); cout << "fin draw..." <<endl; } Triangle::~Triangle () { delete triangleCoords; }

et son .h

#ifndef TRIANGLE_H #define TRIANGLE_H #include "ProgramGLSL.h" #include "VBO.h" const int NB_VERTEX = 3; // 3 vertice pour un triangle ! const int NB_COORDS_PAR_VERTEX = 4; // 4 coordonnées par vertex const int BYTES_PER_FLOAT = sizeof(GL_FLOAT); // Un float occupe 4 octets class Triangle { public: // Un triangle Triangle (ProgramGLSL *program); Triangle (ProgramGLSL *program, float* newTriangleCoords); void setTriangle (float* newTriangleCoords); void draw(); ~Triangle(); protected: float *triangleCoords=new float[NB_VERTEX*NB_COORDS_PAR_VERTEX]; int indexAPosition; // Index de l'attribur aPosition VBO* vboTriangle=0; ProgramGLSL *prgGLSL; void initVariables(ProgramGLSL *program); }; #endif

La classe Triangle utilise donc un VBO dont voici une classe pour le gérer:

• L'allocation dans le constructeur
• Une méthode bind et unbind
• Une méthode initVertexAttribPointer
• Et de quoi libérer la mémoire sur la carte.

#include <iostream> #include "VBO.h" using namespace std; /** * VBO Fonctionnant avec des coordonnées homogènes et 4 composantes par couleur * * @author supertos * */ /** * Constructeur VBO qui attend un tableau de vertice composé de la manière suivante: * coordonnées homogènes (donc 4 coorodonnées: x,y,z et w) suivies des 4 composantes d'une couleur * soit: Rouge, vert, bleu et alpha pour chacun des vertice * * @param verticeCoords */ VBO::VBO(float *verticeCoords, int nbVertice) { // cout<<"VBO:Construction en cours..."<<endl; this->nbVertice=nbVertice; this->verticeCoords = verticeCoords; // Génération d'un nom/identifiant de buffer glGenBuffers(1, &bufferId); // Maintenant, nous voulons travailler sur ce buffer glBindBuffer(GL_ARRAY_BUFFER, bufferId); // Ok, on peut transférer les informations glBufferData(GL_ARRAY_BUFFER, nbVertice*VBO_NB_COORDS_PAR_VERTEX*sizeof(float), (const GLvoid*)verticeCoords, GL_STATIC_DRAW); // Fini de travailler avec ce buffer ! glBindBuffer(GL_ARRAY_BUFFER, 0); // cout<<"VBO:Fin Construction..."<<endl; } /** * Effectuer une bind sur le buffer object */ void VBO::bindBuffer() { if (glIsBuffer(bufferId)) { glBindBuffer(GL_ARRAY_BUFFER, bufferId); } else { cout<"VBO:BindBuffer impossible, buffer invalide !"<<endl; } } /** * Initilisation des attributs du vertex shader avec les informations sur la structure du VBO * * @param indexPosition attribut position * @param indexCouleur attribut couleur */ void VBO::initVertexAttribPointer (int indexPosition, int indexCouleur) { // cout<"Passage des informations vertice"<<endl; if (!glIsBuffer(bufferId)) { cout<"VBO:ATTENTION: initialisation attributs du vertex shader sans Buffer Object valide !"<<endl; } glVertexAttribPointer(indexPosition, // Index de l'attribut VBO_NB_COORDS_PAR_VERTEX, // 4 informations par vertex GL_FLOAT, // De type float false, (VBO_NB_COORDS_PAR_VERTEX /* + NB_COORDS_PAR_COULEUR*/ ) * VBO_BYTES_PER_FLOAT, // La taille des informations en byte par un vertex est donc 4 * taille d'un float * le nombre d'information 0); // L'index de départ est 0 soit le début du tableau // cout<"Passage des informations vertice terminé"<<endl; } /** * Arrêter l'utilisation du buffer object */ void VBO::unBindBuffer() { glBindBuffer(GL_ARRAY_BUFFER, 0); } /** * Libération des buffer objects */ void VBO::freeBuffer() { // Si le buffer existe, on peut le virer. if (glIsBuffer(bufferId)) { glDeleteBuffers (1,&bufferId); } else { cout<"VBO:delete buffer object impossible, buffer invalide !"; } } VBO::~VBO () { freeBuffer(); }

Et son include

#ifndef VBO_H #define VBO_H #define GL_GLEXT_PROTOTYPES 1 #include <GL/gl.h> const int VBO_NB_COORDS_PAR_VERTEX = 4; // 4 coordonnées par vertex const int VBO_NB_COORDS_PAR_COULEUR = 4; // 4 couleurs par vertex const int VBO_BYTES_PER_FLOAT = sizeof(float); // Un float occupe 4 octets class VBO { public: // Un VBO VBO(float *verticeCoords, int nbVertice); void bindBuffer(); void initVertexAttribPointer (int indexPosition, int indexCouleur); void unBindBuffer(); void freeBuffer(); ~VBO(); protected: private: float *verticeCoords; float nbVertice; GLuint bufferId; }; #endif

Puis un zip contenant les codes déjà vus pour gérer les shaders et un fichier makefile.

Il suffit de taper make all pour compiler et linker le tout.