• Introduction
• Utilisation
• Réduction de la taille en fonction de la distance
• Sprites
• Sources
• Exercice

Introduction

Les objets tampon offrent un gain de performance supplémentaire par rapport aux tableaux de sommets, puisqu'ils permettent de stocker les données au niveau du serveur OpenGL : sur la carte graphique.
Les objets tampon permettent de stocker des données de sommets et des tableaux d'indices, et d'y accéder à l'aide de l'interface des tableaux de sommets.
Depuis la version 2.1 d'OpenGL, ils permettent aussi de stocker des pixels.

Utilisation

Résumé

1. (Facultatif) Commencer par générer des identifiants d'objets tampon, avec glGenBuffers( sizei n, uint *buffers ).
2. Activer un objet tampon, et indiquer le type de données qu'il stocke, avec glBindBuffer( enum target, uint buffer ).
3. Allouer la mémoire pour les données, avec glBufferData( enum target, uint buffer ).
4. Spécifier les données des objets tampons : leur nature et leur décalage relatif au début de l'objet tampon
   Cela se fait par exemple avec glVertexPointer() et
glEnableClientState(GL_VERTEX_ARRAY) pour les coordonnées des sommets.
5. Activer l'objet tampon désiré pour le sélectionner pour la restitution, ou pour mettre à jour ses données
6. Si besoin, mettre à jour ses données, avec glBufferSubData() ou glMapBuffer().
7. L'afficher, en utilisant les fonctions des tableaux de sommets, comme glDrawElements() ou glDrawArrays().
8. Libérer les ressources et l'identificateur de l'objet tampon, avec glDeleteBuffers().

Remarques :
L'étape 1 est facultative puisqu'il est possible d'utiliser l'identifiant de son choix. La fonction glIsBuffer() permet de vérifier que l'identifiant n'est pas en cours d'utilisation.

Activation pour l'initialisation

glBindBuffer( GLEnum target, GLuint buffer ) indique que le Objet Tampon buffer sera concerné par les opérations futures. target peut prendre les valeurs GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER,
GL_PIXEL_UNPACK_BUFFER, ou GL_PIXEL_PACK_BUFFER.

Remarque :
Pour arrêter d'utiliser les Objets Tampon, appeler glBindBuffer(enum target, 0).

Allocation, et initialisation éventuelle

glBufferData( GLenum target, GLsizeiptr size, const void *data, GLenum usage) alloue la mémoire nécessaire sur le serveur OpenGL, et y transfert les données data. Si ce pointeur vaut NULL, les données seront copiées ultérieurement, de manière dynamique. usage peut prendre 9 valeurs, qui sont des indications de performance pour OpenGL.

Spécifier les données et les décalages relatifs au début de l'Objet Tampon

On appelle la fonction de spécification des données adéquate, comme glVertexPointer() ou glColorPointer(), en indiquant en dernier paramètre le décalage en octets par rapport au début des données.

Mise à jour des données

• Si des données de même type se trouvent dans un tampon de l'application, glBufferSubData(GLenum   target,   GLintptr   offset,   GLsizeiptr   size,   const GLvoid *   data ) remplace un sous-ensemble de données.
• La fonction glMapBuffer( GLenum   target,   GLenum   access) permet d'obtenir un pointeur sur la mémoire de l'objet tampon, à partir duquel écrire de nouvelles valeurs. Lorsque la mise à jour est terminée, appeler UnmapBuffer(GLenum target ).

Exemple

Préparation

    static GLfloat sommets[]={-.5, -.5,
			      .5, -.5,
			      .5, .5,
			      .25, .75,
			      -.5, .5};
    static GLfloat couleurs[]={1.0, 0.2, 0.2,
			       0.2, 0.2, 1.0,
			       0.8, 1.0, 0.2,
			       0.5, 1.0, 0.5,
			       0.8, 0.8, 0.8};
   static GLubyte indices[]={3, 4,
			     3, 0,
			     3, 1,
			     3, 2};

   static GLuint idSommets, idCouleurs, idIndices;
   
   //Génération des identifiants
   glGenBuffers(1, &idSommets);
   glGenBuffers(1, &idCouleurs);
   glGenBuffers(1, &idIndices);
   
   //Les coordonnées des sommets
   glBindBuffer(GL_ARRAY_BUFFER, idSommets);
   glBufferData(GL_ARRAY_BUFFER, sizeof(sommets), sommets, GL_STATIC_DRAW);
   glVertexPointer(2, GL_FLOAT, 0, 0);
   glEnableClientState(GL_VERTEX_ARRAY);

   //Les couleurs des sommets
   glBindBuffer(GL_ARRAY_BUFFER, idCouleurs);
   glBufferData(GL_ARRAY_BUFFER, sizeof(couleurs), couleurs, GL_STATIC_DRAW);
   glColorPointer(3, GL_FLOAT, 0, 0);
   glEnableClientState(GL_COLOR_ARRAY);
   
   //La liste des indices
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, idIndices);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

Affichage

      glDrawElements(GL_LINES, 8, GL_UNSIGNED_BYTE, 0);

Mise à jour des données

    GLfloat * data;
    glBindBuffer(GL_ARRAY_BUFFER, idSommets);
    data = (GLfloat*) glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
    if (data != (GLfloat*)NULL){
      for (int i=0 ; i<5 ; i++)
		data[2*i]+= .1; //Mise à jour des x
    }
    glUnmapBuffer(GL_ARRAY_BUFFER);

Exercice

Chargez et affichez l'objet Generic.ply qui est au format ply indiqué dans le chapitre sur les Tableaux de Sommets, et sélectionnez et déplacez les sommets à la souris.