C / C++ SDL - Tutorial ( Windows )

[~$N4P~]

INTRODUÇÃO Á SDL
Por: Cr!tic4L K3rneL

Site Oficial: Apenas usuários registrados e ativados podem ver os links., Clique aqui para se cadastrar...



A SDL é uma poderosa biblioteca multimídia e multiplataforma que pode ser usada para diversos propósitos como criação de jogos, aplicativos gráficos, players de DVD e como utilitário para diversos tipos de aplicação.

O nome por trás da SDL é Sam Lantinga que criou a mesma em 1998, no período que trabalhava na Loki Software, como uma solução para portar jogos para diversas plataformas. O primeiro deles, foi Doom para BeOS.

Essa biblioteca foi escrita e c, mas pode ser usada com diversas linguagens como c, c++, Ada, Eiffel, Java, Lua, ML, Perl, PHP, Pike, Python, e Ruby. Por meio dela podemos manipular vídeo, eventos, áudio, CD-ROM, som, threads, rede e tempo.

A idéia por trás da SDL é criar uma abstração de suporte a gráficos, sons, inputs, redes, etc de forma que um mesmo código possa gerar programas para diversas plataformas, tais como Linux, Windows, Mac Os, BeOS, FreeBSD, OpenBSD, Solaris, QNX e IRIX. Além dessas plataformas, diversas outras ainda são suportadas não oficialmente.

Além de oferecer uma ótima interface 2d e de prover uma série de interfaces auxiliares, um dos principais motivos pelo qual a SDL vem ganhando adeptos é o fato que ela também foi concebida para ser usada com OpenGL, servindo como uma biblioteca auxiliar dessa poderosa API, controlando janelas e eventos, manipulando sons e provendo uma interface amigável para inputs e redes. Dessa forma, além de ser uma ferramenta completa para desenvolvimento de jogos e aplicativos 2d, é a única ferramenta auxiliar que você precisa para criar jogos e aplicativos 3d com OpenGL.

Além da SDL propriamente dita, que é de propósito geral, a biblioteca ainda é formada pelas seguintes bibliotecas específicas:

* SDL_image;
* SDL_mixer;
* SDL_net;
* SDL_ttf;
* SDL_gfx;
* SDL_SMPEG;
* SDL_rtf.

Arquitetura da SDL
A imagem abaixo representa a arquitetura de implementação das aplicações SDL. Uma aplicação multimídia roda sobre a SDL, a qual tem suas funcionalidades suportadas por APIs específicas para cada sistema operacional.

Os principais motivos para você usar SDL
A SDL é uma ótima escolha em diversas situações e por diversos motivos, seja como ferramenta principal ou como uma biblioteca auxiliar. Veja se algum desses fatores se enquadra nas suas reais necessidades:

* Possui todas as funcionalidades para criar qualquer tipo de jogo 2d;
* Alto desempenho em aplicações 2d;
* Comandos de 2d de baixo nível;
* Biblioteca auxiliar única para OpenGL;
* Gratuita;
* Multiplataforma;
* Fácil de ser usada;
* Programação em rede fácil e multiplataforma;
* Utilitário para engines gráficas ou render engines.



Jogos e Aplicativos que usam SDL
Só no site oficial da SDL encontram-se registrados mais de 98 aplicações e 411 jogos desenvolvidos com a biblioteca, ou nos quais a mesma foi usada como ferramenta auxiliar. Dentre esses projetos destacamos:

* Civilization
* Descente3
* Enemy Territory: Quake Wars
* Heavy Metal: F.A.K.K.2
* Herectic II
* Heroes of Might and Magic III
* Myth II: Soulblighter
* Neverwinter Nights
* Postal Plus
* Railroad Tycoon II
* Rune
* Sid Meier's Alpha Centauri
* SimCity 3K Unlimited
* Soldier Of Fortune
* Unreal Tournament



A SDL também vem sendo muito usada para o desenvolvimento de players de DVD, emuladores de video games, arcades e plataformas gráficas.

INSTALANDO A SDL

* como instalar a SDL no DevC++
* Como criar um projeto SDL

Instalando a SDL no Dev C++
Optamos por usar o Dev C++ por ser uma ferramenta gratuíta, de fácil utilização e ser compatível com o C++ padrão. O primeiro passo é obter o Dev C++ caso você ainda não tenha o mesmo instalado no seu computador.


Passo 1 - Baixando o Dev-C++

Se você não tem o Dev-C++ instalado no seu computador, o primeiro passo é baixar e instalar o mesmo. Isso pode ser feito a partir do site da Bloodshed:

Apenas usuários registrados e ativados podem ver os links., Clique aqui para se cadastrar...

Instale o programa no seu computador

