Biblioteca Allegro Monitoria de Introdução à computação – if669ec

Thais Alves de Souza Melo - tasm

2011.2

Instalação

• Code::Blocks do site da disciplina já o possui instalado

• Guia para instalação manual: http://wiki.allegro.cc/index.php?title=Code::Blocks

• Instalação facilitada: http://www.unidev.com.br/phpbb3/viewtopic.php?f=11&t=45265

Criação do Projeto

Hello World

Init( )

• int allegro_init(); • Inicializa o Allegro, devendo ser chamada antes de qualquer outra

função da biblioteca.

• int install_timer(); • int install_keyboard(); • int install_mouse();

• Funções que instalam, respectivamente, o temporizador, teclado e mouse.

• int install_sound(int digi_card, int midi_card, char *cfg_path); • Não vem por padrão no init() ;. Ativa o som no Allegro. • Digi_card e midi_card referem-se aos controladores de som digital e

MIDI, respectivamente. Passá-los como DIGI_AUTODETECT e MIDI_AUTODETECT para que o allegro selecione o driver.

• O parâmetro cfg_path refere-se à compatibilidade com versões anteriores, e pode ser ignorado passando-se NULL.

Init( )

• void set_color_depth(int depth); • Determina a quantidade de bits a serem utilizados pelos gráficos

(depth). Posem ser: • 8 (256 cores)

• 15 (32768 cores)

• 16 (65536 cores)

• 24 (aproximadamente 32 milhões de cores)

• 32 (aproximadamente 4 bilhões de cores)

• int set_gfx_mode(int card, int w, int h, int v_w, int v_h); • Inicializa o modo gráfico. Card representa o driver gráfico a ser

utilizado (ex.: GFX_AUTODETECT, para que o Allegro detecte automaticamente a placa de video), w e h representam o tamanho horizontal e vertical em pixels da tela. v_w e v_h indicam a resolução de uma possível tela virtual.

Deinit( )

• void allegro_exit();

• Utilizada ao final do programa para finalizar o Allegro. Não precisa ser necessariamente chamada, pois allegro_init determina que ela seja chamada automaticamente quando o programa é encerrado.

Alguns Tipos Definidos

• BITMAP

• Tipo definido pelo Allegro para manipular facilmente bitmaps, que seriam matrizes de pixels, em que cada elemento indica uma cor.

• Declaração: BITMAP *nome ;

• O allegro define automaticamente um BITMAP screen, referente à tela.

• PALLETE

• Vetor de 256 posições em que cada uma representa um código de cor.

• Declaração: PALLETE nome ;

Alguns Tipos Definidos

• FONT

• Contém a descrição das fontes que podem ser utilizadas na tela

• Declaração: FONT *nome ;

• MIDI

• Declaração: MIDI *nome ;

• SAMPLE

• Declaração: SAMPLE *nome ;

• Os tipos FONT e PALLETE não serão utilizados.

Teclado

• O Allegro trabalha com um vetor key[] de 127 posições, cujos elementos representam as teclas. Para facilitar, são definidas constantes que facilitam a busca de um elemento no vetor:

• Exemplo: key[KEY_ESC]

Tecla Código na Array Tecla Código na Array A, B ... Z KEY_A, KEY_B...KEY_Z Pause KEY_PAUSE

Teclado Numérico 0 a 9 KEY_0_PAD ... KEY_9_PAD

Barra de Espaço KEY_SPACE

Teclado Normal 0 a 9 KEY_0 ... KEY_9 Print Screen KEY_PRTSCR Esc KEY_ESC Shitf Esquerdo KEY_LSHIFT Enter KEY_ENTER Shift Direito KEY_RSHIFT Seta para a Direita KEY_RIGHT Control Esquerdo KEY_LCONTROL Seta para a Esquerda KEY_LEFT Control Direito KEY_RCONTROL Seta para Cima KEY_UP Alt esquerdo KEY_ALT Seta para Baixo KEY_DOWN Alt Direito KEY_ALTGR

Exemplos

• while(!key[KEY_ESC]) {

...

}

• if(key[KEY_ENTER])

{

...

}

Executará o código enquanto ESC Não estiver pressionado.

Entrará no if apenas se ENTER estiver Pressionado

