Copyright: Entspricht der GNU-Lizenzen. Ausnahme: Wenn Ihr Teile aus dieser Datei und/oder von den Anhängen benutzt, müsst Ihr einen Link auf www.satyria.de in Euren Projekten hinterlassen und verpflichtet diejenigen die Euer Projekt in Teilen oder Insgesamt kopieren, zu diesem Copyright.

Kleiner Zusatz: Solltet Ihr in SDL programmieren wollen und leider auf Linux verzichten müssen, könnt Ihr auch unter Windows mit SDL Programmieren. Auf meiner Seite zum Einrichten der SDL-Biblothek unter Windows, könnt Ihr nachlesen wie man so etwas macht!

Mit diesem Tutor möchte ich Euch ein wenig das SDL (Simple DirectMedia Layer) Programmieren beibringen. Ich selbst habe diesen Tutor mit Ubuntu 7.04 und KDE (Kubuntu) und einigen Zusatzpacketen (sdllib (dev)) (apt-get install libsdl1.2-dev) getestet.

Inhalt

• Die ersten Programme
• Bilder anzeigen lassen
• Auf Eingaben reagieren
• Zeichnen
• Sprites
• Texturen
• Verzeichnis der Funktionen (mit Parameter)

Weitere Infos erhaltet Ihr bei: http://de.wikibooks.org/wiki/SDL

Bitte neue Version verwenden: SDL unter Windows (Update: 28.09.09)

Copyright: Entspricht soweit der GNU-Lizenzen. Ausnahme: Wenn Ihr Teile aus dieser Datei und/oder von den Anhängen benutzt, müsst Ihr einen Link auf www.satyria.de in Euren Projekten hinterlassen und verpflichtet diejenigen die Euer Projekt in Teilen oder Insgesamt kopieren, zu diesem Copyright.

Unter Windows gibt es einige Hilfsprogramme zur Programmierung von Windows. Ich selbst finde hier gcc sehr hilfreich, da ich selbst am meisten unter Linux arbeite. Leider muss ich auch auf Windows-Rechnern arbeiten. Da lag es für mich nah, eine Möglichkeit zu finden, mein Favorit der Bibliotheken (SDL), auch unter Windows zu installieren. Eventuell finde ich auch eine Version, die völlig unabhängig der Installation von Windows läuft. Also Gegoogelt und einige Ideen gefunden. Alle schrieben, es sei sehr leicht und ohne größere Probleme zu installieren, aber nicht eine Version hat funktioniert. Diese Version, die ich nun vorstelle, war zunächst auch nicht fehlerfrei (eventuell immer noch nicht). Aber schaut es Euch einfach mal an:

Achtung: Für das was jetzt kommt, übernehme ich keine Haftung. Sollte hier was Falsches angegeben werden, kann es zu Datenverlusten und auch zu unangenehmen Überraschungen kommen (Systemabstürzen!)! Eine Neuinstallation von Windows ist dann meist unwiderruflich!

 Ich habe hier ein Packet geschnürt, in dem alle wichtigen Dateien vorhanden sind:

SDL-devel(mingw32)
SDL_gfx
SDL_image (Inkl.: JPEG , PNG ( Zlib ), TIFF library) 
MinGW
MSYS

Damit ist es nun möglich alle Dateien, die zumindest der Kurs beschreibt, auch unter Windows laufen zu lassen.

Download: Satyria_SDL_0.1.071018.zip (21.7 MB)
MD5SUM: 92d03d49324e15b2df52718bd0e7476c *Satyria_SDL_0.1.071018.zip

Zur Installation wird zurzeit ca. 100 MB freier Festplattenplatz benötigt!

Aber wie geht man nun mit dieser Datei um

Zunächst wird die Datei heruntergeladen. Unter Windows (ab XP) kann die ZIP-Datei einfach per Doppelklick geöffnet werden und das entstandene Verzeichnis irgendwo hin (Merken!!!) kopiert werden. In einer DOS-Konsole (Ausführen: CMD oder unter Zubehör) wird in das entsprechende Verzeichnis gewechselt und dort der Befehl „install“ ausgeführt. Das Programm möchte nun wissen, wo den die Dateien abgelegt werden sollen (Aufpassen, diese Version überprüft nicht diese Übergabe!).