Passo 2 - Instalando o Pacote da SDL

Uma das vantagens de usar o Dev-C++ é que seu sistema de gerenciamento de pacotes e a disponibilidade de templates facilitam em muito a nossa vida.

Vá ao menu Ferramentas e clique em Atualizações.


No servidor de pacotes, escolha devpaks.org e clique em Check for updates.


Os passos acima carregam todas as atualizações disponíveis. Em Groups, escolha o grupo SDL e selecione a versão mais recente da biblioteca e as bibliotecas adicionais que você deseja usar em seu projeto. Clique no botão de Downloads.

Terminado o Download, o processo de instalação é iniciado automaticamente.

Passo 3 - Criando um projeto a partir do template

Vamos aprender a criar projetos a partir do template da SDL que vem disponibilizado a no pacote que acabamos de instalar.

Inicie um novo projeto. Vá ao menu Arquivo, Novo e escolha Projeto.

Vai abrir a janela abaixo de configuração do projeto:
Apenas usuários registrados e ativados podem ver os links., Clique aqui para se cadastrar...

1. Clique na aba Multimedia;

2. Escolha o projeto do tipo SDL;

3. Dê um nome ao projeto;

4. Escolha a linguagem: C ou C++;

5. Clique em OK para criar o projeto;

6. Salve o seu projeto.

Passo 4 - O Código

Ao iniciar o projeto, é criado um código de exemplo da SDL para mostrar a mesma em ação. Selecione todo o código e apague. A partir de agora o projeto está pronto para que você inicie o seu código para criar aplicações que usam a biblioteca.


CRIANDO A TELA

* Como criar uma tela em SDL;
* Os vários formatos de telas;
* Como adicionar título às janelas ;


Criando uma Tela

O comando que cria uma tela em SDL é SDL_SetVideoMode. Na verdade uma tela nada mais é que uma surface, assim como as imagens utilizadas nos programas. Surfaces são as unidades primitivas de qualquer aplicação gráfica em SDL, pois as mesmas são buffers de imagens, isso é, áreas da memória utilizadas para armazenar imagens.

Assim, antes de configurar a tela temos que criar uma surface e depois aplicar sobre ela o comando SDL_SetVideoMode para configuração da tela. Veja o exemplo abaixo.

Exemplo 1

#include <SDL/SDL.h>
 
SDL_Surface* tela = NULL;
 
int main (int argc, char *argv[])
{  
    SDL_Init (SDL_INIT_VIDEO);
   tela = SDL_SetVideoMode(400,300,32,SDL_SWSURFACE);
   
   SDL_Delay(3000);
      
    SDL_Quit();
    return 0;
}

A linha abaixo declara uma surface de nome tela e dá a mesma o valor nullo. Veja que tela será uma instância da estrutura SDL_Surface que é o protótipo para surfaces, uma struct.

SDL_Surface* tela = NULL;

Para trabalhar com imagens e necessário iniciar o subsistema de vídeo.

SDL_Init (SDL_INIT_VIDEO);

Agora sim podemos configurar o modo de vídeo com o comando SDL_SetVideoMode. Os dois primeiros parâmetros 400, 300 são as dimensões da tela. O parâmetro 32 se refere a quantidade de bits por pixel e o último parâmetro é a flag do tipo da surface. Nesse caso estamos definindo uma surface do tipo SW, o que significa que estamos criando um buffer na área principal da memória, a memória ram. A sigla sw vem de software, isso é, não é acelerado por hardware e assim não usará a memória de vídeo.

tela = SDL_SetVideoMode(400,300,32,SDL_SWSURFACE);

A linha abaixo faz com que o programa aguarde 3 segundos até continuar a executar. Se não fizéssemos isso não seria possível visualizar a tela criada, pois o programa executaria muito rápido. O valor passado foi 3.000, devido o fato de que o tempo deve estar em milésimos de segundos.

SDL_Delay(3000);

Os vários formatos de telas

A SDL é de fato uma biblioteca muito poderosa e versátil, dando ao usuário inúmeras possibilidades de configurações. Isso também é verdade na hora de criar seu ambiente de reprodução de imagens, onde você pode escolher uma das diversas formas de trabalhar com ela. Veja abaixo a tabela dos vários tipos de flags para a criação de surfaces de vídeo e o que significa a sigla de cada uma delas.

SDL_SWSURFACE: a surface será criada na memória ram.
SDL_HWSURFACE: a surface será criada na memória de vídeo.
SDL_ASYNCBLIT: usa método de blitagem assíncrono.
SDL_ANYFORMAT: usa o padrão atual da tela.
SDL_HWPALETTE: usa todas as 256 cores da paleta.
SDL_DOUBLEBUF: usar duplo buffer (composição e exibição).
SDL_FULLSCREEN: aplicação deve rodar em tela cheia.
SDL_OPENGL: usa SDL com OpenGL.
SDL_OPENGLBLIT: usa SDL com OpenGL mas vai renderizar com SDL.
SDL_RESIZABLE: uma janela redimensionável.
SDL_NOFRAME: janela sem bordas.

