forma eficaz de dibujo en OpenGL ES

Question

En mi solicitud me dibuja una gran cantidad de cubos a través de OpenGL ES Api. Todos los cubos son de las mismas dimensiones, sólo ellos están situados en diferentes coordenadas en el espacio. Se me ocurren dos maneras de dibujar, pero no estoy seguro de que es el más eficiente. No soy experto OpenGL, así que decidí pedir aquí.

Método 1, que es lo que uso ahora: Puesto que todos los cubos son de dimensiones idénticas, calculo vértice tampón, tampón índice, tampón normal y de color amortiguar sólo una vez. Durante una actualización de la escena, yo voy todos los cubos, hago bufferData () para el mismo conjunto de buffers y luego dibujar el triángulo malla del cubo usando drawElements () llamada. Dado que cada cubo se encuentra en una posición diferente, traduzco la mvMatrix antes de que dibujo. bufferData () y drawElements () se ejecuta para cada cubo. En este método, probablemente guardar una gran cantidad de memoria, al no calcular los amortiguadores cada vez. Pero estoy haciendo mucho drawElements () llamadas.

Método 2 sería: tratar a todos los cubos como conjunto de polígonos extendido por todo el escenario. Calcular vértice, índice, color, tampones normales para cada polígono (triángulos en realidad dentro de los polígonos) y los empujan a memoria de tarjeta gráfica en sola llamada a bufferData (). A continuación, dibuje con una sola llamada a drawElements (). La ventaja de este enfoque es, lo hago sólo una bindBuffer y drawElements llamada. La desventaja es, utilizo gran cantidad de memoria para crear las memorias intermedias.

Mi experiencia con OpenGL es bastante limitado, no sabe cuál de los métodos anteriores es mejor desde el punto de vista del rendimiento.

Estoy usando esto en una aplicación WebGL, pero es una pregunta genérica de OpenGL ES.

Answer 1

He implementado el método 2 y se gana por un deslizamiento de tierra. La supuesta desventaja de alta cantidad de memoria parecía ser sólo mi imaginación. De hecho, el recolector de basura quedó invocada en el método 2 solamente una vez, mientras que fue invocada por 4-5 veces en el método 1.

Su escenario OpenGL podría ser diferente de la mía, pero si has llegado aquí en busca de sugerencias sobre el rendimiento, la lección de esta pregunta es: Identificar las partes de la escena que no cambian con frecuencia. No importa lo grandes que son, los puso en un único conjunto amortiguador (OISCIV) y carga a un número mínimo de memoria de gráficos de veces. Así es como se supone OISCIV para ser utilizado. El ancho de banda de memoria entre el cliente (es decir, su aplicación) y la tarjeta gráfica es preciosa y no desea consumir a menudo sin razón.

Leer la sección "Vertex Buffer Objects" en el cap. 6 de "OpenGL ES 2.0 Guía de Programación" para entender cómo se supone que se utilizará. http://opengles-book.com/

Answer 2

Sé que esta pregunta ya está contestada, pero creo que vale la pena señalar la presentación de Google IO sobre WebGL optimización:

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

Se refieren, en esencia, esto exactamente el mismo problema (mucho de formas idénticas con diferentes colores / posiciones) y hablar de algunas grandes maneras de optimizar una escena (y la de ellos es dinámico también!)

Answer 3

Propongo siguiente enfoque:

En la carga:

1. Generar buffer de coordenadas (por un cubo) y cargarlo en VBO (gl.glGenBuffers, gl.glBindBuffer)

El sorteo:

1. Enlazar tampón (gl.glBindBuffer)

2. Dibujar cada celda (circular)

   2,1. Mover la posición actual al centro del cubo actual (gl.glTranslatef(position.x, position.y, position.z)

   2,2. Dibujar cubo actual (gl.glDrawArrays)

   2.3. Mover la posición hacia atrás (gl.glTranslatef(-position.x, -position.y, -position.z))