c++ - sdl2 - ¿Qué es un procesador SDL?

sdl2 tutorial

Question

Estoy empezando con SDL2 y tengo problemas para tratar de entender qué es un SDL_Renderer.

¿Qué es? ¿Qué hace? ¿Cuál es la diferencia entre SDL_Renderer, SDL_Window, SDL_Surface y SDL_Texture y cómo se relacionan?

Tuve problemas con esto cuando trato de entender este código introductorio:

#include <iostream>
#include <SDL2/SDL.h>
int main()
{
/* Starting SDL */
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
return 1;
}
/* Create a Window */
SDL_Window *window = SDL_CreateWindow("Hello World!", 100, 100, 640, 480, SDL_WINDOW_SHOWN);
if (window == nullptr) {
std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
return 1;
}
/* Create a Render */
SDL_Renderer *render = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (render == nullptr) {
std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
return 1;
}
/* Load bitmap image */
SDL_Surface *bmp = SDL_LoadBMP("./Tutorial/res/Lesson1/hello.bmp");
if (bmp == nullptr) {
std::cout << "SDL_LoadBMP Error: " << SDL_GetError() << std::endl;
return 1;
}
/* Upload surface to render, and then, free the surface */
SDL_Texture *texture = SDL_CreateTextureFromSurface(render, bmp);
SDL_FreeSurface(bmp);
if (texture == nullptr){
std::cout << "SDL_CreateTextureFromSurface Error: " << SDL_GetError() << std::endl;
return 1;
}
/* Draw the render on window */
SDL_RenderClear(render); // Fill render with color
SDL_RenderCopy(render, texture, NULL, NULL); // Copy the texture into render
SDL_RenderPresent(render); // Show render on window
/* Wait 2 seconds */
SDL_Delay(5000);
/* Free all objects*/
SDL_DestroyTexture(texture);
SDL_DestroyRenderer(render);
SDL_DestroyWindow(window);
/* Quit program */
SDL_Quit();
return 0;
}

Estaba usando el tutorial de Twinklebear (sugerido en SDL Wiki) y también busqué en la documentación de SDL Wiki y algunos libros. Pero todos ellos asumen que sé estas definiciones.

Answer 1

SDL_Window

SDL_Window es la estructura que contiene toda la información sobre la ventana en sí: tamaño, posición, pantalla completa, bordes, etc.

SDL_Renderer

SDL_Renderer es una estructura que maneja todas las representaciones. Está vinculado a una SDL_Window por lo que solo se puede procesar dentro de esa SDL_Window . También realiza un seguimiento de la configuración relacionada con la representación. Hay varias funciones importantes relacionadas con el SDL_Renderer

• SDL_SetRenderDrawColor(renderer, r, g, b, a);
  Esto establece el color para borrar la pantalla (ver abajo)

• SDL_RenderClear(renderer);
  Esto borra el objetivo de renderizado con el color de dibujo establecido arriba

• SDL_RenderCopy(
  Esta es probablemente la función que usará más, se usa para representar una SDL_Texture y tiene los siguientes parámetros:

  • SDL_Renderer* renderer,
    El renderizador que desea usar para renderizar.
  • SDL_Texture* texture,
    La textura que quieres renderizar
  • const SDL_Rect* srcrect, la parte de la textura que desea representar, NULL si desea renderizar toda la textura
  • const SDL_Rect* dstrect)
    Donde quieres renderizar la textura en la ventana. Si el ancho y la altura de este SDL_Rect es menor o mayor que las dimensiones de la textura en sí, la textura se extenderá de acuerdo con este SDL_Rect
    
    
• SDL_RenderPresent(renderer);
  Las otras funciones de SDL_Render * se dirigen a un objetivo oculto. Estas funciones tomarán todo eso y lo dibujarán en la ventana vinculada al renderizador.

SDL_Textures y SDL_Surface

SDL_Renderer , renderiza SDL_Texture . SDL_Texture es la información de píxeles de un elemento. Es la nueva versión de SDL_Surface que es muy similar. La diferencia radica principalmente en que SDL_Surface es solo una struct contiene información de píxeles, mientras que SDL_Texture es una representación eficiente y específica del controlador de datos de píxeles.

Puede convertir una SDL_Surface * a SDL_Texture usando

SDL_Texture* SDL_CreateTextureFromSurface(SDL_Renderer* renderer,
SDL_Surface* surface)

Después de esto, la SDL_Surface debería liberarse usando

SDL_FreeSurface( SDL_Surface* surface )

Otra diferencia importante es que SDL_Surface utiliza la representación de software (a través de la CPU), mientras que SDL_Texture utiliza la representación de hardware (a través de GPU).

SDL_Rect

La estructura más simple en SDL. Contiene solo cuatro cortos. x, y que tiene la posición w, h que tiene ancho y alto.

Es importante tener en cuenta que 0, 0 es la esquina superior izquierda en SDL. Por lo tanto, un valor y mayor significa más bajo, y la esquina inferior derecha tendrá la coordenada x + w, y + h

Puedes leer más sobre SDL2 en mi blog.

Answer 2

Piense en SDL_Window como píxeles físicos, y SDL_Renderer y un lugar para almacenar configuraciones / contexto.

Así que creas un montón de recursos y los cuelgas del renderizador; y cuando esté listo, le dices al procesador que lo junte todo y envíe los resultados a la ventana.