4.3. Trabajo con superficies

Una superficie contiene una imagen o una imagen formada por varias superficies. Para ello SDL tiene un tipo de dato llamado SDL_Surface, en el cual podemos cargar cualquier imagen y a la cual le podemos ir "pegando" otras imagenes cargadas en otros SDL_Surface. La definición de SDL_Surface es la siguiente:

		  typedef struct SDL_Surface {
		    Uint32 flags;                           /* solo lectura */
		    SDL_PixelFormat *format;                /* solo lectura */
		    int w, h;                               /* solo lectura */
		    Uint16 pitch;                           /* solo lectura */
		    void *pixels;                           /* lectura y escritura */
		    /* clipping information */
		    SDL_Rect clip_rect;                     /* solo lectura */
		    int refcount;                           /* Read-mostly */
		  } SDL_Surface;
		

En el caso de los video juegos es importante que no se puedan dibujar las superficies directamente en el pantalla. Si fuese así el usuario vería como se van colocando cada una de las imágenes en la pantalla en cada instante. Para solucionar esto SDL sólo nos deja mostrar en pantalla una sólo superficie, a la que con anterioridad le hemos podido "pegar" otras superficies.

Para no liarnos vamos a empezar a ver código. Lo primero será cargar la variable SDL_Surface que nos va a servir como pantalla y la cual vamos a ir colocando cada una de las imágenes de nuestro juego. Para ello tenemos la función SDL_SetVideoMode a la cual le podemos pasar varios parámetros.

		  SDL_Surface *screen;
		  screen = SDL_SetVideoMode(640,480,16, SDL_SWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);
		  if(!screen){
		    printf("No se pudo iniciar la pantalla: %s\n", SDL_GetError());
		    SDL_Quit();
		    exit(-1);
		  }
		

La variable screen contiene la única superficie que puede mostrarnos el juego. Los dos primeros parámetros son las resolución de pantalla, en este caso 640x480. El segundo la profundidad de color y como último parámetro le podemos pasar diferentes flags separados por "|". Los posibles flags son los siguientes:

• SDL_SWSURFACE: crea la superficie en memoria del sistema

• SDL_HWSURFACE: crea la superficie en memoria de vídeo

• SDL_DOUBLEBUF: activa el doble buffer. Lo que hace es que no se le muestra la pantalla directamente al usuario. Mientras el usuario ve la pantalla, el programa está trabajando en la siguiente pantalla a mostrar.

• SDL_FULLSCREEN: abre el programa en pantalla completa

Por este momento lo único que tenemos es la superficie que vamos a mostrar, pero por el momento es una pantalla en negro. Lo que haremos ahora es cargar una imagen en otra superficie que "pegaremos" en nuestra superficie principal (llamada "screen") la cual mostraremos. Para ello utilizaremos la siguiente imagen:

Lo primero es lo primero, y lo que tenemos que hacer es cargar la imagen. SDL por defecto sólo nos deja trabajar con archivos BMP utilizando la función SDL_LoadBMP(const char *file) que se le pasando como parámetro una cadena con la ruta del archivo BMP que queremos cargar. Después de probar diferentes formatos de imágenes yo me quedo con PNG, y no sólo porque sea un formato libre, sino porque es el mejor de todos y trabaja las transparencias como ningún otro. Pero el problema es que SDL no nos deja cargar PNG en nuestro programa. Para ello utilizamos SDL_image, que si habéis seguido el capítulo "Instalación de SDL" ya sabéis de lo que hablo. Lo primero es incluirlas en nuestro programa:

#include <SDL_image.h>

Luego en el programa cargamos la imagen:

		  SDL_Surface *imagen;
		  imagen = IMG_Load ("curso.png");
		

Ya tenemos cargada nuestra imagen, ahora toca colocarla dentro dentro de la superfecie "screen" para que puede ser visualizada. Para ello tenemos que definir un área rectangular que será donde será pegada nuestra imagen en el "screen". Para ello tenemos la estrucutura SDL_Rect que tiene la siguiente definición:

		  typedef struct{
		    Sint16 x, y;
		    Uint16 w, h;
		  } SDL_Rect;
		

La variable "x" nos da la posición X en el "screen", la "y" la posición Y, la "w" el ancho de la imagen y la "h" el alto.

Una vez creado nuestro SDL_Rect, utilizaremos la función SDL_BlitSurface() para colocar la imagen en el "screen". Esta función contiene 4 parámetro:

int SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);

La variable "src" es el "screen", "srcrect" normalmente tiene el valor NULL, "dst" es la superficie imagen y "dstrect" es el SDL_Rect que nos dará las posiciones donde queremos poner nuestra imagen en pantalla. El código completo quedaría algo tal que así:

		  SDL_Surface *screen;
		  SDL_Surface *imagen;
		  SDL_Rect rect;
		  screen = SDL_SetVideoMode(640,480,16, SDL_SWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);
		  if(!screen){
		    printf("No se pudo iniciar la pantalla: %s\n", SDL_GetError());
		    SDL_Quit();
		    exit(-1);
		  }
		  imagen = IMG_Load ("curso.png");
		  rect.x = 100;
		  rect.y = 100;
		  rect.w = imagen->w;
		  rect.h = imagen->h;
		  SDL_BlitSurface(imagen, NULL, screen, &rect);
		  SDL_Flip (screen);
		

En este código podemos ver varias cosas. La primera como hemos cargado el archivo curso.png. Luego vemos como le damos los valores a la variable "rect". La posición x e y muestran que la imagen se cargar en la coordenada (100,100) de nuestra pantalla y a los valores w y h le damos la altura y anchura de la imagen PNG que hemos cargado. También vemos como colocamos la imagen en la pantalla con la función SDL_BlitSurface() y como refrescamos la pantalla con SDL_Flip (screen). La función SDL_Flip se tiene que ir repitiendo en cada bucle para que la pantalla muestre los nuevos datos.

Por último vamos a ver la función SDL_FreeSurface() a la cual le pasamos un SDL_Surface que como todos suponéis ya va a liberar de memoria.