Il n'existe pas de méthode préétablie pour améliorer les performances d'un programme tournant sous OpenGL ; tout dépend de ce que vous voulez lui faire faire exactement. Un moteur 3D destiné à rendre des scènes en intérieur s'orientera plutôt vers des optimisations du type portal + PVS, alors qu'un moteur créé pour rendre des extérieurs aura plutôt tendance à s'orienter vers des octrees/quadtrees.

Dans tout moteur 3D en général, la première optimisation n'est pas d'utiliser les commandes les plus rapides pour afficher, mais bien d'utiliser des algorithmes appropriés pour ce que l'on veut effectuer. Néanmoins d'un point de vue strictement OpenGL, il existe quelques « bonnes techniques » à utiliser pour ne pas se retrouver limité par des erreurs de programmation.

La règle de base est de savoir qu'OpenGL est une machine à états, c'est-à-dire que tout état activé à un instant T restera actif jusqu'au changement ou la désactivation de cet état. Ceci implique pour le programmeur de bien savoir quels états sont actifs à quel moment, afin d'utiliser le moins possible de fonctionnalités inutiles. Un bon exemple de ce qu'il ne faut pas faire est d'utiliser du blending en mode (SRC_ONE, DST_ZERO). En effet, quand cette fonction de blending est activée, elle n'a aucun effet visible sur le rendu (la scène est rendue exactement de la même manière que si le blending était désactivé), ce qui signifie que le pipeline OpenGL calcule une opération de blending, sans que cela ait une quelconque influence sur le rendu final. C'est du temps de calcul perdu.

Un autre type d'optimisation est d'utiliser les listes d'affichage (display lists) pour effectuer du batching de commandes OpenGL (voir qu'est-ce que le batching faq 3D). En effet, les listes d'affichage peuvent contenir presque tout type de commandes OpenGL (avec quelques limitations spécifiées dans le Red Book), ce qui permet en un seul appel de commande d'effectuer plusieurs opérations OpenGL.

Il existe de nombreux sites sur Internet parlant d'optimisation de code OpenGL, le plus documenté étant sûrement le site de nVidia section « développeurs », qui contient notamment un document décrivant les principales erreurs à éviter en OpenGL : Avoiding common OpenGL pitfalls.

Malheureusement la réponse n'est pas évidente, elle dépend de chaque type de moteur.

Basiquement, on peut trier les différentes méthodes comme ceci :

VBO compilé > VBO > vertex array compilé > display list > vertex array > glVertex

Mais malheureusement ceci dépend beaucoup du constructeur de la carte graphique, voire de la version des pilotes. De plus, une mauvaise utilisation d'une des méthodes peut faire perdre beaucoup en rapidité. Par exemple, compiler un vertex array à chaque frame est plus lent que d'utiliser un vertex array simple, car le driver fait une passe d'optimisation lors de la compilation, ce qui du coup fait perdre du temps. De même, utiliser une display list pour un objet très petit est une mauvaise idée, car l'appel à la display list a un coût important qui sera supérieur au coût d'affichage du même objet avec glVertex.

La seule chose qui soit à peu près sûre, c'est que la méthode la plus lente est l'utilisation de glVertex.

La première chose à faire, la plus banale et simple, est d'intégrer une mesure du temps de la fonction de rendu à votre application.

Certaines cartes graphiques possèdent des compteurs permettant de mieux connaître l'utilisation de la carte graphique. Vous pouvez notamment vous servir des fonctionnalités apportées par l'extension KHR_debug.

Des programmes plus poussés ont également été développés afin de tester les performances d'une application OpenGL :

• La page « Benchmarks » du site officiel d'OpenGL fournit une liste des benchs les plus utilisés ;
• apitrace.