Allegro-Tutorial

Aus Spieleprogrammierer-Wiki
Wechseln zu: Navigation, Suche

Inhaltsverzeichnis

Einleitung

Was ist Allegro?

Allegro ist eine in C geschriebene Bibliothek für C/C++-Multimediaanwendungen, die auf allen großen betriebssystemen läuft und unter der zlib-Lizenz steht. Allegro umfasst Funktionen für Grafiken, Sounds, Eingabe und Zeitsteuerung und 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.

Installation von Allegro

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. Danach geben wir noch in den Projekteinstellungen der IDE die entsprechenden Pfade der Header- und Bibliotheksdateien an. In unserem Fall sind das die Ordner \include und \lib. Desweiterern müssen die benötigten DLLs in den Projektordner kopiert werden.

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.

Beispielanwendung

Um einen leichten Einstieg in die Programmierung mit Allegro zu ermöglichen, schauen wir uns ein Beispiel an, welches alle wichtigen Punkte verwendet. Dazu gehören:

Um all dies zu verwenden, werden wir ein Fenster erstellen, in dem man ein Bild bewegen kann, die Framenummer angezeigt wird und im Hintergrund ein Sample abgespielt wird.

Header

Wie (fast) jede C++-Anwedung fangen wir mit dem Einbinden der benötigten Header-Dateien an, wir benötigen dazu mehrere um alle Themen abdecken zu können.

#include <allegro5\allegro.h>
#include <allegro5\allegro_ttf.h>
#include <allegro5\allegro_font.h>
#include <allegro5\allegro_image.h>
#include <allegro5\allegro_audio.h>
#include <allegro5\allegro_acodec.h>

Zusäzlich müssen wir noch die allegro-5.0.4-monolith-md.lib einbinden bzw. die allegro-5.0.4-monolith-md-debug.lib wenn wir im Debug-Modus arbeiten. Zusätzlich müssen wir noch die allegro-5.0.4-monolith-md.lib und wenn wir im Debug-Modus arbeiten die allegro-5.0.4-monolith-md-debug.lib einbinden.

Variablen-Deklaration

In diesem Tutorial arbeiten wir, um es einfach zu halten, nur mit der Main-Funktion. Zu beginn deklarieren wir alle nötigen Variablen und Zeiger, welche wir in der Anwendung verwenden. Dazu gehören Standard-C++ Variablen aber auch Zeiger auf Allegro-Strukturen, die wir z.B. für die Bitmap benötigen.

