Vertex Buffer Object

Les VBOs (de l'anglais Vertex Buffer Object dont une traduction pourrait être objet tampon de vertex) sont en OpenGL une méthode qui permet d'envoyer des données 3D (vertex, normales, maillage, couleurs, etc) vers la carte graphique. Cette méthode s'oppose au « mode immédiat » lequel est désormais désigné comme obsolète en OpenGL. Les VBOs ont été conçus afin d'obtenir les meilleures performances possibles et sont actuellement la méthode la plus efficace en OpenGL du fait que les données 3D ne résident plus dans la mémoire système mais dans la mémoire de la carte graphique ce qui permet un rendu plus rapide.

Prérequis

L'affichage d'images en 3D et en temps réel pour notamment les jeux vidéo requiert beaucoup de calculs qui doivent être effectués en un temps très court. Afin que cela soit rendu possible ces calculs pour être optimisés ne sont pas réalisés par le processeur de l'ordinateur mais par la carte graphique qui est équipée d'unités de calcul spécialisés à cette fin. Une scène 3D étant souvent constituée d'énormément d'éléments, la gestion de la mémoire requise à leur affichage représente un point capital pour les performances et c'est là que les VBOs entrent en jeu.

Historique

Avant l'adoption des VBOs des méthodes pour optimiser l'affichage étaient les « Display List » et les « VertexArray ». Les « Display List » permettent un stockage des données sur la carte graphique mais ne permettent pas de mettre à jour ces données. Les « VertexArray » conservent les données dans des tampons en mémoire système ce qui permet de les modifier mais oblige à transférer toutes ces données à chaque fois qu'elles doivent être affichées.

Pour répondre à ces problèmes les fabricants de cartes graphiques Nvidia et ATI développèrent les extensions NV_vertex_array_range [1] et ATI_vertex_array_object [2] qui furent regroupées et normalisées par l'ARB (Architecture Review Board) pour donner les "Vertex Buffer Object" (VBO, extension ARB_vertex_buffer_object) qui furent inclus dans la version d'OpenGL 1.4.

Interface

Voici les fonctions permettant de manipuler les VBOs :

glGenBuffers(sizei n, uint *buffers)

génère un identifiant pour un nouveau VBO. Retourne un entier non signé avec 0 comme valeur réservée.

glBindBuffer(enum target, uint buffer)

Indique quel VBO doit être considéré comme actif pour les opérations sur les VBOs.

glBufferData(enum target, sizeiptr size, const void *data, enum usage)

Envoie les données vers la carte graphique qui seront associées avec le VBO actif[3].

glDeleteBuffers(sizei n, const uint *buffers)

Détruit/libère un ou des VBO(s) lorsqu'on ne désire plus les utiliser.

Exemple en C

 
  /* Déclare une variable qui contiendra un identifiant pour un VBO */
  unsigned int id;

  /* 3 vertex définissant un triangle (dans le sens des aiguilles d’une montre) */
  float data[] = {
     1.0, 0.0,  1.0,
     0.0, 0.0, -1.0,
    -1.0, 0.0,  1.0
  };

  /* Crée un nouvel identifiant pour un VBO */
  glGenBuffers(1, &id);

  /* Active le nouveau VBO */
  glBindBuffer(GL_ARRAY_BUFFER, id);

  /* Envoie les données du triangle vers la carte graphique */
  glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);

Références
  1. (en) « GL_NV_vertex_array_range »
  2. (en) « ATI_vertex_array_object »
  3. http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml

Liens externes
  • Portail de l’informatique
Cet article est issu de Wikipedia. Le texte est sous licence Creative Commons - Attribution - Partage dans les Mêmes. Des conditions supplémentaires peuvent s'appliquer aux fichiers multimédias.