Representación de mosaicos OpenGL: ¿la forma más eficiente?

Estoy creando un juego 2D basado en mosaicos como una forma de aprender conceptos básicos de OpenGL "modernos". Estoy usando sombreadores con OpenGL 2.1 y estoy familiarizado con la canalización de representación y cómo dibujar geometría en la pantalla. Lo que me pregunto es cuál es la mejor manera de organizar un mapa de mosaicos para que se represente de manera rápida y eficiente. He pensado en varios métodos posibles:

1.) Guarde el cuádruple que representa un solo mosaico (vértices y coordenadas de textura) en un VBO y renderice cada mosaico con un draw* llamada, traduciéndola a la posición correcta en pantalla y usando uniform2i para dar la ubicación en el atlas de texturas para ese mosaico en particular;

2.) Mantenga un VBO que contenga cada mosaico en pantalla (coordenadas de pantalla ya calculadas y coordenadas de atlas de textura), usando BufferSubData para actualizar los mosaicos en cada cuadro pero usando un solo draw* llamada;

3.) Mantenga los VBO que contengan "trozos" estáticos NxN de mosaicos, dibujando tantos pedazos de mosaicos que sean al menos parcialmente visibles en la pantalla y traduciéndolos cada uno a su posición.

* Me gustaría mantenerme alejado de la última opción si es posible, a menos que renderizar fragmentos de 64x64 no sea demasiado ineficiente. Los mosaicos se cargan en la memoria en bloques de ese tamaño, y aunque solo unos 20x40 mosaicos son visibles en la pantalla a la vez, tendría que renderizar hasta cuatro fragmentos a la vez. Este método también complicaría mi código de varias otras maneras.

Entonces, ¿cuál de estas es la forma más eficiente de renderizar una pantalla de mosaicos? ¿Existen mejores métodos?

preguntado el 29 de julio de 12 a las 04:07

2 Respuestas

Podrías hacer cualquiera de estos y probablemente estarían bien; lo que propones renderizar es muy, muy simple.

#1 definitivamente será peor en principio que las otras opciones, porque estaría dibujando muchos "modelos" extremadamente simples en lugar de dejar que la GPU haga una gran cantidad de trabajo por lotes en una llamada de dibujo. Sin embargo, si tienes , solamente 20 × 40 = 800 mosaicos visibles en la pantalla a la vez, entonces esta es una cantidad trivial de trabajo para cualquier CPU y GPU moderna (a menos que esté haciendo un sombreador de fragmentos loco).

Te recomiendo que elijas el que sea más fácil de programar para ti, para que puedas continuar trabajando en tu juego. Me imagino que este sería el #1, o posiblemente el #2. Siempre y cuando se encuentra con un problema de rendimiento, haga lo que sea entre el n.° 2 o el n.° 3 (64×64 suena como un tamaño de fragmento fino) le permite gastar la menor cantidad de tiempo de CPU en tu programaes parte del dibujo (es decir, actualizar el(los) búfer(es)).

Respondido 29 Jul 12, 06:07

Ok, después de investigar un poco más sobre "dosificación", creo que iré con el n. ° 2. ¡Gracias por la respuesta! - naelego

Recientemente he estado aprendiendo OpenGL moderno, a través de OpenGL ES 2.0 en Android. La Guía de programación de OpenGL ES 2.0 recomienda una "matriz de estructuras", es decir,

"Almacene los atributos de los vértices juntos en un solo búfer. La estructura representa todos los atributos de un vértice y tenemos una matriz de estos atributos por vértice".

Si bien esto puede parecer que inicialmente consumiría mucho espacio, permite una representación eficiente utilizando VBO y flexibilidad en el mapeo de texturas de cada mosaico. Recientemente hice una cuadrícula hexagonal en mosaico utilizando matrices intercaladas que contenían datos de vértices, normales, color y textura para una cuadrícula hexagonal de mosaico de 20x20 en un Droid 2. Hasta ahora, todo funciona sin problemas.

Respondido 29 Jul 12, 20:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.