int main()
{
    int screenWidth = 800;
    int screenHeight = 600; 
    bool running = true;
    bool redraw = true;
    bool key[4] = {false, false, false, false};
    enum KEYS {UP, DOWN, LEFT, RIGHT};
    int posX, posY, bitmapWidth, bitmapHeight;
    int frameNumber = 0;
 
    ALLEGRO_DISPLAY* display = 0;
    ALLEGRO_EVENT_QUEUE* eventQueue = 0;
    ALLEGRO_EVENT ev;
    ALLEGRO_BITMAP* bitmap = 0;
    ALLEGRO_SAMPLE* sample = 0;
    ALLEGRO_FONT* font = 0;
    ALLEGRO_TIMER *timer = 0;

Da Allegro nicht den Zustand der Tasten speichert, sondern nur über Änderungen der Zustände informiert, müssen wir den Status selbst speichern. In diesem Fall werden nur die Pfeiltasten benötigt, weshalb ein bool-Array ausreichend ist. Um eine bessere Lesbarkeit zu erreichen, erstellen wir eine Aufzählung von 0 bis 3 durch welches Element des Arrays welche Taste repräsentiert wird.

Fenster erstellen

Bevor wir das eigentliche Fenster erstellen können, müssen wir erst Allegro initialisieren. Dazu rufen wir die Funktion al_init auf und überprüfen, ob sie korrekt ausgeführt werden konnte. Wenn eine Funktion nicht korrekt ausgeführt werden konnte, setzen wir die Variable 'running' auf 'false', damit die Game-Loop gar nicht erst begonnen wird. Alterantiv könnten wir auch mit einem return das Programm beenden, allerdings wird dann der Speicher evtl. nicht richtig freigegeben.

    if(!al_init())
        running = false;

Ist dies der Fall, können wir mit dem Aufruf der Funktion al_create_display das Fenster erstellen. Dazu übergeben wir ihr die gewünschte Fensterhöhe, bzw. -breite. Auch hier überprüfen wir wieder ob sie korrekt ausgeführt werden konnte. ist dies der Fall, sind wir bereit mit dem Erstellen des Fensters fertig.

    display = al_create_display(screenWidth, screenHeight);
    if(!display)
        running = false;

Bitmap laden

Um ein Bild darstellen zu können, muss zuerst das entsprechende Addon, das für die Bearbeitung von Bildern benötigte Addon initialisiert werden. Danach laden wir das eigentliche Bild und berechnen seine Startposition, damit es am Anfang in der Mitte des Fensters zu sehen ist. Für dieses Beispiel heißt das Bild Test.png. Zeichnen können wir die Bitmap später mit der Funktion al_draw_bitmap. Dazu übergeben wir den Bitmap-Zeiger, die X- und Y-Position, sowie eine 0 als zusätzliche Flags. Datei:Test.png

    al_init_image_addon();
    bitmap = al_load_bitmap("Test.png");
    if(!bitmap)
        running = false;
    bitmapWidth = al_get_bitmap_width(bitmap);
    bitmapHeight = al_get_bitmap_height(bitmap);
    posX = (screenWidth / 2) - (bitmapWidth / 2);
    posY = (screenHeight / 2) - (bitmapHeight / 2);


Sample laden

Ein Sample ist im Prinzip eine Musikdatei, die z.B. als Hintergrundmusik verwendet wird. Auch hier müssen wir erst die Audio-Schnittstelle von Allegro aktivieren bevor wir unsere Audiodatei, in diesem Fall Test.wav, verwenden können. Zusätzlich muss noch die Anzahl der Samples, welche wir verwenden möchten, festgelgt werden.

    al_install_audio();
    al_init_acodec_addon();
    al_reserve_samples(1);
    sample = al_load_sample("Test.wav");

Abspielen können wir das Sample später mit der Funktion al_play_sample, dieser übergeben wir den Zeiger des Samples, die Lautstärke, die Position (-1: links, 0: mittig, 1: recht), die Geschwindigkeit (1: normal), die Wiedergabeart (ALLEGRO_PLAYMODE_ONCE oder ALLEGRO_PLAYMODE_LOOP) und eine 0, da der letzte Parameter für uns erstmal nicht relevatn ist.


Texte zeichnen

Als nächstes beschäftigen wir uns mit dem zeichnen von Schriftzügen innerhalb des Fensters. Dazu initialisieren wir zuerst die entsprechenden Addons und laden eine .ttf-Datei. Beim Laden ist zu beachten, dass wir hier eine feste Größe angeben, die wir später nicht mehr ändern können. Wenn wir zusätzlich eine andere Schriftgröße verwenden möchten, müssen wir die Datei ein zweites mal Laden, mit einem zweiten ALLEGRO_FONT-Zeiger.

    al_init_font_addon();
    al_init_ttf_addon();
    font = al_load_font("Test.ttf", 16, 0);

Danach können wir an jeder Stelle innerhalb der Anwendung Texte in die Szene einbauen. Dazu stehen uns zwei unterschiedliche Funktionen zur Verfügung. Die erste zeichnet nur den reinen Text, die zweite kann zusätzlich noch Variablen verarbeiten (ähnlich der printf-Funktion in C).

al_draw_textf(font, al_map_rgb(r, g, b), X, Y, Flags, "text.. %i", Variablen...);
al_draw_textf(font, al_map_rgb(r, g, b), X, Y, Flags, "text...");

Timer erstellen

Damit wir in unserer Anwedung mit der Zeit arbeiten können, erstellen wir uns einen Timer. Dazu rufen wir die Funktion al_create_timer auf und Übergeben ihr als Parameter die Dauer eines einzelnen Frames. Wenn wir z.B. 60 FPS haben wollen, geben wir als Parameter 1.0 / 60 an. Danach überprüfen wir, ob der Timer erstellt werden konnte.

    timer = al_create_timer(1.0 / 60);  // 60 FPS
    if(!timer)
        running = false;


Event-Quellen

Als Event-Quellen bezeichnen wir all die Dinge, die ein Event auslösen können und somit Einfluss auf den Ablauf der Anwedung nehmen können. Für unsere Beispielanwendung sind dies:

Damit wir die Tastatur verwenden können, machen wir sie zunächst mit der Funktion al_install_keyboard für Allegro zugänglich. Danach erstellen wir die Event-Queue, dies ist eine Art Warteschlange, in der die Events, welche noch nicht verarbeitet wurden, gespeichert werden und registrieren die oben genannten Event-Quellen.

    // Tastatur zugänglich machen
    al_install_keyboard();
 
    // Event-Queue erstellen
    eventQueue = al_create_event_queue();
    al_register_event_source(eventQueue, al_get_keyboard_event_source());
    al_register_event_source(eventQueue, al_get_timer_event_source(timer));
    al_register_event_source(eventQueue, al_get_display_event_source(display));


Die Game-Loop

Die Game-Loop ist eine Schleife, die solange ausgeführt wird, bis das Programm beendet wird. Sie verarbeitet die Eingabe des Benutzers, berechnet die Szene neu und zeichnet diese dann. Bevor wir nun die Game-Loop programmieren können, zeichnen wir die Ausgangsszene Zum Zeichnen der Szene verwendet Allegro einen Front- und einen Back-Buffer. Die Szene wird in den Back-Buffer gezeichnet und dann werden die beiden Buffer vertauscht, so dass das fertige Bild auf den Monitor erscheint.
Um den Back-Buffer zu leeren verwenden wir die Funktion al_clear_to_color, welche den Back-Buffer mit einer von uns definierten Farbe, in diesem Fall Schwarz, überschreibt. Danach zeichnen wir das erste Mal unseren Frame-Counter und unsere Bitmap in das Fenster und vertauschen die Buffer mit der Funktion al_flip_display.

Danach starten wir noch das Abspielen des Samples und den Timer.

    // Szene zeichnen
    al_clear_to_color(al_map_rgb(0, 0, 0));
    al_draw_textf(font, al_map_rgb(0, 125, 0), 32, 32, 0, "Frame: %i", frameNumber);
    al_draw_bitmap(bitmap, posX, posY, 0);
    al_flip_display();
 
    // Sample abspielen
    al_play_sample(sample, 0.5, 0, 1, ALLEGRO_PLAYMODE_ONCE, 0);
 
    // Timer starten
    al_start_timer(timer);

Nun programmieren wir die Game-Loop. Diese ist eigentlich nur eine while-Schleife, die solange ausgeführt wird, bis das Fenster geschlossen wird. Sie besteht aus mehreren Teilschirtten:

  1. Events abfragen
  2. Frame-Counter erhöhen
  3. Bitmap-Position updaten
  4. Abfragen ob das Fenster geschlossen wurde
  5. Tastatur-Status verarbeiten
  6. Szene neu zeichnen

Die ersten zwei Schritte sind leicht zu realisieren. Events fragen wir mit der Funktion al_wait_for_event ab. Die Funktion erhält als Parameter den Event-Queue-Zeiger und die Adresse des Event-Speichers.
Den Frame-Counter erhöhen wir einfach, indem wir den Framecounter in jedem Durchlauf um 1 erhöhen.

// Game-Loop
    while(running)
    {
        // Events abfragen
        al_wait_for_event(eventQueue, &ev);
 
        // Frame-Counter erhöhen
        frameNumber++;

Anschließend berechnen wir die neue Position des Bitmaps, dies soll in jedem Durchlauf, wenn die entsprechende Pfeiltaste gedrückt ist, um vier Pixel verschoben werden. Zusätzlich kontrollieren wir, dass die neue Position innerhalb des sichtbaren Bereichs des Fensters liegt, ist dies nicht der Fall, wird die Bitmap nicht verschoben. Damit dies in jedem Durchlauf passiert, kontrollieren wir ob es ein Event ist, das vom Timer ausgelöst wurde (ALLEGRO_EVENT_TIMER). Zusätzlich setzen wir die Variable redraw auf true, damit die Szene ebenfalls neu gezeichnet wird.

        if(ev.type == ALLEGRO_EVENT_TIMER)
        {
            // Verschiebung nach oben
            if(key[UP] && posY >= 0)
                posY -= 4.0;
 
            // Verschiebung nach unten
            if(key[DOWN] && posY <= (screenHeight - bitmapHeight))
                posY += 4.0;
 
            // Verschiebung nach links
            if(key[LEFT] && posX >= 0)
                posX -= 4.0;
 
            // Verschiebung nach rechts
            if(key[RIGHT] && posX <= (screenWidth - bitmapWidth))
                posX += 4.0;
 
            redraw = true;
 
        }
        // .....

Danach überprüfen wir, ob der Benutzter evtl. das Fenster geschlossen hat. Ist dies der Fall setzen wir die Variable running auf false

        else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
        {
            running = false;
        }
        // .....

Als nächstes machen wir uns an das Abfragen der Tastatur. Wenn die entsprechende Taste gedrückt wird setzen wir das entsprechende Element des Arrays auf true und wenn sie wieder losgelassen wird auf false.

        // Taste gedrückt
        else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) 
        {
            switch(ev.keyboard.keycode) 
            {
                case ALLEGRO_KEY_UP:
                    key[UP] = true;
                break;
    
                case ALLEGRO_KEY_DOWN:
                    key[DOWN] = true;
                break;
 
                case ALLEGRO_KEY_LEFT: 
                    key[LEFT] = true;
                break;
 
                case ALLEGRO_KEY_RIGHT:
                    key[RIGHT] = true;
                break;
            }
        }
 
        // Taste losgelassen
        else if(ev.type == ALLEGRO_EVENT_KEY_UP) 
        {
            switch(ev.keyboard.keycode) 
            {
                case ALLEGRO_KEY_UP:
                    key[UP] = false;
                break;
 
                case ALLEGRO_KEY_DOWN:
                    key[DOWN] = false;
                break;
 
                    case ALLEGRO_KEY_LEFT: 
                key[LEFT] = false;
                break;
 
                case ALLEGRO_KEY_RIGHT:
                    key[RIGHT] = false;
                break;
 
                case ALLEGRO_KEY_ESCAPE:
                    running = false;
                break;
            }
        }
        // .....

Am Ende zeichnen wir die Szene, falls redraw auf true gesetzt ist, neu. Dazu leeren wir zuerst wieder den Back-Buffer, zeichen anschließend die Bitmap und den Text und tauschen zum Schluss wieder beide Buffer. Die Variable redraw setzen wir auf false, da die Szene erst beim nächsten Timing-Event wieder gezeichnet werden soll.

        if(redraw && al_is_event_queue_empty(eventQueue)) 
        {
            redraw = false;
            al_clear_to_color(al_map_rgb(0,0,0));
            al_draw_bitmap(bitmap, posX, posY, 0);
            al_draw_textf(font, al_map_rgb(0, 125, 0), 32, 32, 0, "Frame: %i", frameNumber);
            al_flip_display();
        }
    }

