Usando la API de Simple DirectMedia Layer

• Eligiendo y estableciendo modos de vídeo (la manera fácil)

  Simplemente escoges tu modo de resolución y profundidad de color preferido y, ¡lo estableces!

Pista #2:
Puedes obtener una lista de resoluciones de vídeo soportadas para una determinada profundidad de color usando la función SDL_ListModes().

{ SDL_Surface *screen;

    screen = SDL_SetVideoMode(640, 480, 16, SDL_SWSURFACE);
    if ( screen == NULL ) 
    {
        fprintf(stderr, "No se puede establecer el modo \
                de video 640x480: %s\n", SDL_GetError());
        exit(1);
    }
}

• Dibujando píxels en la pantalla

  Para dibujar en la pantalla debemos escribir directamente en el búfer de marco (framebuffer) gráfico, y llamar a la función de actualización de pantalla.

Dibujando un píxel en la pantalla de un formato arbitrario

void DrawPixel(SDL_Surface *screen, Uint8 R, Uint8 G, Uint8 B)
{
    Uint32 color = SDL_MapRGB(screen->format, R, G, B);

    if ( SDL_MUSTLOCK(screen) ) 
    {
        if ( SDL_LockSurface(screen) < 0 ) 
	{
            return;
        }
    }
    switch (screen->format->BytesPerPixel) 
    {    
        case 1: 
	{ /* Asumimos 8-bpp */
            Uint8 *bufp;

            bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
            *bufp = color;
        }
        break;

        case 2: 
	{ /* Probablemente 15-bpp o 16-bpp */
            Uint16 *bufp;

            bufp = (Uint16 *)screen->pixels + \
	           y*screen->pitch/2 + x;
            *bufp = color;
        }
        break;

        case 3: 
	{ /* Modo lento 24-bpp, normalmente no usado */
            Uint8 *bufp;

            bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
            *(bufp+screen->format->Rshift/8) = R;
            *(bufp+screen->format->Gshift/8) = G;
            *(bufp+screen->format->Bshift/8) = B;
        }
        break;

        case 4: 
	{ /* Probablemente 32-bpp */
            Uint32 *bufp;

            bufp = (Uint32 *)screen->pixels + \ 
                   y*screen->pitch/4 + x;
            *bufp = color;
        }
        break;
    }
    if ( SDL_MUSTLOCK(screen) ) 
    {
        SDL_UnlockSurface(screen);
    }
    SDL_UpdateRect(screen, x, y, 1, 1);
}

• Cargar y mostrar imágenes

  SDL facilita una única rutina de carga de imágenes para tu conveniencia, SDL_LoadBMP(). Puedes encontrar una librería para la carga de imágenes en el archivo de demos SDL.

  Puedes mostrar imágenes usando SDL_BlitSurface() para volcarlas en búfer de marco gráfico. SDL_BlitSurface() recorta automáticamente el rectángulo volcado, que debería ser pasado a SDL_UpdateRects() para actualizar la porción de la pantalla que ha cambiado.

Pista #2:
Muchas imágenes de sprite tienen un fondo transparente. Puedes habilitar volcados transparentes (volcados con color clave) mediante la función SDL_SetColorKey().

void ShowBMP(char *file, SDL_Surface *screen, int x, int y)
{
    SDL_Surface *image;
    SDL_Rect dest;

    /* Cargamos el archivo BMP en la superficie */
    image = SDL_LoadBMP(file);
    if ( image == NULL ) {
        fprintf(stderr, "No pude cargar %s: %s\n", 
	        file, SDL_GetError());
        return;
    }

    /* Volcamos en la superficie de pantalla.
       Las superficies no deberían estar bloqueadas 
       en este punto. */
    dest.x = x;
    dest.y = y;
    dest.w = image->w;
    dest.h = image->h;
    SDL_BlitSurface(image, NULL, screen, &dest);

    /* Actualizamos la porcion de pantalla que ha cambiado */
    SDL_UpdateRects(screen, 1, &dest);

    SDL_FreeSurface(image);
}