texturas - texture mapping opengl

El mejor método para copiar la textura a la textura

Question

¿Cuál es el mejor método para copiar píxeles de textura a textura?

He encontrado algunas formas de lograr esto. Por ejemplo, hay un método glCopyImageSubData() pero mi versión de destino es OpenGL 2.1, así que no puedo usarlo. Además, como el rendimiento es muy importante, glGetTexImage2D() no es una opción. Como manejo cuadros de video como textura, tengo que hacer copias entre 30 y 60 veces por segundo.

Las opciones disponibles que encontré son las siguientes:

1. cree fbo para la textura de origen y cópielo a la textura de destino usando glCopyTexSubImage2D ().
2. crea fbos para texturas de origen y destino y blit the fbos.
3. crea fbo para la textura de destino y renderiza la textura de origen a fbo.

Puede ignorar el costo de creación de fbo porque fbo se creará solo una vez.

Por favor, no publique algo como ''depende. haga su punto de referencia. ''. No estoy apuntando solo a una GPU. Si depende, por favor, hágamelo saber cómo depende de qué.

Además, dado que es muy difícil medir el tiempo de las llamadas OpenGL, lo que quiero saber no es un resultado cuantitativo. Necesito algunos consejos sobre qué método debo evitar.

Si conoce un método mejor para copiar texturas, hágamelo saber también.

Gracias por leer.

Answer 1

Como no conocía la consulta del temporizador, no pensé en la evaluación comparativa. Ahora puedo hacer mis propios puntos de referencia. He medido el tic para cada 100 operaciones y lo he repetido cinco veces. El costo para crear FBO no está incluido.

- S=source texture, D=destination texture, SF=FBO of S, DF=FBO of D
- operation=copying texture to texture
- op/s = how many operations for one second(average), larger is better

1. Crear DF ​​y renderizar S a DF usando sombreador de paso simple

   • 945.656op / s (105.747ms para 100 operaciones)
   • 947.293op / s (105.564ms para 100 operaciones)
   • 949.099op / s (105.363ms para 100 operaciones)
   • 949.324op / s (105.338ms para 100 operaciones)
   • 948.215op / s (105.461ms para 100 operaciones)

2. Crea SF y usa glCopyTexSubImage2D () para D

   • 937.263op / s (106.694ms para 100 operaciones)
   • 940.941op / s (106.277ms para 100 operaciones)
   • 941.722op / s (106.188ms para 100 operaciones)
   • 941.145op / s (106.254ms para 100 operaciones)
   • 940.997op / s (106.270ms para 100 operaciones)

3. Crear DF ​​y SF y usar glBlitFramebuffer ()

   • 828.172op / s (120.748ms para 100 operaciones)
   • 843.612op / s (118.538ms para 100 operaciones)
   • 845.377op / s (118.290ms para 100 operaciones)
   • 847.024op / s (118.060ms para 100 operaciones)
   • 843.303op / s (118.581ms para 100 operaciones)

4. Crear DF ​​y SF y usar glCopyPixels ()

   • 525.711op / s (190.219ms para 100 operaciones)
   • 523.396op / s (191.060ms para 100 operaciones)
   • 537.605op / s (186.010ms para 100 operaciones)
   • 538.560op / s (185.680ms para 100 operaciones)
   • 553.059op / s (180.813ms para 100 operaciones)

Comparación de rendimiento

passthrough shader ~ glCopyTexSubImage2D > glBlitFramebuffer >> glCopyPixels

Por lo tanto, el sombreado de paso simple muestra el mejor rendimiento para copiar texturas. glCopyTexSubImage2D es ligeramente más lento que el sombreado pasante. fbo-blitting es lo suficientemente rápido pero peor que shader y glCopyTexSubImage2D. glCopyPixels, de la que no esperaba buenos resultados, muestra el peor rendimiento según mis expectativas.

Answer 2

Finalmente terminamos por convertir un quad en el objetivo; cuando se usan shaders mínimos, la precisión de baja precisión, etc. la diferencia de rendimiento entre los diferentes métodos que usan la GPU para hacer blit es leve, y este enfoque proporciona la mayor flexibilidad.

Sin embargo, si puede encontrar una forma de evitar las operaciones que solo copian por completo, si puede cambiar una operación que muta una de sus copias en una operación que lee el original, aplica la mutación y genera una copia nueva, todo en una sola vez, esa por supuesto será mucho más rápido.