Anwendung korrekt beenden

Statt nun einfach das Programm zu beenden, wollen wir vorher noch den verwendeten Speicher freigeben, um mögliche Fehler zu vermeiden. Dazu rufen wir für jedes Objekt eine extra Funktion al_destroy_$object auf und übergeben ihr das entsprechende Objekt. Anschließend geben wir noch eine 0 an das Betriebssystem zurück und unsere Beispiel-Anwendung ist fertig.

    // Speicher freigeben
    al_destroy_sample(sample);
    al_destroy_font(font);
    al_destroy_bitmap(bitmap);
    al_destroy_timer(timer);
    al_destroy_display(display);
    al_destroy_event_queue(eventQueue);
 
    return 0;
}

Der gesamte Quelltext

Quellcode

/*
    Allegro-Beispielanwendung:
        - Bitmap laden und bewegen
        - Lied im Hintergrund abspielen
        - Text-Ausgabe
        - Timer
*/
 
// Benötigte Header
#include <allegro5\allegro.h>
#include <allegro5\allegro_ttf.h>
#include <allegro5\allegro_font.h>
#include <allegro5\allegro_image.h>
#include <allegro5\allegro_audio.h>
#include <allegro5\allegro_acodec.h>
 
 
 
int main()
{
    // Variablen-Deklaration
    int screenWidth = 800;
    int screenHeight = 600;
    bool running = true;
    bool redraw = true;
    bool key[4] = {false, false, false, false};
    enum KEYS {UP, DOWN, LEFT, RIGHT};
    int posX, posY, bitmapWidth, bitmapHeight;  // Bilddaten
    int frameNumber = 0;
 
    ALLEGRO_DISPLAY* display = 0;
    ALLEGRO_EVENT_QUEUE* eventQueue = 0;
    ALLEGRO_EVENT ev;
    ALLEGRO_BITMAP* bitmap = 0;
    ALLEGRO_SAMPLE* sample = 0;
    ALLEGRO_FONT* font = 0;
    ALLEGRO_TIMER *timer = 0;
 
    // Allegro initialisieren
    if(!al_init())
        running = false;
 
    // Fenster erstellen
    display = al_create_display(screenWidth, screenHeight);
    if(!display)
        running = false;
 
 
    // Bild laden
    al_init_image_addon();
    bitmap = al_load_bitmap("Test.png");
    if(!bitmap)
        running = false;
    bitmapWidth = al_get_bitmap_width(bitmap);
    bitmapHeight = al_get_bitmap_height(bitmap);
    posX = (screenWidth / 2) - (bitmapWidth / 2);
    posY = (screenHeight / 2) - (bitmapHeight / 2); 
 
    // Sample laden
    al_install_audio();
    al_init_acodec_addon();
    al_reserve_samples(1);
    sample = al_load_sample("Test.wav");
 
    // Text-Ausgabe vorbereiten
    al_init_font_addon();
    al_init_ttf_addon();
    font = al_load_font("Test.ttf", 16, 0);
 
    // Timer erstellen
    timer = al_create_timer(1.0 / 60);      // 60 FPS
    if(!timer)
        running = false;
 
    // Tastatur zugänglich machen
    al_install_keyboard();
 
    // Event-Queue erstellen
    eventQueue = al_create_event_queue();
    al_register_event_source(eventQueue, al_get_keyboard_event_source());
    al_register_event_source(eventQueue, al_get_timer_event_source(timer));
    al_register_event_source(eventQueue, al_get_display_event_source(display));
 
    // Szene zeichnen
    al_clear_to_color(al_map_rgb(0, 0, 0));
    al_draw_textf(font, al_map_rgb(0, 125, 0), 32, 32, 0, "Frame: %i", frameNumber);
    al_draw_bitmap(bitmap, posX, posY, 0);
    al_flip_display();
 
    // Sample abspielen
    al_play_sample(sample, 0.5, 0, 1, ALLEGRO_PLAYMODE_ONCE, 0);
 
    // Timer starten
    al_start_timer(timer);
 
    // Game-Loop
    while(running)
    {
        // Events abfragen
        al_wait_for_event(eventQueue, &ev);
 
        // Frame-Counter erhöhen
        frameNumber++;
 
        // Position updaten
        if(ev.type == ALLEGRO_EVENT_TIMER)
        {
            // Verschiebung nach oben
            if(key[UP] && posY >= 0)
                posY -= 4.0;
 
            // Verschiebung nach unten
            if(key[DOWN] && posY <= (screenHeight - bitmapHeight))
                posY += 4.0;
 
            // Verschiebung nach links
            if(key[LEFT] && posX >= 0)
                posX -= 4.0;
 
            // Verschiebung nach rechts
            if(key[RIGHT] && posX <= (screenWidth - bitmapWidth))
                posX += 4.0;
 
            redraw = true;
 
        }
 
        // Fenster wurde mit 'X' geschlossen
        else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
        {
            running = false;
        }
 
        // Taste gedrückt
        else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) 
        {
            switch(ev.keyboard.keycode) 
            {
                case ALLEGRO_KEY_UP:
                    key[UP] = true;
                break;
 
                case ALLEGRO_KEY_DOWN:
                    key[DOWN] = true;
                break;
 
                case ALLEGRO_KEY_LEFT: 
                    key[LEFT] = true;
                break;
 
                case ALLEGRO_KEY_RIGHT:
                    key[RIGHT] = true;
                break;
            }
        }
 
        // Taste losgelassen
        else if(ev.type == ALLEGRO_EVENT_KEY_UP) 
        {
            switch(ev.keyboard.keycode) 
            {
                case ALLEGRO_KEY_UP:
                    key[UP] = false;
                break;
 
                case ALLEGRO_KEY_DOWN:
                    key[DOWN] = false;
                break;
 
                case ALLEGRO_KEY_LEFT: 
                    key[LEFT] = false;
                break;
 
                case ALLEGRO_KEY_RIGHT:
                    key[RIGHT] = false;
                break;
 
                case ALLEGRO_KEY_ESCAPE:
                    running = false;
                break;
            }
        }
        if(redraw && al_is_event_queue_empty(eventQueue)) 
        {
            redraw = false;
            al_clear_to_color(al_map_rgb(0,0,0));
            al_draw_bitmap(bitmap, posX, posY, 0);
            al_draw_textf(font, al_map_rgb(0, 125, 0), 32, 32, 0, "Frame: %i", frameNumber);
            al_flip_display();
        }
    }
 
    // Speicher freigeben
    al_destroy_sample(sample);
    al_destroy_font(font);
    al_destroy_bitmap(bitmap);
    al_destroy_timer(timer);
    al_destroy_display(display);
    al_destroy_event_queue(eventQueue);
 
    return 0;
}