Adicionando títulos às janelas
Os captions são as legendas de títulos das bordas das janelas. Podemos colocar títulos nas janelas de aplicações sdl por meio do comando SDL_WM_SetCaption. Para isso basta passar a esse comando a mensagem que desejamos que seja exibida, entre aspas.

Exemplo 2

#include <SDL/SDL.h>
 
SDL_Surface *tela = NULL;
 
int main (int argc, char *argv[])
{
    SDL_Init (SDL_INIT_EVERYTHING);
   tela = SDL_SetVideoMode (640, 480, 16, SDL_SWSURFACE);
   
   SDL_WM_SetCaption ("Cr!tic4L_SOFT RODANDO...", NULL);
   
    SDL_Delay(3000);
    SDL_Quit();
   
    return 0;
}

A linha abaixo é a responsável pela exibição do título da janela.

SDL_WM_SetCaption ("Cr!tic4L_SOFT RODANDO...", NULL);

Carregando e Exibindo Imagens

* Como carregar uma imagem;
* Como exibir imagens usando a SDL;
* Exibir imagens com o tamanho correto;

1. Carregando e exibindo imagens

A SDL carrega arquivos do tipo .bmp. Mas se você precisar carregar outro tipo de imagens, poderá fazer isso ao incluir a biblioteca auxiliar SDL_Image ao seu projeto. A imagem carregada deverá ser alocada em uma surface, um buffer de imagem, por isso o primeiro passo é declarar uma surface para a imagem.

SDL_Surface* imagem = NULL;

Se estamos trabalhando com imagens, obrigatoriamente teremos que inicializar o subsistema de imagens para que os comandos de manipulação das mesmas fiquem disponíveis.

SDL_Init (SDL_INIT_VIDEO);

Feito isso, já podemos carregar uma imagem por meio da função SDL_LoadBMP. Para isso passamos como parâmetro uma string com nome ou localização e nome do arquivo bitmap a ser carregado.

imagem = SDL_LoadBMP("Foto.bmp");

Uma coisa importante a considerar é que você não sabe previamente qual é profundidade de cor da imagem carregada e exibir uma imagem com paleta diferente da paleta de cor da tela vai desfigura a mesma. Para resolver esse problema, você pode usar a função SDL_DisplayFormat, que vai converter a imagem para o formato de cores da tela.

imagem = SDL_DisplayFormat(imagem);

Agora já podemos exibir a imagem. Para isso vamos fazer uma Blitagem (Blitting). O termo Blit é uma forma contraída de “Block Transfer”, então, fazer uma blitagem é transferir um bloco de pixels de um buffer para outro. No nosso caso, estamos transferindo um bloco de pixels do buffer da imagem para o buffer da tela.

Para fazer uma blitagem precisamos de duas surfaces e de dois retângulos como parâmetros, mas os retângulos podem ser definidos como NULL, e assim usaremos o parâmetro padrão que é posição 0,0 e tamanho total da surface.

Dessa forma, o comando SDL_BlitSurface aceita por ordem os seguintes parâmetros: surface recurso, retângulo recurso, surface destino e retângulo destino. No nosso exemplo estamos fazendo a blitagem da imagem na tela, por isso “imagem” é a surface recurso e “tela” é a surface destino. Estamos definindo os retângulos como Null, assim a imagem vai ser toda exibida a partir do canto superior esquerdo da tela.

SDL_BlitSurface(imagem, NULL, tela, NULL);

Como você já sabe, para que possamos ver os efeitos de renderização, temos que atualizar a surface. Na primeira linha abaixo é exatamente isso que fazemos e na segunda linha, fazemos o programa aguardar três segundos antes de ser encerrado.

SDL_UpdateRect(tela, 0, 0, 0, 0);
SDL_Delay(3000);

Para evitar qualquer problema com gerenciamento de memória, descarregue as surfaces de imagens quando não mais forem usadas por meio do comando SDL_FreeSurface.

SDL_FreeSurface(imagem);

Veja abaixo como ficou o código fonte completo se nosso exemplo de carregar e exibir imagens a partir de arquivos.

Exemplo 1

#include <SDL/SDL.h>
 
SDL_Surface* imagem = NULL;
SDL_Surface* tela   = NULL;

