Nesta segunda lição será mostrado como carregar imagens com a SDL, resultando numa tela de fundo e uma figura que se move pelo teclado. Lembre-se que é necessário incluir os parâmetros do linker (-lmingw32 -lSDLmain -lSDL) nas opções do projeto como comentado na primeira lição.
1. Cabeçalhos e objetos globais
Iniciamos incluindo cabeçalhos e declarando alguns objetos globais, entre superfícies desenháveis e inteiros para armazenar a posição da figura na tela.#include MENORQstdio.hMAIORQ
#include MENORQstdlib.hMAIORQ
#include MENORQSDL/SDL.hMAIORQ
SDL_Surface *back; // imagem de fundo
SDL_Surface *image; // figura controlada
SDL_Surface *screen; // será tela completa
int xpos = 0, ypos = 0; // posição da figura
Em seguida foi declarada uma função auxiliar que carrega as imagens a partir de arquivos bitmap e preenche as superfícies. Para isso, a função SDL_LoadBMP() recebe um nome de arquivo e retorna um ponteiro para o tipo SDL_Surface.int InitImages()
{
back = SDL_LoadBMP("bg.bmp");
image = SDL_LoadBMP("image.bmp");
return 0;
}
2. Mostrando na tela
Continuando, as próximas duas funções fazem o blit (cópia) da imagem para a tela usando a função SDL_BlitSurface(), cujo protótipo é definido comoint SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect);
onde src é a superfície a ser copiada e dst é a superfície onde src será copiada.
srcrect permite que apenas uma parte da imagem de origem seja copiada, especificada por seus membros x, y, w e h (esquerda, topo, largura e altura).
dstrect indica a posição (x,y de dst) onde srcrect será colocado. Note que se srcrect é substituído por NULL, a imagem toda é copiada. É desta forma que mostramos uma figura sobre o plano de fundo.void DrawIMG(SDL_Surface *img, int x, int y)
{
SDL_Rect dest;
dest.x = x;
dest.y = y;
SDL_BlitSurface(img, NULL, screen, &dest);
}
Se NULL não é usado, temos um overload (sobrecarga) da função auxiliar DrawIMG() que permite o blit de apenas uma parte específica da imagem de origem, como comentado.void DrawIMG(SDL_Surface *img, int x, int y,
int w, int h, int x2, int y2)
{
SDL_Rect dest;
dest.x = x;
dest.y = y;
SDL_Rect dest2;
dest2.x = x2;
dest2.y = y2;
dest2.w = w;
dest2.h = h;
SDL_BlitSurface(img, &dest2, screen, &dest);
}
Aqui, a região (dest2) da imagem (img) é desenhada na tela (screen) na posição (dest). Simples.
Na seqüência, criamos mais uma função para desenhar o plano de fundo. Basicamente, a superfície (back) é colocada no início da tela (posição x,y = 0,0 sobre a superfície screen).void DrawBG()
{
DrawIMG(back, 0, 0);
}
Em seguida, outra função foi criada, desta vez, para eliminar o rastro da figura que se move pela tela e também para redesenhá-la em seguida, normalmente. O rastro é eliminado redesenhando-se a região onde está a figura, com uma "folga" de alguns pixels em x, y, w e h. A tela toda poderia ser redesenhada, mas para melhor desempenho, atualiza-se somente a região da figura. Por fim, é feita a troca (flip) dos buffers através da função SDL_Flip().void DrawScene()
{
DrawIMG(back, xpos-2, ypos-2, 132, 132, xpos-2, ypos-2);
DrawIMG(image, xpos, ypos);
SDL_Flip(screen);
}
Já se aproximando do fim desta lição, vamos à função main(). A porção inicial do código inicializa a SDL, como já foi tratado, e será mostrada no exemplo completo mais abaixo. Em seguida são chamadas as funções auxiliares para carregar as imagens e desenhar o fundo da tela. Na seqüência, entramos no game loop, também já comentado na primeira lição.
3. Código completo#include MENORQstdio.hMAIORQ
#include MENORQstdlib.hMAIORQ
#include MENORQSDL/SDL.hMAIORQ
SDL_Surface *back; // imagem de fundo
SDL_Surface *image; // figura controlada
SDL_Surface *screen; // será tela completa
int xpos = 0, ypos = 0; // posição da figura
int InitImages()
{
back = SDL_LoadBMP("bg.bmp");
image = SDL_LoadBMP("image.bmp");
return 0;
}
void DrawIMG(SDL_Surface *img, int x, int y)
{
SDL_Rect dest;
dest.x = x;
dest.y = y;
SDL_BlitSurface(img, NULL, screen, &dest);
}
void DrawIMG(SDL_Surface *img, int x, int y,
int w, int h, int x2, int y2)
{
SDL_Rect dest;
dest.x = x;
dest.y = y;
SDL_Rect dest2;
dest2.x = x2;
dest2.y = y2;
dest2.w = w;
dest2.h = h;
SDL_BlitSurface(img, &dest2, screen, &dest);
}
void DrawBG()
{
DrawIMG(back, 0, 0);
}
void DrawScene()
{
DrawIMG(back, xpos-2, ypos-2, 132, 132, xpos-2, ypos-2);
DrawIMG(image, xpos, ypos);
SDL_Flip(screen);
}
int main(int argc, char *argv[])
{
if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO) MENORQ 0)
{
printf("Erro: %s\n", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
screen = SDL_SetVideoMode(640, 480, 32,
SDL_SWSURFACE | SDL_FULLSCREEN);
if (screen == NULL) exit(1);
InitImages();
DrawBG();
int done = 0;
while (done == 0)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT) { done = 1; }
if (event.type == SDL_KEYDOWN &&
event.key.keysym.sym == SDLK_ESCAPE)
done = 1;
}
Uint8 *keys = SDL_GetKeyState(NULL);
if (keys[SDLK_UP]) { ypos -= 1; }
if (keys[SDLK_DOWN]) { ypos += 1; }
if (keys[SDLK_LEFT]) { xpos -= 1; }
if (keys[SDLK_RIGHT]) { xpos += 1; }
DrawScene();
}
return 0;
}
Neste exemplo, foi acrescentado o tratamento do teclado. De maneira resumida, verificamos se o evento ocorrido foi um pressionamento de tecla (event.type == SDL_KEYDOWN) e, em caso afirmativo, se foi a tecla esc (event.key.keysym.sym == SDLK_ESCAPE). Em seguida, pegamos o estado do teclado através da função SDL_GetKeyState() e atualizamos a posição x,y da figura conforme a tecla pressionada. Por último, a função auxiliar DrawScene() é chamada para atualizar tudo o que vemos na tela.
Lembre-se de criar duas imagens (bg.bmp e image.bmp) para o fundo e a figura. O fundo pode ter 640x480 pixels e a figura é recomendável que tenha 128x128 para que coincida com o exemplo da "folga" na função DrawScene().
Lembre-se também de substituir qualquer MENORQ e MAIORQ pelos respectivos símbolos mátemáticos, até eu me acertar com o blogger.
