moyen efficace de dessin dans OpenGL ES

Question

Dans ma demande, je dessine beaucoup de cubes par OpenGL ES Api. Tous les cubes sont de mêmes dimensions, seulement ils sont situés à différentes coordonnées dans l'espace. Je peux penser à deux façons de les dessiner, mais je ne suis pas sûr qui est le plus efficace un. Je ne suis pas expert OpenGL, alors j'ai décidé de demander ici.

Méthode 1, qui est ce que j'utilise maintenant: Comme tous les cubes sont de dimensions identiques, je calcule tampon vertex, tampon d'index, un tampon tampon normal et la couleur une seule fois. Au cours d'une actualisation de la scène, je vais sur tous les cubes, faire bufferData () pour un même ensemble de tampons, puis dessine le maillage triangulaire du cube en utilisant l'appel drawElements (). Étant donné que chaque cube est à une position différente, je traduis la mvMatrix avant que je dessine. bufferData () et drawElements () est exécuté pour chaque cube. Dans cette méthode, je sauve probablement beaucoup de mémoire, en ne calculant pas les tampons à chaque fois. Mais je fais des appels beaucoup de drawElements ().

Méthode 2 serait la suivante: Traiter tous les cubes comme un ensemble de polygones répartis sur tout la scène. Calculer le sommet, l'index, la couleur, des tampons normales pour chaque polygone (triangles en fait à l'intérieur des polygones) et les pousser vers la mémoire graphique d'une carte à appel unique à bufferData (). Puis les dessiner avec seul appel à drawElements (). L'avantage de cette approche est, je fais un seul appel bindBuffer et drawElements. L'inconvénient est, je l'utilise beaucoup de mémoire pour créer les tampons.

Mon expérience avec OpenGL est assez limitée, de ne pas savoir que l'une des méthodes ci-dessus est mieux du point de vue de la performance.

J'utilise ceci dans une application WebGL, mais il est une question OpenGL ES générique.

Answer 1

méthode que je 2 et mis en œuvre remporte une victoire écrasante. L'inconvénient supposé d'une grande quantité de mémoire semblait être que mon imagination. En fait, le garbage collector se est invoqué dans la méthode 2 qu'une seule fois, alors qu'il a été invoqué pour 4-5 fois dans la méthode 1.

Votre scénario OpenGL pourrait être différente de la mienne, mais si vous atteigniez ici à la recherche de conseils de performance, la leçon de cette question est la suivante: Identifier les parties de votre scène qui ne changent pas souvent. Peu importe la façon dont ils sont gros, les mettre dans un ensemble unique tampon (de VBOs) et le téléchargement à mémoire graphique nombre minimum de fois. C'est ainsi VBOs sont destinés à être utilisés. La bande passante de la mémoire entre le client (à savoir votre application) et la carte graphique est précieux et vous ne voulez pas consommer souvent sans raison.

Lire la section "Vertex Buffer Objects" au chap. 6 de « OpenGL ES 2.0 Guide de programmation » pour comprendre comment ils sont censés être utilisés. http://opengles-book.com/

Answer 2

Je sais que cette question est déjà répondu, mais je pense qu'il est intéressant de souligner la présentation IO Google sur l'optimisation WebGL:

http://www.youtube.com/watch?v=rfQ8rKGTVlg

Ils couvrent essentiellement ce exactement la même question (lot de formes identiques avec différentes couleurs / positions) et parler de quelques bonnes façons d'optimiser une telle scène (et leur est dynamique aussi!)

Answer 3

Je propose l'approche suivante:

En charge:

1. Générer tampon coordonnées (pour un cube) et le charger dans VBO (gl.glGenBuffers, gl.glBindBuffer)

Le tirage au sort:

1. Bind Buffer (gl.glBindBuffer)

2. Dessiner chaque cellule (boucle)

   2.1. Déplacer la position actuelle au centre du cube actuel (gl.glTranslatef(position.x, position.y, position.z)

   2.2. Dessiner cube en cours (gl.glDrawArrays)

   2.3. retour de position Move (gl.glTranslatef(-position.x, -position.y, -position.z))