¿Cuál es el punto de una textura SDL2?

7 minutos de lectura

Qix - Avatar de usuario de MONICA FUE MALTRATADA
Qix – MONICA FUE MALTRATADA

Estoy un poco atascado en la lógica detrás de una textura SDL2. Para mí, no tienen sentido ya que no puedes dibujar hacia ellos.

En mi programa tengo varias superficies (o lo que Somos superficies antes de cambiar a SDL2) que acabo de juntar para formar capas. Ahora, al parecer, tengo que crear varios renderizadores y texturas para crear el mismo efecto ya que SDL_RenderCopy toma un puntero de textura.

No solamente eso, pero todos los renderizadores tienen que venir desde una ventana, lo cual entiendo, pero aún me confunde un poco más.

Todo esto parece extremadamente voluminoso y lento. ¿Me estoy perdiendo de algo? ¿Hay alguna manera de dibujar directamente en una textura? ¿Cuál es el punto de las texturas, y estoy seguro de tener múltiples (si no cientos) de renderizadores en lugar de lo que eran superficies?

  • La forma en que cambió la arquitectura de SDL cuando introdujeron 2.0 me obliga a usar SFML. Simplemente no puedo lidiar con la reestructuración de todo mi programa debido a su cambio de API; básicamente, no hay una representación fuera de pantalla como la que admite SFML.

    – Qix – MONICA FUE MALTRATADA

    20 de septiembre de 2012 a las 7:30

  • SDL2 se encuentra en un estado previo al lanzamiento. No es exactamente justo juzgarlo todavía. A pesar de ser un WIP, el desarrollador ha tenido la amabilidad de dejarnos jugar con él a medida que avanza, eso es todo.

    usuario1727324

    7 oct 2012 a las 21:25


  • @ Di-0xide La antigua wiki todavía está disponible. libsdl.org/cgi/docwiki.cgi

    – Wes

    14 de noviembre de 2012 a las 11:26


  • Mirando hacia atrás en esto 3 años después, no entendía qué gráficos textura realmente lo era Para aquellos de ustedes que todavía votan a favor, recuerden que las texturas no son necesariamente piezas de imágenes o gráficos; son realmente cualquier dato enviado a la tarjeta.

    – Qix – MONICA FUE MALTRATADA

    1 de julio de 2015 a las 3:28


  • Otros tres años después y un respuesta que escribí para un Reddit ELI5 tiene un poco de sentido vincular. Es una explicación muy básica de cómo funcionan las canalizaciones de gráficos y toca una teoría básica. Buen punto de partida si alguien que encuentra esto es completamente nuevo en el tema.

    – Qix – MONICA FUE MALTRATADA

    21 de septiembre de 2018 a las 8:31


avatar de usuario de diegoperini
diegoperini

SDL_Texture los objetos se almacenan lo más cerca posible de la memoria de la tarjeta de video y, por lo tanto, su GPU puede acelerarlos fácilmente. El cambio de tamaño, la combinación alfa, el suavizado y casi cualquier operación de cómputo pesado pueden verse gravemente afectadas por este aumento de rendimiento. Si su programa necesita ejecutar una lógica por píxel en sus texturas, le animamos a convertir sus texturas en superficies temporalmente. También es posible lograr una solución con texturas de transmisión.

Editar: Dado que esta respuesta recibe bastante atención, me gustaría elaborar mi sugerencia.

Si prefieres usar Texture -> Surface -> Texture flujo de trabajo para aplicar su operación por píxel, asegúrese de almacenar en caché su textura final a menos que necesite volver a calcularla en cada ciclo de renderizado. Las texturas en esta solución se crean con SDL_TEXTUREACCESS_STATIC bandera.

Streaming de texturas (la bandera de creación es SDL_TEXTUREACCESS_STREAMING) se recomiendan para casos de uso en los que la fuente de los datos de píxeles es una red, un dispositivo, un servidor de marcos o alguna otra fuente que está más allá del alcance total de las aplicaciones de SDL y cuando es evidente que el almacenamiento en caché de los marcos de la fuente es ineficiente o no funcionaría.

Es posible renderizar sobre texturas si se crean con SDL_TEXTUREACCESS_TARGET bandera. Esto limita la fuente de la operación de dibujo a otras texturas, aunque esto podría ser lo que necesitaba en primer lugar. “Texturas como objetivos de renderizado” es una de las características más nuevas y menos compatibles de SDL2.

Información nerd para lectores curiosos:

Debido a la naturaleza de la implementación de SDL, los primeros dos métodos dependen de las operaciones de lectura y copia a nivel de aplicación, aunque están optimizados para escenarios sugeridos y lo suficientemente rápidos para aplicaciones en tiempo real.