Ergebnis

AllegroTut.png

Weitere Techniken

Wir haben zwar nun ein vollständige Anwendung, die alle großen Anwendungsbereiche abdeckt, allerdings wollen wir uns noch ein paar zusätzliche Dinge anschauen.

Fenstertitel

Allegro verwendet als Fenstertitel standardmäßig, unter Windows, den Projektnamen, allerdings können wir diesen mit der Funktion al_set_window_title ändern. Der Funktion übergeben wir unseren Display-Zeiger und den gewünschten Titel.

al_set_window_title(display, "Beispieltitel");

Monitor auswählen

Nicht selten kommt es vor, dass ein Benutzer über mehr als einen Monitor verfügt. Allegro gibt uns die Möglichkeit, einen Monitor auszuwählen. Besonders wenn wir uns später den Vollbild-Modus anschauen kann dies wichtig sein, da man ein Fenster verschieben kann, aber keine Vollbild-Anwendung. Um den gewünschten Monitor auszuwählen, verwenden wir die Funktion al_set_new_display_adapter. Als Paramet übergeben wir die Nummer des Monitors, wobei 0 der erste Monitor ist. Die Funktion muss vor dem Aufruf von al_create_display aufgereufen werden.

al_set_new_display_adapter(0);

Vollbild

Richtige Spielatmosphäre kommt in einem Fenster nicht wirklich auf. Deshalb schauen wir uns als nächstes an, wie wir den Vollbildmodus aktivieren können. Dabei ist zu beachten, dass wir zuerst, wie oben beschrieben, den Monitor auswählen. Nach dieser Auswahl rufen wir, ebenfalls vor dem Aufruf von al_create_display, die Funktion al_set_new_display_falgs auf und übergeben ihr den Parameter ALLEGRO_FULLSCREEN.