Texto

• void textout_ex(BITMAP *bmp, const FONT *f, const char *s, int x, int y, int color, int bg); • Imprime uma string na tela na posição x, y. Color refere-se a cor do texto e bg a

cor do fundo do texto.

• void textprintf_ex(BITMAP *bmp, const FONT *f, int x, int y, int color, int bg, const char *fmt, ...); • Imprime uma string na tela de forma parecida à printf(), permitindo a passagem

de parâmetros como %d, %c etc..

• int makecol(int r, int g, int b); • Converte cores do formato RGB para o formato aceito pelas funções.

• Obs1.: 0 equivale a cor preta e -1 ou makecol(255, 0, 255) à transparente. • Obs2.: Passar o parâmetro FONT como “font” (sem aspas) para utilizar a fonte

própria do sistema. • Obs3.: Ambas possuem variantes que imprimem o texto centralizado,

justificado ou alinhado à direita.

Primitivas de Imagem

• int getpixel(BITMAP *bmp, int x, int y);

• Lê um o pixel da coordenada (x, y) de um BITMAP.

• int getr(int c);

• int getg(int c);

• int getb(int c);

• Retornam respectivamente os valores de R, G e B de um determinado pixel (pego pelo getpixel()).

• void putpixel(BITMAP *bmp, int x, int y, int color);

• void line(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);

• void triangle(BITMAP *bmp, int x1, y1, x2, y2, x3, y3, int color);

• void rect(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);

• void circle(BITMAP *bmp, int x, int y, int radius, int color);

Carregando imagens

• BITMAP *create_bitmap(int width, int height); • Cria um bitmap de memória do tamanho especificado.

• BITMAP *load_bitmap(const char *filename, RGB *pal); • Carrega um arquivo bitmap do disco. RGB* pal refere-se à paleta de cores,

aplicada apenas a imagens de 8 bits. Passar como NULL.

• void destroy_bitmap (BITMAP *bitmap); • Libera a memória utilizada por um bitmap.

• void clear_bitmap(BITMAP *bitmap); • Limpa um bitmap para a cor preta.

• void clear_to_color(BITMAP *bitmap, int color);

• Análoga àcima, porém com a escolha da cor para a qual será limpo o bitmap.

• Obs.: Não é necessário utilizar a função create_bitmap antes da load_bitmap!

Blitting e Sprites

• void blit(BITMAP *source, BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height); • Copia uma área retangular (width x height) do bitmap de fonte (source)

em um bitmap de destino (dest). Não aceita o rosa puro como transparante.

• void draw_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y);

• Copia o bitmap de origem (sprite) diretamente no bitmap de destino (bmp). Aceita o rosa puro como transparente.

• Obs.: Ambas as funções acima possuem variantes que espelham, aumentam ou rotacionam as imagens.

Exemplo

• ...

• BITMAP* buffer, *imagem ;

• buffer = create_bitmap(60, 60) ;

• imagem = load_bitmap(“imagem.bmp”, NULL) ;

• ...

• blit(imagem, buffer, 100, 100, 0, 0, 60, 60) ;

• draw_sprite(screen, buffer, 400, 300) ;

• ...

• destroy_bitmap(imagem) ;

• destroy_bitmap(buffer) ;

• ...

Podemos usar o clear_bitmap() aqui, caso ainda precisemos usar os BITMAPs.

Double Buffering

• Desenhar os bitmaps diretamente no screen faz e depois limpá-lo faz com que a tela “pisque” a cada troca de frame, gerando um efeito visualmente desconfortável. Para evitar esse problema, é utilizada a técnica de double buffering:

• Cria-se um BITMAP* buffer de memória, em geral do tamanho da tela e nele são desenhados todos os elementos desejados.

• O buffer é desenhado então na tela e é depois limpado, e assim sucessivamente para os outros frames. Não usar clear_bitmap na screen!

Exemplos Sem Double Buffering:

int main(){

init();

while (!key[KEY_ESC]){

textout_centre_ex(screen, font, "Sem Double Buffering", 320, 240, makecol(255, 255, 255), 0);

clear_bitmap(screen) ;

}

deinit();

return 0;

}

END_OF_MAIN()