In meinem Beispiel ist das Zielverzeichnis: „g:\“ (Mein USB-Stick). Nun werden alle Dateien in das entsprechende Verzeichnis kopiert und einige Umgebungsvariablen gesetzt.

Das entstandene Verzeichnis

Bei der Installation entstehen mehrere Verzeichnisse:

msys

Das ist unser Ausgangspunkt zur Programmierung von SDL. In diesem Verzeichnis existiert die Datei „msys.bat“. Durch einen Doppelklick wird hier eine Unix-ähnliche Umgebung erstellt, in der einige Unix -Programme laufen. Auch unser „gcc“! Mit „cd“ kann in ein Verzeichnis oder auch Partition gewechselt werden (Bei mir mit „cd g:\“ auf den Stick).

MinGW

Hier ist die „gcc“-Umgebung installiert, sowie alle Librarys und Includes

test_sdl

In diesem Verzeichnis habe ich ein Programm abgelegt, um zu prüfen ob den SDL überhaupt funktioniert. Zum Kompilieren wird die Datei „1.sh“ (einfach so schreiben) gestartet und die Datei „ 1.c“ kompiliert. Allerdings überprüft der Installer nicht die Verzeichnisse in „1.sh“, die zuvor überprüft werden sollten (Einfach mit einem Editor öffnen, verändern und speichern). Ausgeführt wird das Programm mit „1“. Es wird für ca. 2 sek. ein schwarzes Fenster geöffnet. Alle Programme können auch aus Windows oder einer DOS-Konsole gestartet werden!

test_gfx

Auch hier wird die entsprechende Library getestet. „test.sh“ ausführen und anschliesend die Datei „1.exe“ ausführen. Diese Datei ist aus der Org. SDL_gfx Library. Also auch riesige Dateien lassen sich hier Installieren. Sollte es Probleme geben, dann siehe bei test_sdl.

test_image

Datei „image.sh“ ausführen und dann das Programm „image.exe“ ausführen. Siehe auch test.sdl.

test_xxxx

Allgemein muss ich hier noch darauf hinweisen, das in den entsprechenden Verzeichnissen auch die entsprechenden *.dll Dateien vorhanden sind, damit diese dann auch laufen! Es reicht nicht, nur die *.exe Datei weiterzugeben!
Ausserdem kann in der entsprechenden *.sh nachgeschaut werden, wie denn die Dateien kompiliert werden können. Im Kurs werde ich speziell darauf noch eingehen!

dll

Hier sind alle wichtigen *.dll Dateien, die zum ausführen der Dateien erforderlich sind.

docs

Hier ist eine allgemeine Beschreibung der SDL-Library im HTML-Format. Diese Dokumentation ist direkt von libSDL.org. Dort können auch jederzeit weitere Informationen geholt werden.

Solltet Ihr nun noch ein paar Probleme haben oder sogar einige gute Infos, die den anderen helfen könnten, meldet Euch einfach mal (sdlfehler@satyria.de), aber bitte denkt daran, das ich von euch ein wenig Flexibilität zumuten muss, da ich relative wenig Zeit habe, auf hunderte von Mails zu reagieren. Sollte der Fehler bei der Programmierung entstehen, gibt es genügend Foren, die Euch da weiterhelfen können.

Mit diesem Tutor möchte ich Euch ein wenig das SDL (Simple DirectMedia Layer) Programmieren beibringen. Ich selbst habe diesen Tutor mit Ubuntu 7.04 und KDE (Kubuntu) und einigen Zusatzpacketen (sdllib (dev)) (apt-get install libsdl1.2-dev) getestet. 
Aber nun, damit wir auch was sehen, hier das erste Beispiel:

/* Das erste Programm: 1.c */ #include <SDL/SDL.h>   //Unter Windows: <SDL.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h>int main (int argc, char *argv[]) {   SDL_Surface *screen;                                        //ein Zeiger für ein Screen   if (SDL_Init ( SDL_INIT_VIDEO ) != 0)                       //SDL Initialisierung   {     printf („SDL Initialisierung fehlgeschlagen: %s\n“,SDL_GetError ());     return EXIT_FAILURE;                                      //Bei Fehler, beenden   }   atexit (SDL_Quit);                                          //Beim beenden des Programms                                                               //wird SDL_Quit ausgeführt   screen = SDL_SetVideoMode (640, 480, 16, SDL_SWSURFACE);    //Erstelle Screen   if (screen == NULL)   {                                                           //Bei Fehler     printf („Auflösung nicht gefunden: %s\n“, SDL_GetError ());    //Fehler melden!     return EXIT_FAILURE;   }   SDL_Delay (2000);                                           //Warte 2000 Millisec.   printf („Alles OK!\n“);                                     //Beenden mit „Alles OK!“   return EXIT_SUCCESS; }

1.c

Kompiliert wird es unter Linux mit:

gcc `sdl-config –cflags –libs` 1.c -o 1

Und unter Windows und MSYS-Konsole wenn auf e:\ installiert ist, so:

gcc -o 1.exe 1.c -Ie:/mingw/include/SDL -Le:/mingw/lib -lmingw32 -lSDLmain -lSDL -mwindows

und ausgeführt wird es mit:

./1

Bei diesem Prgramm wird ein SDL-Fenster für 2000 Millisekunden geöffnet.

Na ja, eigentlich kann man dieses Programm nicht wirklich als gut bezeichnen. Ein Fenster wird geöffnet und dann irgendwann wieder geschlossen.

Wir machen es nun ein bisschen spannender und reagieren zumindest mal auf das Schließensymbol.
Dazu müssen wir eine Abfrage erstellen, die dann entsprechend reagieren kann. Statt mit SDL_Delay auf das Ende zu warten, setzen wir hier eine WHILE-Schleife ein:

while (!done)   {     while (SDL_PollEvent(&event))     {       switch(event.type)       {        case SDL_QUIT:         done = 1;         break;       }     }   }

2.c

Dieses Programm ist fast selbsterklärend: Die WHILE-Schleife wird solange fortgesetzt bis done einen Wert bekommen hat. Die nächste WHILE-Schleife holt einen Event (wenn vorhanden) ab, und setzt den Wert in die &event-Struktur. In der SWITCH-Schleife, werden verschieden Events getestet, hier nur beenden, und entsprechend reagiert. Bei SDL_QUIT done = 1.

Mehr muss hier nicht geschehen und unser Programm ist fertig!

Mit dem nächsten Beispiel werden andere Events aufgezeigt:

while (!done)   {      while (SDL_PollEvent(&event))     {        switch(event.type)       {          case SDL_QUIT:            done = 1;            break;          case SDL_MOUSEMOTION:            printf(„Mausposition: x: %i und y: %i\n“, event.motion.x, event.motion.y);            break;          case SDL_KEYDOWN:            printf( „Taste %s wurde gedrückt\n“, SDL_GetKeyName( event.key.keysym.sym ) );           break;          case SDL_KEYUP:            printf( „Taste %s wurde Losgelassen\n“, SDL_GetKeyName( event.key.keysym.sym ) );           break;        }      }    }

3.c

Hier Zeigt sich ein kleiner Nachteil des MS-Windowssystems. Da unter Windows keine Textausgabe vorgesehen ist, wird die Textausgabe in eine Datei „sdtout.txt“ umgeleitet und wir sehen selbst zunächst nichts von unserem Ergebnis. Diese Datei kann man aber anschließend in einem Editor durchgesehen werden. Unter Linux läuft es tadellos.

Zu der Maus:

Wie uns dieses Programm verrät sind die X und Y Koordinaten wie folgt verteilt: 

x -> von links nach rechts
y -> von oben nach unten

Eine kleine Info: Das Zeichnen mit SDL kann auch mit den Funktionen der SDL_gfx Libaray erfolgen. Damit wird es auch einfacher. Laut Literatur würde ein direktes Zeichnen allerdings Performance bringen. Damit Ihr wist was besser ist, könnt Ihr ein paar versuche machen. Aber zunächst zeige ich Euch, wie es ohne GFX geht.