al_set_new_display_flags(ALLEGRO_FULLSCREEN);

Primitiven

Primitiven sind einfache geometrischen Strukturen. Dazu gehören z.B. Dreiecke, Vierecke, Linien und Kreise. Allegro stellt uns, um mit Primitiven zu arbeiten, ein extra Addon zur Verfügung. Um mit diesem Addon arbeiten zu können, müssen wir die allegro_primitives.h einbinden und das Addon mit al_init_primitives_addon initialisieren.

#include <allegro5\allegro_primitives.h>
 
// Main-Funktion
al_init_primitives_addon();

Beispiele

// Ein paar Beispiele (eine komplette Liste, steht in der Allegro-Dokumentation)
al_draw_line(startX, startY, endX, endY, al_map_rgb(r, g, b), Breite); // Eine Linie
al_draw_filled_rectangle(startX, startY, endX, endY, al_map_rgb(r, g, b)); // Ein Viereck
al_draw_circle(mittelX, mittelY, radius, al_map_rgb(r, g, b), Breite); // Ein Kreis

Wie geht es jetzt weiter

Natürlich war dies nur ein sehr kurzer Einstieg in Allegro. Allerdings sind wir nun theoretisch in der Lage ein Spiel mit Allegro zu programmieren.
Unser wichtigstes Hilftmittel für die Zukunft, um mit Allegro zu programmieren, ist die Dokumentation. Ansonsten gilt wie immer "Learning by doing".

Meine Werkzeuge
Namensräume
Varianten
Aktionen
Navigation
Werkzeuge