¡Código!

El primer paso en nuestro uso de SDL será la creación de una simple ventana. Para esto haremos uso de algunas pocas funciones de la librería.

Figura. El ejemplo que acompaña el tutorial en acción

Para esto crearemos una clase C++ llamada “Window” dentro de un espacio de nombre llamado “codeTutorials” simplemente para evitar colisiones de este nombre tan común con cualquier otra librería que en el futuro pueda utilizar nuestra aplicación.

Nuestra clase poseerá los siguientes métodos:

Constructor: Creará un objeto del tipo ventana e inicializará el subsistema de video de SDL.
Destructor: Apagará el subsistema de video y destruirá el objeto.
Update: Actualiza el contenido de la ventana.
Clear: Limpia el contenido de la ventana con el color especificado.
SetBackgroundColor: Fija el color de fondo por defecto de la ventana.
SetTitle: Fija el título de la ventana.

Claro que podríamos especificar más métodos, pero nos manejaremos con estos sólo simplemente para ver como lidiar con SDL.

Las propiedades que tendrá nuestra pequeña clase “Window” serán:

SDL_Surface * m_pMainSurface: Puntero a una superficie SDL. Una superficie es básicamente una porción de memoria de video (aunque en ciertos casos esto no sea realmente así nos servirá pensarlo de este modo) con ciertos atributos. Esta superficie puede ser escrita y en el caso particular de la superficie principal su contenido podrá verse en pantalla dentro de nuestra ventana.
unsigned int m_uiColor: Color por defecto utilizado por nuestra clase para “pintar” la superficie.

Ahora, veamos el código dentro del constructor y analicemos el uso de las primeras funciones SDL:


| // Crea una ventana del tamaño especificado
| Window::Window(int iWidth, int iHeight, const char * pszTitle)
| {
| // Fijo un color por defecto
| m_uiColor = 0xff000000;
|
| // Si algo sale mal y debo terminar la función de manera prematura
| // la superficie quedará en NULL
| m_pMainSurface = NULL;
|
| // Inicialización de SDL
| if (SDL_Init(SDL_INIT_VIDEO) == -1)
| // Ha ocurrido un error
| return;
|
| // Fijo el título de la ventana
| if (pszTitle != NULL)
| SDL_WM_SetCaption(pszTitle, NULL);
|
| // Obtengo información del sistema
| const SDL_VideoInfo * pInfo = SDL_GetVideoInfo();
|
| if(!pInfo)
| // No se pudo obtener la información de video
| return;
|
| // Creo una variable con los flags requeridos
| unsigned long ulFlags = SDL_DOUBLEBUF | SDL_HWSURFACE;
| m_pMainSurface = SDL_SetVideoMode(iWidth, iHeight, pInfo->vfmt->BitsPerPixel, ulFlags);
| }


La primer función que utilizamos de SDL es SDL_Init, por medio de ella podremos inicializar los distintos subsistemas de la librería. En este caso particular deseamos inicializar el subsistema de video por lo que especificamos como parámetro SDL_INIT_VIDEO.

Función: SDL_Init
Prototipo: int SDL_Init(Uint32 flags);
Parámetros: Los valores posibles principales de flags son:

Constantes:

SDL_INIT_VIDEO: Inicializa subsistema de video.
SDL_INIT_AUDIO: Inicializa subsistema de audio.
SDL_INIT_TIMER: Inicializa subsistema de timer.
SDL_INIT_CDROM: Inicializa subsistema de cd-rom.
SDL_INIT_JOYSTICK: Inicializa subsistema de joystick.
SDL_INIT_EVERYTHING: Inicializa todos los subsistemas.

Siguiendo el código del constructor, líneas después utilizamos la función SDL_WM_SetCaption que en realidad pertenece al conjunto de función de manejo de ventanas (notar el prefijo WM de Window Management). Esta función se utiliza para cambiarle el nombre a la ventana (algo así como la función del API de Win32 SetWindowText).

