SDL 2: Guía de uso de la librería SDL para un proyecto con interfaz gráfica - aigora/twIE_2021-chkr_s-l GitHub Wiki

En el desarrollo de nuestro proyecto hemos seguido la guía de Lazyfooo sobre SDL aunque los inconvenientes de esta guía son que el lenguaje con el se programa en este tutorial es C++ y está en inglés.

La primera parte de un proyecto de SDL consiste en la inicialización de la aplicación. En primer lugar, es importante que la función main quede definida de la siguiente forma, pues así se puede portar a otros sistemas operativos.

int main(int argv, char** args)
{
   ...

  return 0;
}

Cabe destacar, que para emplear las funciones que se emplean a continuación hay que incluir las funciones de la librería y para ello, en función de como se halla instalado hay que escribir un comando distinto. Solo se usará uno de los dos.

#include <SDL.h>

#include <SDL2/SDL.h>

Posteriormente, lo que se debe hacer es crear una ventana donde alojaremos nuestros elementos gráficos. Para ello, primero declararemos nuestras variables:

SDL_Window *Ventana= NULL;
SDL_Renderer *Render = NULL;
SDL_Texture *Textura = NULL;

Se han declarado estas tres variables porque la imagen se cargara como una textura para poder luego dibujar en ella mediante el render que es como una especie de lienzo en blanco. Es importante que la inicialización de estos se haga en main pues sino, es posible que los punteros no apunten bien a la dirección de memoria que deberían.

  1. Se comprueba si se ha inicializado correctamente la librería y sino se le pide que nos imprima un error por consola:
if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 ) //Se compureba si se ha iniciado correctamente SDL
  {
    printf( "SDL no pudo iniciarse: %s\n", SDL_GetError() );
  }
else
  { ... }
  1. Se comprueba si la calidad de las texturas es la adecuada:
if(!SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" )) //Se compureba la calidad de texturas
        {
          printf("Aviso: Filtración linear de texturas no disponible");
        }
  1. Se crea la ventana (nombre, si esta centrado, si esta centrado, ancho de la ventana, alto de la ventana, si se muestra la ventana ), asignándole una dirección de memoria al puntero y se comprueba que la ventana haya iniciado de manera adecuada:
Ventana = SDL_CreateWindow( "Damas.exe", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1920, 1080, SDL_WINDOW_SHOWN ); //Se crea la ventana
      if( Ventana == NULL ) //Se comprueba si la ventana ha inicializado bien
          {
           printf( "No se pudo crear la ventana: %s\n", SDL_GetError() );
           return -1;
          }
  1. Se le asigna al render la dirección de memoria de la ventana para que de esta manera se pueda dibujar por pantalla (ya sea importando fondos o formas geométricas). Además, mediante el comando RENDER_ACELERATED se emplea la aceleración de software, es decir, usaremos la tarjeta gráfica para los elementos gráficos del programa.
Render= SDL_CreateRenderer( Ventana, -1, SDL_RENDERER_ACCELERATED ); //Se crea el render que será donde pintaremos y se le añade aceleración de sowftware
    if( Render == NULL ) //Se comprubea si ha inicializado bien el render
         {
           printf( "El render no se pudo crear SDL Error: %s\n", SDL_GetError() );
           return -1;
         }

  1. A la hora de usar SDL se pueden usar por defecto los formatos de imagen BMP y si se quieren importar otros formatos será necesario configurar otra librería adicional. En nuestro programa como no era necesario optimizar el peso de la aplicación porque no empleamos muchas imágenes simplemente hemos decidido seguir empleando el formato BMP.

  2. Para importar un fondo es necesario emplear una superficie auxiliar que será donde se cargará la imagen y posteriormente se cargara la superficie sobre la textura, para acto seguido borrar la superficie y liberar memoria. (Se coloca el color del render en blanco para poder luego dibujar de forma cómoda)

SDL_SetRenderDrawColor( Render, 0xFF, 0xFF, 0xFF, 0xFF ); //Se pone el color del render en blanco
SDL_Surface *SupCarg = SDL_LoadBMP("direccion"); //Se carga el fondo
       if( SupCarg == NULL ) //Se comprueba si se ha guardado bien el fondo
           {
             printf( "No se pudo cargar la imagen: %s SDL Error: %s\n", "direccion", SDL_GetError() );
           }
       else
          {
            Textura = SDL_CreateTextureFromSurface( Render, SupCarg ); //Se aplica el fondo sobre la textura
            if(  Textura == NULL ) //Se compueba si la textura ha cogido el fondo
              {
                printf( "No se pudo cargar crear la textura SDL Error: %s\n", SDL_GetError() );
              }
                SDL_FreeSurface( SupCarg );
         }
  1. Por último, se coloca la textura sobre el render y se actualiza el render
SDL_RenderCopy( Render, Textura, NULL, NULL ); //Se coloca la textura sobre el render
SDL_RenderPresent( Render ); //Se actualiza el Render
  1. Una de las opciones que permite SDL es dibujar formas geométricas simples, en este caso en nuestro programa hemos empleado la forma geométrica de rectágulo relleno. Importante, tras dibujar la forma se actualiza el render para que salga por pantalla.

En el código x e y son la esquina superior izquierda, w el ancho hacia la derecha y h la altura hacia abajo. En la función DrawColor RGB denotan la escala rojo, verde y azul que toman valores de 0 a 255, denotando los extremos mediante 0x00 = 0 y 0xFF = 255. Por último, T es la transparencia.

SDL_Rect fillRect = { x,y,w,h};
SDL_SetRenderDrawColor( Render, R, G, B, T );
SDL_RenderFillRect( Render, &fillRect );

SDL_RenderPresent( Render ); //Se actualiza el render
  1. Por último, tras todas las ejecuciones de SDL es necesario liberar la memoria empleada para los elementos gráficos y cerrar la librería.
SDL_DestroyTexture( Textura );
Textura = NULL;
SDL_DestroyRenderer( Render );
SDL_DestroyWindow( Ventana );
Ventana = NULL;
Render = NULL;
SDL_Quit();
⚠️ **GitHub.com Fallback** ⚠️