Einleitung

Was ist Allegro?

Allegro ist 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 (siehe Übersicht im Einsteigerartikel) verglichen werden. Es gibt verschiedene Versionen: 4 und 5. Die Version 4 wird nicht mehr weiterentwickelt und abwärtskompatibel bis zur Version 2. Die Version 5 hat eine komplett neue API und ist daher NICHT abwärtskompatibel zu alten Allegro Versionen.

Wo bekomme ich Allegro?

Allegro kann unter http://www.allegro.cc/files 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.

Installation von Allegro

Vorkompilierte Dateien

Auf http://www.allegro.cc/files kann man sich Allegro runterladen. Unter "Windows Binaries" oder nur "Binary" kann man sich die vorkompilierte Version von Allegro für seinen Compiler runterladen. Die Dateien der Ordner \bin, \include und \lib steckt man dann einfach in die Ordner \bin, \include und \lib seines Compilers. Diese liegen bei den meisten Compilern zwar im Stammverzeichnis, bei Microsoft Visual C++ aber in ..\(Name euerer Visual C++ Version\VC\.

Quellcode kompilieren

Wenn der Quellcode für euer Betriebsystem/Compiler nicht erhältlich ist, müsst ihr Allegro erst selbst kompilieren. Dazu ladet ihr den "Source Code" von http://www.allegro.cc/files für euer Betriebssytem runter. Wie man dann den Quellcode richtig kompiliert, steht ihm Ordner \docs. Dort sind verschiedene Compiler angegeben.

Allegro verwenden

Wenn ihr versucht, ein Projekt mit Allgro zu kompilieren z.B. das hier:

#include <allegro.h>  //Füge Allegro ein
 
int main()
{
   allegro_init(); //Starte Allegro
   install_keyboard();  //Installiere die Tastatur
    set_color_depth(32); //Setze einen 32Bit Farbmodus
    set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0); //Erstelle ein Fenster der Größe 640x480
    set_window_title("Test"); //Titel des Fensters wird benannnt
 
    while(!key[KEY_ESC])   //solange ESC nicht gedrückt wird
{
    //Schreibe     Bildschirm, Schriftart, X-Position, Y-Position, Schriftfarbe, Hintergrund-Farbe, Text
      textprintf_ex(screen, font, 300, 300, makecol(255, 255, 255), makecol(0, 0, 0), "Hallo Welt!");  
}
return 0;
}
END_OF_MAIN();     //Sage Allegro, das das Programm vorbei ist

erhalten wir etwa diese Fehler:

 [Linker error] undefined reference to `__dyn_tls_init_callback' 
 [Linker error] undefined reference to `__cpu_features_init' 

Wir müssen hier die liballeg.a einbinden. Unter Dev-Cpp geht das so: Drücke ALT + P gehe zum Reiter "Parameter" Klicke auf Bibliothek/Objekt hinzufügen wähle die liballeg.a im Ordner lib\. Manchmal heißt sie auch alleg.lib.

Das erste Fenster (Allegro 5)

Der Code

(Dieser Code ist für Allegro 5.)

// 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;
    
    // Tastatureingabe registrieren
    al_install_keyboard();
    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.