Efficiente modo di disegnare OpenGL ES

Question

Nella mia applicazione ho disegnato un sacco di cubi attraverso OpenGL ES Api.Tutti i cubi sono delle stesse dimensioni, solo che si trovano a diverse coordinate nello spazio.Posso pensare a due modi di disegno, ma non sono sicuro di quale è il più efficiente.Io non sono OpenGL esperto, così ho deciso di chiedere qui.

Il metodo 1, che è quello che uso ora:Dal momento che tutti i cubi sono di dimensioni identiche, calcola il vertex buffer, indice del buffer, buffer normale e di colore buffer solo una volta.Durante un aggiornamento di scena, andare oltre tutti i cubi, fare bufferData() per lo stesso set di buffer e quindi disegnare il triangolo maglia del cubo utilizzando drawElements() chiamata.Dal momento che ogni cubo è in posizione diversa, traduco il mvMatrix prima di disegnare.bufferData() e drawElements() viene eseguita per ogni cubo.In questo metodo, probabilmente risparmiare un sacco di memoria, da non calcolare il buffer di ogni tempo.Ma sto facendo molta drawElements() chiama.

Metodo 2 sarebbe:Il trattamento di tutti i cubi come insieme di poligoni diffuse in tutta la scena.Calcolare vertice, indice, colore, normale buffer per ogni poligono (in realtà triangoli all'interno di poligoni) e li spingono a memoria della scheda grafica in unica convocazione, per bufferData().Quindi disegnare con singola chiamata a drawElements().Il vantaggio di questo approccio è, faccio solo una bindBuffer e drawElements chiamata.Il rovescio della medaglia è, io uso il sacco di memoria per creare il buffer.

La mia esperienza con OpenGL è abbastanza limitato, per non sapere che uno dei metodi di cui sopra è meglio dal punto di vista del rendimento.

Sto usando questo in un WebGL app, ma è un generico OpenGL ES questione.

Answer 1

Ho implementato il metodo 2 e vince da una frana.Il presunto svantaggio di elevate quantità di memoria sembrava essere solo la mia immaginazione.Infatti il garbage collector ha invocato il metodo 2 solo una volta, mentre era invocato per 4-5 volte nel metodo 1.

OpenGL scenario potrebbe essere diverso dal mio, ma se siete arrivati qui in cerca di consigli sulle prestazioni, la lezione di questa domanda è:Identificare le parti della scena che non cambiano molto frequentemente.Non importa quanto siano grandi, metterli in singolo set di buffer (VBOs) e il caricamento in memoria grafica numero minimo di volte.Ecco come VBOs sono destinati ad essere utilizzati.La larghezza di banda della memoria tra client (es.la tua app) e la scheda grafica è prezioso e non vuoi consumare spesso senza motivo.

Leggere la sezione "Vertex Buffer Objects" in Cat.6 di OpenGL ES 2.0 Manuale di Programmazione", per comprendere come si sono supposti per essere utilizzato. http://opengles-book.com/

Answer 2

So che questa domanda è già una risposta, ma penso che la pena sottolineare la presentazione di Google IO di ottimizzazione WebGL:

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

Essi coprono, in sostanza, questo esattamente lo stesso problema (il lotto di forme identiche con diversi colori / posizioni) e parlare di alcuni modi per ottimizzare una scena (e la loro dinamica è troppo!)

Answer 3

Propongo seguente approccio:

In carico:

1. Genera coordinate tampone (per un cubo) e caricarlo nella VBO (gl.glGenBuffers, gl.glBindBuffer)

In pareggio:

1. Bind tampone (gl.glBindBuffer)

2. Draw ogni cella (anello)

   2.1. Spostare posizione corrente al centro del cubo corrente (gl.glTranslatef(position.x, position.y, position.z)

   2.2. Disegnare cubo corrente (gl.glDrawArrays)

   2.3. posizione di movimento di nuovo (gl.glTranslatef(-position.x, -position.y, -position.z))