Pre DirectX Tutorial: Teil 1 - Einführung in die WinAPI
Ich brauchte mal ne Pause vom neuen Design von Sundancer (ja Flupdi, wird kommen
:) ). Etwa da erinnerte ich mich, das hier ja noch ein DirectX Tutorial zu schreiben
war. Nun auf.
Bevor wir zum Planeten X aufbrechen noch ein paar Kleinigkeiten. Zunächst
braucht ihr einen Compiler der DirectX Programme erstellen kann. MS VC++ ist
fein, Borland und alle anderen taugen genauso gut. Worauf ich aber hinauswill
ist folgendes - wenn ihr mit eurer Compilerumgebung nicht umgehen könnt
wird das auch nix mit DirectX. Also, für diejenigen, die noch nicht mit
VC++ oder gar noch nichts in C gemacht haben, LERNT ERST DAS! Betreibt RTFM
und kompiliert ein paar Programme bevor ihr los legt.
In diesem Teil gehen wir es locker an und lassen den Planeten X unberührt.
Vielmehr geht es erst einmal um das Universum: Windows.
Andre LaMothe sagte mal "In Windows zu programmieren ist wie zum Zahnarzt
zu gehen: Man weiß das es gut für einen ist, aber niemand mag es."
Ich für meinen Teil habe Windows-Programmierung lange Zeit höflich
vermieden. Als es dann doch Zeit war verbrachte ich 3 Wochen in der Hölle,
aber inzwischen mag ich es sogar. Wirklich. Ganz ehrlich. Mist, das glaube ich
mir nicht mal selber ;)
Wenn wir heute von Windows reden meinen wir eine Version von Win32, also Win95,
98, NT4 oder 2000. Diese sind Multitasking und Multithreading fähig. Das
bedeutet: mehrere Programme können gleichzeitig ausgeführt werden
und diese Programme können aus mehreren Unterprogrammen und Aufgaben bestehen,
die ebenfalls gleichzeitig ausgeführt werden. So - und jetzt zur Realität.
Windows hat im Kern den sogenannten Scheduler. Dieser macht nichts anderes
als jedem Programm welches gerade startet eine Prozessnummer zuzuweisen. Aus
der Sicht von Windows ist jedes Programm ein Prozess. Jene Prozessnummern werden
nun in eine Prozessliste eingetragen. Unter NT kann man sich diese Prozessliste
bequem anzeigen lassen: CRTL, ALT, DEL und dann "Task Manager" und
"Prozessliste". Der Scheduler ruft die Prozesse in der Prozessliste
nacheinander für Sekundenbruchteile auf. Gleichzeitig läuft da also
gar nichts, nur so schnell das man den Eindruck hat.
Und hier liegt auch schon ein Vierbeiner vergraben, denn die Entscheidung wie
lange welcher Prozess läuft liegt bei Windows. Win kann und wird (!) euch
gnadenlos den Teppich unter eurer Applikation weg ziehen wenn es mal gerade
Lust drauf hat. Der User hat kaum einen Einfluß darauf, da nützt
auch das erhöhen der Priorität eurer Programme wenig.
Windows ist "event driven". Das bedeutet das Windows alles erst einmal
als Ereignis (event) welches es dann als Nachricht (message) weiter verarbeitet.
Allerdings sieht es so aus das Windows die Nachrichten an euer Programm weiter
leitet und ihr dann etwas mit diesen Nachrichten anfangen müsst. Ein Event
kann z.B. ein Tastendruck des Nutzers sein aber auch die Aktivierung des Bildschirmschoners...
Wenn Windows Nachrichten an unser Programm weiter gibt brauchen wir eine Art
Schnittstelle um diese Nachrichten zu verarbeiten. Dazu aber später noch
mehr als euch lieb ist.
Sehen wir uns erst einmal ein simples Windows Programm an.
--------------------------------------------------------------------------------
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <windowsx.h>
int WINAPI WinMain(HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
MessageBox(NULL, "Hello World!",
"Hello Title",
MB_OK | MB_ICONEXCLAMATION);
return(0);
}
--------------------------------------------------------------------------------
Das Programm gibt einfach nur ein Nachrichtenfenster aus. Kompiliert es mal
und schaut es euch an. Jetzt zur Obduktion ;)
#define WIN32_LEAN_AND_MEAN
Hmmm. Man hat erst einmal 2 Möglichkeiten ein Windows-Programm zu schreiben:
MFCs oder SDKs. Die MFCs (Microsoft Foundation Classes) sind typische Microsoft
Ausgeburten: völlig mit Features überladen, aufgeblasen und so logisch
aufgebaut, das sie schon wieder viel zu komplex sind. Die SDKs (Software Development
Kits) sind kleiner, enthalten nur das nötigste und man kann den Umgang
in ein paar Wochenenden lernen.
WIN32_LEAN_AND_MEAN weist den Compiler nun an diesen ganzen MFC Kram zu vergessen
und sich auf das nötigste zu beschränken.
Windows.h repräsentiert die wichtigsten Windows Header und windowsx.h
enthält einige nette Spielzeuge, die uns das Leben in Windows erleichtern.
Jetzt wird es wichtig, also aufwachen. Der Einstiegspunkt aller Windows Programme
ist die WinMain() Prozedur. Sie ist das Äquivalent zu der Main() Prozedur
von DOS Programmen.
Diese WINAPI Deklaration ist die neumodische PASCAL Funktionen Deklaration.
WINAPI sagt einfach nur das die folgenden Parameter von links nach rechts statt
von rechts nach links bearbeitet werden. Und jetzt zu eben jenen Parametern.
hinstance - Diesen Parameter nutzt Windows um eine Applikation zu überwachen
und ihr eine Nummer zuzuweisen. Es ist quasi die Adresse eures Programmes.
hprevinstance - Das ist eine Krankheit, die noch aus der Zeit der 16 Bit Windows
Versionen übrig geblieben ist. Win16 Programme nutzten das, um die Instanz
des Programmes zu speichern, die das aktuelle Programm aufgerufen hat. Nicht
drüber nachdenken, seid einfach froh, das es jetzt Geschichte ist ;)
lpcmdline - Das sind die Kommandozeilen Parameter, die beim Start überliefert
werden. Ist ganz nützlich für eigene Debug Erweiterungen ;)
ncmdshow - Dieser Parameter zeigt an wie euer Programm gestartet wird. So kann
es beim Start gleich minimiert werdenoder gar nciht angezeigt werden (in bestimmten
Fällen durchaus sinnvoll).
So! Wenn ihr die ganzen Parameter, Flags oder sonst was lernen wollt holt euch
ein Buch über Windows Programmierung (solltet ihr so wie so). Auch gut
ist eine Referenz oder Nachschalgewerk, welches nur die Befehle und Inhalte
aufführt.
Jetzt kommen wir zum Nachrichtenfenster. Die Message Box ist eine nette Funktion
der Windows API, die einfach nur ein kleines Fenster öffnet. Gehen wir
wieder die Parameter durch:
hwnd - In unserem Falle NULL. Es ist das Handle der Box und zeigt an an welche
Applikation die Box gebunden ist. Indem wir NULL setzen ist der Desktop das
übergeordnete Fenster.
lptext - Das ist der Text den ihr ausgeben wollt - in unserem Falle "Hello
World!"
lpcaption - Der Titel unseres Fenster "Hello Title"
utype - Das ist der einzig aufregende Parameter. Hier könnt ihr festlegen
welche Buttons (OK, Cancel, Retry, ...) euer Fenster haben soll und welche Icons
(Ausrufezeichen, ...) angezeigt werden sollen. Hierbei verweise ich wieder auf
ein Buch über die Windows API. Schnappt euch ne Liste und schlagt nach,
was alles möglich ist.
So. Das war unser kleines Programm. Dummerwesie ist jedes Programm nicht ganz
so einfach, deshalb macht an der Stelle erst einmal eine Pause und Compiliert
das obere Programm. Schaut es euch an, spielt mit den Parametern und schaut
dann, was dabei heraus kommt.
Pause! Erst mal so weit. Das nächste Mal geht es noch etwas tiefer in
Windows hinein.
Wenn ihr jetzt alle sagt "Boah, langeweilig - ich weiß schon, wie
man ein Windows Fenster öffnet, einen DirectX Kontext daran bindet und
WinProc ruft nur noch ein Gähnen hervor" werde ich gleich zum "Real
Stuff" übergehen. Ansonsten werde ich alles Schritt für Schritt
erklären. Sagt mal was.
Obwohl ich alles langsam durchgehe soll das kein Windows API Kurs sein, sondern
eher ein ganz schneller Überblick sein, gerade genug um ein DirectX Fenster
zu öffnen. Bei entsprechender Nachfrage kann ich das zwar vertiefen, aber
im Moment halte ich Windows sehr einfach.
Dann noch eine Empfehlung für ein Windows Buch: "Tricks of the Windows
Game Programming Gurus" von Andre LaMothe. SAMS Verlag, ISBN: 9-780672-31361-5.
Hat knapp über tausend Seiten und behandelt nicht nur DirectX mit fast
allen seinen Komponenten, sondern auch noch Windows, Künstliche Intelligenz,
Physikalische Modelle und viele andere nette Dinge. Es ist in englisch, aber
echt leicht zu lesen. Ein Schock ist der Preis von knapp 150.-, aber anstatt
5 Bücher über die ganzen Themen zu kaufen braucht man nur dieses.
Des weiteren sind auf der beiliegenden CD noch weitere Bücher und hunderte
von Texten über Optimierung und tiefer gehendes Material. Auf der 2. CD
liegt der uneingeschränkte MS VC++ 6.0 Compiler in der Introductory Version
vor. Einziger Haken: die kompilierten Programme dürfen nicht für Kommerzielle
Zwecke verwendet werden, sonst hat er alles! Und wenn das nicht mal Gegenwert
fürs Geld ist!
So...bis zum nächsten Mal...
Delax
[delax@sundancerinc.de]