Com Double Buffering: int main(){ init(); BITMAP* buffer = create_bitmap(640, 480) ; while (!key[KEY_ESC]){ textout_centre_ex(buffer, font, "Com Double Buffering", 320, 240, makecol(255, 255, 255), 0); draw_sprite(screen, buffer, 0, 0) ; clear_bitmap(buffer) ; } deinit(); return 0; } END_OF_MAIN()

Som – MIDI

• MIDI *load_midi(const char *filename); • Carrega um arquivo MIDI.

• void destroy_midi(MIDI *midi); • Libera a memória do arquivo carregado.

• int play_midi(MIDI *midi, int loop); • Toca o arquivo MIDI indicado, parando a execução de qualquer

outro MIDI. Se loop receber qualquer valor diferente de 0, tocará até ser parado ou substituído.

• void stop_midi(); • Pára qualquer MIDI que esteja sendo executada (funciona de

maneira semelhante à play_midi(NULL, false) ;)

Som – Sample

• SAMPLE *load_sample(const char *filename); • Carrega um SAMPLE.

• void destroy_sample(SAMPLE *spl); • Libera a memória ocupada por um SAMPLE.

• int play_sample(const SAMPLE *spl, int vol, int pan, int freq, int loop); • Toca um sample. Vol e pan variam de 0(min/esquerda) à 255(máx/direita).

Freq indica a velocidade com que o som é executado, sendo 1000 a velocidade normal. Loop indica a quantidade de vezes para repetir um som.

• void stop_sample(const SAMPLE *spl); • Pára a execução de um sample.

• Obs.: Diferente dos MIDI, podem ser executados vários SAMPLEs ao mesmo tempo.

Mouse

• O mouse em allegro se comporta como um objeto, possuindo as variáveis mouse_x e mouse_y que indicam sua posição.

• A variável mouse_b indica qual botão do mouse está sendo pressionado, sendo o bit 0 o botão esquerdo, o bit 1 o botão direito e o bit 2 o botão do meio. • Sintática da comparação:

• If(mouse_b & 1) printf(“Botao esquerdo apertado”) ;

• If(!(mouse_b & 1)) printf(“Botao esquerdo não apertado”) ; • Atenção: comparação bit a bit! (apenas um ‘&’)

• void position_mouse(int x, int y); • Coloca o mouse na posição x e y indicada

• void show_mouse(BITMAP *bmp); • Desenha o mouse no bitmap apontado. Para não exibir mouse, passar NULL

como argumento. Obs.: Funciona apenas com o timer instalado

Temporizador

• A priori, para o controle da velocidade do jogo, temos a função void rest(unsigned int time); que faz com que o computador aguarde “time” milissegundos para executar o próximo comando.

• Porém, em computadores mais lentos, isso pode prejudicar o andamento do jogo, pois os comandos seriam executados mais lentamente, o que levaria a necessidade de um rest menor ou até sua ausência para que a velocidade se mantivesse.

• O uso de temporizadores resolve este problema.

Temporizador - Exemplo volatile long int contador = 0 ; void timer_game () ; … void timer_game () { contador++ ; } END_OF_FUNCTION(timer_game) ; ... int main() {

... LOCK_VARIABLE(contador) ; LOCK_FUNCTION(timer_game) ; install_int (timer_game, TBF) ; ...

}

Variável global!

TBF = Time Between Frames

Exercício

• Implementar um space invaders simplificado em Allegro. Deve possuir um menu com duas opções:

• Selecionando a primeira, deverá aparecer uma nave que se move na horizontal controlada pelo usuário.

• Ao pressionar ESPAÇO, a nave deve atirar um projétil (velocidade constante) na direção em que está olhando.

• Ao pressionar a tecla P, deve voltar ao menu inicial.

• A segunda opção é a de sair do programa.

Referências

• http://www.allegro.cc/

• http://www.allegro.cc/manual/ - Manual com funções das versões 4 e 5 do Allegro.

• http://alleg.sourceforge.net/

Tutoriais

• http://www.dcc.ufrj.br/~abdalla/allegro.html

• http://www.glost.eclipse.co.uk/gfoot/vivace/ (Em Inglês)

• http://equipe.nce.ufrj.br/adriano/c/apostila/allegro/docs/allegro.html