Einleitung

Was ist Allegro?

Allegro eine in C geschriebene Bibliothek für C/C++-Multimediaanwendungen. Es läuft auf allen großen Betriebssystem und steht unter der zlib-Lizenz. Allegro umfasst Funktionen für Grafiken, Sounds, Eingabe und Zeitsteuerung. Allegro kann mit SDL oder SFML verglichen werden.

Wo bekomme ich Allegro?

Allegro kann unter http://www.allegro.cc/ herutergeladen werden. Dort finden sich auch viele Informationen rund um Allegro. Um Allegro zu nutzen, müssen nach dem Download die Header und Libraries dem Compiler bekannt gemacht werden.

Das erste Fenster

Der Code

// Allegro-Header einbinden
#include <allegro5/allegro.h>
 
int main()
{
    // Konstanten für Bilschirmbreite/-höhe
    const int SCREEN_W = 640;
    const int SCREEN_H = 480;
    
    // Zeiger für das Fenster
    ALLEGRO_DISPLAY* display = 0;
    
    // Zeiger für die Event-Warteliste
    ALLEGRO_EVENT_QUEUE* eventQueue = 0;
    
    // Allegro initialisieren
    if(!al_init()) return -1;
    
    // Fenster erzeugen
    display = al_create_display(SCREEN_W, SCREEN_H);
    if(!display) return -1;
    
    al_install_keyboard();
 
    // Tastatureingabe registrieren
    eventQueue = al_create_event_queue();
    al_register_event_source(eventQueue, al_get_keyboard_event_source());
    
    bool running = true;
    while(running)
    {
        ALLEGRO_EVENT ev;
        al_wait_for_event(eventQueue, &ev);
        
        if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
        {
            switch(ev.keyboard.keycode)
            {
            case ALLEGRO_KEY_ESCAPE:
                running = false;
                break;
            }
        }
        
        // Display schwarz färben
        al_clear_to_color(al_map_rgb(0, 0, 0));
        
        // Fenster aktualisieren
        al_flip_display();
    }
    al_destroy_event_queue(eventQueue);
    al_destroy_display(display);
    
    return 0;
}

Erklärung

#include <allegro5/allegro.h>

Der benötigte Header für die Grundfunktionen wird eingefügt.

const int SCREEN_W = 640;
const int SCREEN_H = 480;

In diesen Konstanten werden Bilschirmbreite und -höhe deklariert und definiert. Alternativ könnte dies auch beim Aufruf von al_create_display() geschehen.

ALLEGRO_DISPLAY* display = 0;
ALLEGRO_EVENT_QUEUE* eventQueue = 0;

Dies sind zwei Zeiger für die spätere Verwendung eines Displays (Fenster) und einer Event-Warteschlange, wir setzen sie erst einmal auf 0, da wir sie erst später verwendet werden (siehe al_create_display und al_create_event_queue).

if(!al_init()) return -1;

Der Aufruf dieser Funktion initialisiert Allegro und gibt -1 zurück, wenn dies nicht erfolgreich war.

display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) return -1;

Hier wird ein mit den oben definierten Werten für Breite (SCREEN_W) und Höhe (SCREEN_H) ein Fenster erzeugt. Sollte dies nicht erfolgreich sein, wird ebenfalls -1 zurückgegeben.

al_install_keyboard();

Damit später die Tastatur zum Schließen unseres ersten Fensters benutzt werden kann, müssen wir die Tastatur in Allegro installieren.

eventQueue = al_create_event_queue();
al_register_event_source(eventQueue, al_get_keyboard_event_source());

Hier erstellen wir die Event-Warteschleife und weißen sie dem bereits vorher deklariertem Zeiger zu. Zusätzlich geben wir die Tastatur als Quelle für die Event-Warteschleife an.

bool running = true;
while(running)

Hier beginnt unsere while-Schleife, die so lange läuft, bis running auf false gesetzt wird.

ALLEGRO_EVENT ev;
al_wait_for_event(eventQueue, &ev);

Hier erzeugen wir eine Variable vom Typ ALLEGRO_EVENT, die wir, wie der Name schon vermuten lässt, für das Arbeiten mit Events verwenden werden. Danach lassen wir Allegro auf ein Event warten.

if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
    switch(ev.keyboard.keycode)
    {
    case ALLEGRO_KEY_ESCAPE:
        running = false;
        break;
    }
}

Hier püfen wir, ob das Event aus dem Herunterdrücken einer Taste bestand. Danach prüfen wir, ob es die Taste Escape war. Trifft dies zu, wird running auf false gesetzt, und die while-Schleife wird somit nicht weiter ausgeführt.

al_clear_to_color(al_map_rgb(0, 0, 0));
al_flip_display();

Wir füllen die Anzeige mit der Farbe Schwarz und sorgen danach dafür, dass das Ganze sichtbar wird. Allegro benutzt hier einen Doppelpuffer, d.h. man zeichnet zunächst in einen unsichtbaren Speicherbereich, der dann erst durch al_flip_display sichtbar gemacht wird.

al_destroy_event_queue(eventQueue);
al_destroy_display(display);
    
return 0;

Zum Schluss "zerstören" wir noch das Fenster und die Event-Warteschlange und geben 0 zurück, um das Programm zu beenden.