Modalità di disegno efficiente in OpenGL ES

Question

Nella mia applicazione disegno un sacco di cubi tramite OpenGL ES Api. Tutti i cubi sono delle stesse dimensioni, solo che si trovano in diverse coordinate nello spazio. Posso pensare a due modi di disegnarli, ma non sono sicuro di quale sia il più efficiente. Non sono un esperto di OpenGL, quindi ho deciso di chiedere qui.

Metodo 1, che è quello che uso ora: Poiché tutti i cubi sono di dimensioni identiche, a calcolare vertex buffer, index buffer, tampone normale e buffer di colore sola volta. Durante un aggiornamento della scena, analizzo tutti i cubi, eseguo bufferData() per lo stesso set di buffer e quindi disegno la mesh triangolare del cubo usando la chiamata drawElements(). Poiché ogni cubo si trova in una posizione diversa, traduco la mvMatrix prima di disegnare. bufferData() e drawElements() viene eseguito per ogni cubo. Con questo metodo, probabilmente risparmio molta memoria, non calcolando i buffer ogni volta. Ma sto facendo molte chiamate a drawElements().

Metodo 2 sarebbe: trattare tutti i cubi come insieme di poligoni sparsi in tutto lo scena. Calcola vertici, indici, colori, buffer normali per ciascun poligono (in realtà triangoli all'interno dei poligoni) e trasferiscili nella memoria della scheda grafica nella singola chiamata a bufferData(). Quindi disegnali con una sola chiamata a drawElements(). Il vantaggio di questo approccio è che faccio una sola chiamata bindingBuffer e drawElements. Lo svantaggio è che uso molta memoria per creare i buffer.

La mia esperienza con OpenGL è abbastanza limitata, per non si sa quale uno dei metodi di cui sopra è meglio dal punto di vista delle prestazioni.

Sto usando questo in un'applicazione WebGL, ma è una generica domanda di OpenGL ES.

Answer 1

ho implementato il metodo 2 e vince da una frana. Il presunto svantaggio di un'alta quantità di memoria sembrava essere solo la mia immaginazione. Infatti il ​​garbage collector è stato invocato nel metodo 2 solo una volta, mentre è stato invocato per 4-5 volte nel metodo 1.

Lo scenario OpenGL potrebbe essere diverso dal mio, ma se si è arrivati ​​qui alla ricerca di suggerimenti sulle prestazioni, la lezione da questa domanda è: identifica le parti nella scena che non cambiano frequentemente. Non importa quanto siano grandi, mettili in un singolo buffer set (VBO) e caricali nella memoria grafica per un numero minimo di volte. Ecco come devono essere usati i VBO. La larghezza di banda della memoria tra il client (ad esempio la tua app) e la scheda grafica è preziosa e non vuoi consumarla spesso senza motivo.

Leggere la sezione "Oggetti del buffer di vertice" nel cap. 6 della "Guida alla programmazione OpenGL ES 2.0" per capire come dovrebbero essere usati. http://opengles-book.com/

Answer 2

propongo seguente approccio:

On carico:

1. generare coordinate tampone (per un cubo) e si carica in VBO (gl.glGenBuffers, gl.glBindBuffer)

On pareggio:

1. tampone Bind (gl.glBindBuffer)

2. Draw ciascuna cella (loop)

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

   2,2.Draw current cube (gl.glDrawArrays)

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

Answer 3

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

che coprono, in sostanza, , questo stesso identico problema (molti di forme identiche con diversi colori/posizioni) e parlare di alcuni ottimi modi per ottimizzare una scena del genere (e anche la loro è dinamica!)