Función: SDL_WM_SetCaption
Prototipo: void SDL_WM_SetCaption(const char *title, const char *icon);
Parámetros:
title: Título de la ventana (puede ser NULL).
icon: Nombre del archivo “.ico” que se utilizará para la ventana (puede ser NULL).

Acto seguido invocamos la función SDL_GetVideoInfo, esta función nos retorna un puntero a una estructura del tipo SDL_VideoInfo.

Función: SDL_GetVideoInfo
Prototipo: SDL_VideoInfo *SDL_GetVideoInfo(void);
Parámetros: Ninguno.

La estructura del tipo SDL_VideoInfo posee información relacionada a las capacidades del dispositivo de video y el formato del pixel utilizado al momento de realizar la llamada a la función. Recordemos que si fijaremos el adaptador en pantalla completa podremos seleccionar (de un grupo de modos disponibles) cuál es el formato de pixel y la resolución de la pantalla, pero si inicializaremos en modo ventana deberemos tomar las propiedades como están fijadas y adaptarnos a ellas.

Veamos con mayor detalle sus elementos:

Propiedades:

hw_available: Indica si es posible crear superficies de hardware.
wm_available: Indica si el sistema dispone de un gestor de ventanas (en Windows esto siempre será así pero no en otros sistemas)
blit_hw: Indica si existe aceleración de copiado de superficies en hardware.
blit_hw_CC: Indica si existe aceleración de copiado con colorkey de superficies en hardware.
blit_hw_A: Indica si existe aceleración de copiado con canal alfa de superficies en hardware.
blit_sw: Indica si existe aceleración de copiado de superficies de software a hardware.
blit_sw_CC: Indica si existe aceleración de copiado con colorkey de superficies de software a hardware.
blit_sw_A: Indica si existe aceleración de copiado con canal alfa de superficies de software a hardware.
blit_fill: Indica si existe aceleración en el proceso de rasterización.
video_mem: Indica la cantidad total de memoria disponible (en Kb).
vfmt: Puntero a estructura SDL_PixelFormat

De la estructura SDL_PixelFormat tal vez la propiedad de mayor interés para nosotros sea BitsPerPixel que nos indica la cantidad de bits que existen por píxels, es decir la profundidad de colores.

Finalmente llegamos a la última línea del método, en donde fijamos el modo de video haciendo uso de la función SDL_SetVideoMode:

Función: SDL_SetVideoMode
Prototipo: SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags);
Parámetros:
width: Ancho en píxels de la superficie a crear.
height: Alto en píxels de la superficie a crear.
bpp: Profundidad de colores (bits por pixel).
flags: Propiedades de la superficie a crear:

Flags:

SDL_SWSURFACE: Superficie en memoria de sistema.
SDL_HWSURFACE: Superficie en memoria de video.
SDL_ASYNCBLIT: Habilita el copiado a superficie principal sin sincronizar con barrido de vertical.
SDL_DOUBLEBUF: Habilita un búfer doble en hardware (sólo válido para superficies de hardware).
SDL_FULLSCREEN: Fija el modo de video en pantalla completa.
SDL_OPENGL: Crea un contexto de renderización OpenGL.
SDL_RESIZABLE: Crea una ventana redimensionable.
SDL_NOFRAME: Crea una ventana sin barra de título ni bordes.

En nuestro caso, utilizamos el alto y ancho especificados por parámetros en el constructor (que será el alto y ancho de la ventana), utilizamos la profundidad de colores que nos retornó la función SDL_GetVideoInfo dentro de la estructura SDL_VideoInfo.

Luego, en cuanto a flags especificaremos que deseamos una superficie de hardware con búfer doble (utilizando un búfer doble escribiremos sobre una porción de memoria que no se esté mostrando en pantalla y luego cambiaremos la superficie activa por esta).

Cuando terminemos de utilizar la librería deberemos invocar la función SDL_Quit.

Función: SDL_Quit
Prototipo: void SDL_Quit(void);
Parámetros: -

Pages: 1 2 3 4

Comentarios (2)