c++ - sdl2 - ¿Qué es un procesador SDL?
sdl2 tutorial (2)
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.
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 arribaSDL_RenderCopy(
Esta es probablemente la función que usará más, se usa para representar unaSDL_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 esteSDL_Rect
es menor o mayor que las dimensiones de la textura en sí, la textura se extenderá de acuerdo con esteSDL_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.
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.