Um mit SDL zeichnen zu können, muss man zunächst den Bildschirm sperren. Dies geschieht mit dem Befehl „SDL_LockSurface“. Wenn alle Pixel gezeichnet wurden muss der Bildschirm wieder freigegeben („SDL_UnlockSurface“) werden.

Hier nun ein Beispiel:

…   if (SDL_LockSurface(screen) < 0)   {     printf („Konnte das Surface nicht sperren: %s\n“, SDL_GetError());     return EXIT_FAILURE;    }   x=50;    y=100;    R=0;    G=255;    B=255;   Uint32 *bufp;   for (a=0;a<=20;a++)    {      bufp=(Uint32 *)screen->pixels + (y+a) * screen->pitch / 4 + (x+a);      *bufp = SDL_MapRGB( screen->format,R,G,B);   }    SDL_UnlockSurface (screen);    SDL_UpdateRect (screen,0,0,0,0);   …

Sourcecode: 7.c

So schwer war es doch nicht, oder doch? Mit der GFX-Bibliothek wird es meines Erachtens einfacher. Diese Bibliothek unterstützt uns dabei, viel einfacher die Punkte (Pixel) zu zeichnen.

Das gleiche Programm, aber diesmal mit GFX

… #include <SDL_gfxPrimitives.h> …   …    x=50;    y=100;    R=0;    G=255;    B=255;   for (a=0;a<=20;a++)    {      pixelRGBA(screen, x+a, y+a, R, G, B, 255);    }    SDL_UpdateRect (screen,0,0,0,0);   …

Sourcecode: 8.c

Was war jetzt einfacher? Aber es gibt noch mehr:

Das Zeichnen eines Kreises:

…   circleRGBA(screen, x, y, 30, R, G, B, 255); …

Sourcecode: 9.c

Eine gesamte Auflistung aller Befehle findest Du in meiner SDL_gfx Aufstellung.

DLLINTERFACE int filledPolygonColor(SDL_Surface * dst, const Sint16 * vx, const Sint16 * vy, int n, Uint32 color);  DLLINTERFACE int filledPolygonRGBA(SDL_Surface * dst, const Sint16 * vx, const Sint16 * vy, int n, Uint8 r, Uint8 g, Uint8 b, Uint8 a);  DLLINTERFACE int texturedPolygon(SDL_Surface * dst, const Sint16 * vx, const Sint16 * vy, int n, SDL_Surface * texture,int texture_dx,int texture_dy);

Beispiel:

filledPolygonColor(screen, &rx1[0], &ry1[0], 5, red); // Zeichne ein Mehreck (hier Fünfeck) aus den Koordinaten rx1 und ry1 in „red“  filledPolygonRGBA(screen, &rx1[0], &ry1[0], 5, 255,0,0,255); // Zeichne ein Mehreck (hier Fünfeck) aus den Koordinaten rx1 und ry1 in der Farbe Rot (R=255,G=0,B=0), Alphablending 255  texturedPolygon(screen, &rx1[0], &ry1[0], 5, texture, 100, 100); //Zeichne ein Mehreck mit einer Texture

gfx_filledPolygonColor.c
gfx_filledPolygonRGBA.c
gfx_texturedPolygon.c

DLLINTERFACE int aapolygonColor(SDL_Surface * dst, const Sint16 * vx, const Sint16 * vy, int n, Uint32 color);  DLLINTERFACE int aapolygonRGBA(SDL_Surface * dst, const Sint16 * vx, const Sint16 * vy, int n, Uint8 r, Uint8 g, Uint8 b, Uint8 a);

Beispiel:

aapolygonColor(screen, &rx1[0], &ry1[0], 5, red); // Zeichne ein Mehreck (hier Fünfeck) aus den Koordinaten rx1 und ry1 in „red“  aapolygonRGBA(screen, &rx1[0], &ry1[0], 5, 255,0,0,255); // Zeichne ein Mehreck (hier Fünfeck) aus den Koordinaten rx1 und ry1 in der Farbe Rot (R=255,G=0,B=0), Alphablending 255

gfx_aapolygonColor.c
gfx_aapolygonRGBA.c