Usando a API Simple DirectMedia Layer 

• Escolhendo e ajustando o modo de tela (o jeito fácil)

  Você simplesmente escolhe sua profundidade- de- bits (bits-por-ponto) e resolução favorita e ajusta!

 Você pode encontrar a profundidade de vídeo mais rápida suportada pelo hardware com a função SDL_GetVideoInfo().

Dica #2:
Você pode obter uma lista de resoluções de vídeo em uma profundidade-de-bits em  particular suportadas usando a função SDL_ListModes().

{ SDL_Surface *screen;

    screen = SDL_SetVideoMode(640, 480, 16, SDL_SWSURFACE);
    if ( screen == NULL ) {
        fprintf(stderr, "Impossível ajustar ao vídeo em  640x480 : %s\n", SDL_GetError());
        exit(1);
    }
}

• Desenhando pixels na tela

  Para desenhar na tela , escreve-se diretamente no framebuffer (que armazena cada tela antes de sua exibição) gráfico e chamando a função de atualização da tela

Se você sabe que ira desenhar muito na tela, é melhor trancar a tela ( se necessário) antes de desenhar, desenhar enquanto mantém uma lista de áreas necessária de se atualizar, e destrancar a tela novamente antes de atualiza-la.

Desenhando um pixel em uma tela de formato arbitrário

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: { /* Assumindo 8-bpp */
            Uint8 *bufp;

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

        case 2: { /* Provavelmente 15-bpp ou 16-bpp */
            Uint16 *bufp;

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

        case 3: { /* mode 24-bpp lento,normalmente não 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: { /* Provavelmente 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);
}

• Carregando e exibindo imagens na tela

  SDL prove uma única rotina de carregamento de imagens para sua conveniência,SDL_LoadBMP().Uma biblioteca para carregamento de imagens pode ser encontrado no arquivo de demos do SDL.

  Você pode exibir imagens usando SDL_BlitSurface() para copia-las no framebuffer gráfico. SDL_BlitSurface() automaticamente delimita a área copiada, que deve ser passado para SDL_UpdateRects() para atualizar a porção da tela que foi modificada.

Se você esta carregando uma imagem para ser exibida muitas vezes,você pode melhorar a velocidade de copia,convertendo-a para o formato da tela. a função SDL_DisplayFormat() faz esta convenção para você.

Dica #2:

Muitas sprites tem fundo transparente.Você pode habilitar copias transparentes (copias em colorkey) com a função SDL_SetColorKey().

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

/* carrega o arquivo BMP na superfície */
    image = SDL_LoadBMP(file);
    if ( image == NULL ) {
        fprintf(stderr, "Não foi possível carregar o arquivo %s: %s\n", file, SDL_GetError());
        return;
    }

/* Copia na superfície da tela. A superfície não pode estar trancada neste ponto. */

    dest.x = x;
    dest.y = y;
    dest.w = image->w;
    dest.h = image->h;
    SDL_BlitSurface(image, NULL, screen, &dest);

/* Atualiza a porção modificada da tela */
    SDL_UpdateRects(screen, 1, &dest);
}