La copia de datos desde el nivel de la aplicación casi siempre es lenta en comparación con el posprocesamiento en la GPU. Si sus requisitos son más estrictos de lo que puede proporcionar SDL y su lógica no depende de una fuente de datos de píxeles externos, sería sensato asignar texturas OpenGL sin procesar pintadas a partir de sus superficies SDL y aplicarlas. sombreadores (lógica GPU) para ellos.

Los sombreadores están escritos en GLSL, un lenguaje que se compila en el ensamblaje de la GPU. Aceleración de hardware/GPU en realidad se refiere al código paralelizado en los núcleos de GPU y el uso de sombreadores es la forma preferida de lograrlo con fines de renderizado.

¡Atención! El uso de texturas y sombreadores sin procesar de OpenGL junto con las funciones y estructuras de renderizado de SDL puede causar algunos conflictos inesperados o la pérdida de flexibilidad proporcionada por la biblioteca.

TLDR;

Es más rápido renderizar y operar sobre texturas que sobre superficies, aunque modificarlas a veces puede resultar engorroso.

  • Qué es esto streaming texture?

    – anatoly techtonik

    12 de enero de 2014 a las 7:03

  • “Las texturas estáticas están diseñadas para sprites y fondos y otras imágenes que no cambian mucho… …Las texturas de transmisión están diseñadas para cosas que se actualizan con frecuencia, cada pocos segundos o cada cuadro”. citado de slouken.blogspot.com/2011/02/… Técnicamente, son datos de píxeles mutables que están sujetos a modificaciones entre cada renderizado, por lo que requieren un cuidado especial para evitar tartamudeos debido al acceso pesado a sus búferes.

    – diegoperini

    14/01/2014 a las 22:32


  • ¿Cuál es la lógica detrás texture > surface > texture? Por qué no surface > texture cada cuadro?

    – Hola Mundo

    08/03/2015 a las 20:58


  • Inmediatamente después del primer bucle de renderizado, muchos materiales se almacenarían en caché como texturas. Aplicarles pequeñas modificaciones (como alterar algunas partes rectangulares más pequeñas) se beneficiaría de ese flujo.

    – diegoperini

    1 de abril de 2015 a las 7:50

Mediante la creación de una textura SDL2 como tipo STREAMING, se puede bloquear y desbloquear toda la textura o solo un área de píxeles para realizar operaciones directas de píxeles. Uno debe crear previamente una superficie SDL2 y vincular con bloqueo y desbloqueo de la siguiente manera:

SDL_Surface surface = SDL_CreateSurface(..);
SDL_LockTexture(texture, &rect, &surface->pixels, &surface->pitch);
// paint into surface pixels
SDL_UnlockTexture(texture);

La clave es que, si dibuja una textura de mayor tamaño y el dibujo es incremental (por ejemplo, un gráfico de datos en tiempo real), asegúrese de bloquear y desbloquear solo el área real para actualizar. De lo contrario, las operaciones serán lentas, con mucha copia de memoria.

He experimentado un rendimiento razonable y el modelo de uso no es demasiado difícil de entender.

  • Crear una superficie primero no es necesario y posiblemente no sea deseable. SDL_LockTexture() obtiene los píxeles y el tono de la textura, escribiéndolos en las direcciones proporcionadas, que no tienen por qué (y posiblemente no deberían) ser parte de ninguna superficie. Dicho paint into surface pixels no tiene sentido: lo que realmente hace aquí es sobrescribir la superficie *pixels y pitch miembros con los de la textura, luego actualice los píxeles de la textura, no de la superficie, a través de ese puntero. Esto podría funcionar en algunos casos, y presumiblemente funcionó en el tuyo, pero no parece necesario ni una buena idea.

    – subrayado_d

    23 de julio de 2016 a las 19:16


En SDL2 es posible renderizar fuera de pantalla / renderizar directamente a una textura. La función a utilizar es:

int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture);

Esto solo funciona si el renderizador habilita SDL_RENDERER_TARGETTEXTURE.

  • ¿Alguien sabe qué tan ampliamente soportado es SDL_RENDERER_TARGETTEXTURE?

    – Vórtice

    27 de diciembre de 2013 a las 11:54

  • Parece que solo puedes pasar SDL_RENDERER_TARGETTEXTURE a SDL_CreateRendererconsulte stackoverflow.com/q/38813605

    – Jakub Klinkovský

    12 dic 2018 a las 21:57

¿Ha sido útil esta solución?