int main (int argc, char *argv[])
{  
    SDL_Init (SDL_INIT_VIDEO);
    tela = SDL_SetVideoMode(600,400,32,SDL_SWSURFACE);
   
    imagem = SDL_LoadBMP("Foto.bmp");
    imagem = SDL_DisplayFormat(imagem);
   
    SDL_BlitSurface(imagem, NULL, tela, NULL);
   
    SDL_UpdateRect(tela, 0, 0, 0, 0);
    SDL_Delay(3000);
   
    SDL_FreeSurface(imagem);
    SDL_Quit();
   
    return 0;
}

2.Blitando surfaces com o tamanho correto
O programa acima processa dados de forma desnecessária, pois considera a área total das surfaces. Em alguns programas, como veremos mais adiante, usamos apenas uma parte de um surface sendo desnecessário processar o resto. Por outro lado, o programa acima também peca pelo fato de não podermos escolher em que local da surface de destino a surface de origem será blitada.

Podemos resolver os dois problemas trabalhando com retângulos. Devemos definir um retângulo para a imagem recurso, e assim especificar qual parte dela nos interessa. Também podemos definir um retângulo para a imagem de destino e assim controlar em qual local da imagem de destino aquela imagem será blitada e até mesmo quais partes dessa imagem serão blitadas.

O exemplo abaixo é uma adaptação do exemplo anterior, mas agora usando retângulos para controlar as áreas das surfaces e seu local de exibição. Veja que a primeira coisa que fizemos foi declarar dois retângulos.

SDL_Rect R_Recurso;
SDL_Rect R_Destino;

O passo seguinte foi definir a largura e a altura desses retângulos como sendo idênticas às dimensões da imagem carregada. Isso cria um retângulo com o tamanho exato de pixels que serão blitados, isso é, transferidos de uma surface para outra.

R_Recurso.w = R_Destino.w = imagem->w;
R_Recurso.h = R_Destino.h = imagem->h;

A posição x e y da imagem de recurso é (0,0), pois vamos usar a imagem inteira e assim temos que pegar os pixels a partir do início da imagem. Lembrando que essa é a surface de origem, isso é, de onde os pixels serão copiados para serem transferidos para outra área.

R_Recurso.x = 0;
R_Recurso.y = 0;

Como desejamos exibir a imagem no centro da tela, as posições x e y do retângulo de destino são configuradas como (140,20), pois esse é o ponto inicial onde os pixels serão blitados.

R_Destino.x = 140;
R_Destino.y =  20;

Agora que já temos tudo definido nos retângulos então podemos fazer a blitagem passando ao comando o endereço dos retângulos que definem a forma como essa blitagem das imagens vai ocorrer.

SDL_BlitSurface(imagem, &R_Recurso, tela, &R_Destino);

Agora veja abaixo o código completo do programa que nos mostra como fazer um controle total da blitagem de imagens.

Exemplo2

#include <SDL/SDL.h>
 
SDL_Surface* imagem = NULL;
SDL_Surface* tela   = NULL;
 
int main (int argc, char *argv[])
{  
    SDL_Init (SDL_INIT_VIDEO);
    tela = SDL_SetVideoMode(600,400,32,SDL_SWSURFACE);
   
    imagem = SDL_LoadBMP("Foto.bmp");
    imagem = SDL_DisplayFormat(imagem);
   
    SDL_Rect R_Recurso;
    SDL_Rect R_Destino;
    R_Recurso.w = R_Destino.w = imagem->w;
    R_Recurso.h = R_Destino.h = imagem->h;
    R_Recurso.x = 0;
    R_Recurso.y = 0;
    R_Destino.x = 140;
    R_Destino.y =  20;
         
    SDL_BlitSurface(imagem, &R_Recurso, tela, &R_Destino);
   
    SDL_UpdateRect(tela, 0, 0, 0, 0);          
    SDL_Delay(3000);
   
    SDL_FreeSurface(imagem);
    SDL_Quit();
   
    return 0;
}

continua...

[inocente]

Hum... bom otimo sobre programação

[Billisilva]

Vlw ai pela ajuda estava estudando sobre criação de jogos e isso ai vai me ajuda muito :d

[~$N4P~]

Vlw Galera! Olhá SDL é exelente para quem ta começando na Programação de Jogos! Mais no entanto SDL só da Suporte á 2D se quiser fazer algum 3D, uma boa sugestão séria seu primo, OpenGL !

[luizfernandodag]

Eu baixei a o SDL no Dev mas a opção de projeto multimidia do SDL não aparece como no tutorial.... o que eu faço?

[~$N4P~]

Hum! estranho!! Bom verifique se baixou a versão correta do SDL, depois vai lá em Novo>Projeto>[na aba]MultiMedia escolha SDL !

[cmtamaki]

Boas dicas, estou a espera da continuação....