Meine Werkzeuge
Namensräume
Varianten

DirectX 11 Jumpstart/Die Konfiguration der IDE

Aus indiedev
Wechseln zu: Navigation, Suche
Hinweis Dieser Artikel wird gerade geschrieben bzw. bearbeitet und erfüllt noch nicht die Qualitätsstandards von indiedev.
Bitte bearbeite diesen Artikel nur, wenn du kleine Fehler korrigieren möchtest oder der Autor bist.
DirectX 11 Jumpstart
Die Konfiguration der IDE
Autor Glatzemann
Programmier­sprache C++
Kategorie DirectX
Diskussion Thread im Forum
Lizenz indiedev article license
Originalartikel: MitOhneHaare.de


Die Einstiegshürde für DirectX 11 ist deutlich höher als die von XNA und daher fällt die Entscheidung für Neulinge oft eindeutig aus: XNA gewinnt, da man sich gerade am Anfang wenn man sowieso schon überwältigt ist von allem was da auf einen zukommt, deutlich weniger Probleme einhandeln möchte und möglichst schnell Ergebnisse erzielen möchte. Trotzdem möchte ich an dieser Stelle die Gelegenheit nutzen und einen Einblick in DirectX ermöglichen und versuchen den Einstieg schnell und einfach zu ermöglichen.

Die Frage ist hier natürlich: Warum DirectX und warum Version 11? Dies sind berechtigte Fragen auf die ich selbstverständlich auch eine Antwort habe. Aktuelle Empfehlung von Microsoft zur Erstellung von "Metro Style Games" ist DirectX/C++. Da Windows 8 DirectX 11.1 verwendet bietet es sich an diese Version zu verwenden. Da nicht jeder die Developer Preview installieren kann oder will werde ich zunächst mit DirectX 11 beginnen. Die neuen Features von DirectX 11.1 benötigen wir erstmal nicht, daher reicht DX11 vollkommen aus und die grundsätzlichen Unterschiede zwischen einem DX11/Win7 und einem DX11.1/Metro Style Game liegen hauptsächlich beim erzeugen der sogenannten SwapChain und dem Render-Window.

Und warum "Metro Style Games", wo doch Windows 8 auch XNA und andere Grafikbibliotheken unterstützen wird? Auch hierauf ist die Antwort schnell gegeben: Metro und der Windows 8 Kernel wird sich zukünftig sehr wahrscheinlich auf allen Geräten und Geräteklassen wiederfinden: Egal ob Desktop-PC, Slate, Tablet oder Notebook, auch auf dem Windows Phone ("Apollo") wird es wohl bald soweit sein und auch um die XBox vNext ranken Gerüchte, dass diese auf dem Windows Kernel basieren könnte. Eine Umgebung und eine Sprache also für alle Geräte, solange diese unter Windows 8 laufen und das spart uns Arbeit, wenn wir Spiele für alle Systeme anbieten wollen.

Genug der einleitenden Worte es gibt gute Gründe für DirectX und C++ und wir können daran nichts ändern, so schade wir das auch finden mögen. Wir können es also verwenden oder auch nicht und wer jetzt weiterliest, der möchte es zumindest ausprobieren.

Wir benötigen Software

Bevor wir loslegen können benötigen wir ein wenig Software und die gute Nachricht ist, dass Microsoft uns hier kostenlos mit extrem guter Software versorgt.

Fangen wir mit der IDE, also dem Integrated Development Environment (integrierte Entwicklungsumgebung) an. Ich werde für meine Artikel Visual Studio 2010 verwenden. Ein ähnliches Vorgehen ist jedoch auch mit neueren Versionen möglich. Downloaden könnt ihr die IDE auf der eigens von Microsoft eingerichteten Microsite zu Visual Studio Express 2010. Dort laden wir aus der Kategorie Windows Visual C++ 2010 Express herunter und installieren dieses. Wer Schüler oder Student ist bekommt über seine Schule unter Umständen eine kostenfreie Versionen zum lernen im Rahmen des Dreamspark-Programm bereitgestellt. Die Express-Version reicht aber vollkommen aus.

Während die Installation läuft können wir uns um die zweite notwendige Software kümmern: Das DirectX SDK. SDK steht für Software Development Kit und enthält eine Reihe von Libraries, als auch Header-Dateien. Abgerundet wird das alles von Beispielen, Tools und einem Haufen Dokumentation. Die aktuelleste Version ist das DirectX Juni 2010 SDK und gleichzeitig wird dies auch die letzte Version sein. Zukünftig ist das DirectX SDK in das Windows SDK integriert und muss nicht mehr separat beschafft werden. Ob dies ein Vorteil oder ein Nachteil sein wird, darüber möchte ich mich an dieser Stelle nicht auslassen. Dies wird die Zukunft zeigen.

Während Download und Installation laufen können wir schnell einen Kaffee trinken gehen oder so. Immerhin handelt es sich um etwas mehr als 500MB. Nachdem dieser Punkt erledigt ist gehen wir über zum nächsten Punkt:

Die Einrichtung

Wir starten nun das frisch installierte Visual Studio 2010 und richten es ein. Als erstes erzeugen wir dafür ein neues Win32 Projekt, welches wir durch Klicken auf Datei/Neu/Projekt erstellen. Bevor der Assistent durch einen Klick auf OK gestartet wird, müssen wir dem Projekt natürlich einen Namen geben. Ich habe dafür Tutorial01 gewählt. Auf der zweiten Seite wählen wir leeres Projekt und klicken auf Fertigstellen.

cpp_t01_00.png

Wir haben nun ein leeres C++-Projekt das wir nun weiter konfigurieren werden.

cpp_t01_01.png

Aus dem Ansicht-Menü rufen wir nun unter weitere Fenster den Eigenschaften-Manager auf. Dieser öffnet sich etwas versteckt im rechten Bereich.

Sollte der Eigenschaften-Manager nicht vorhanden sein, dann kann es daran liegen, dass deine Visual Studio Version noch auf den Experten-Modus umgeschaltet werden muss. Dazu wählt man im Menu Extras/Einstellungen einfach Erweiterte Einstellungen.

cpp_t01_02.png

Im vorherigen Screenshot habe ich den folgenden Schritt bereits vorgenommen. Ihr klickt den Baum einfach solange auf, bis ihr den Eintrag "Microsoft.Cpp.Win32.user" unter eurem Projekt findet. Auf diesen Eintrag macht ihr nun einen Doppelklick was dazu führt, dass ein neues Fenster geöffnet wird.

Im linken Bereich wählt ihr nun "VC++ Directories", da wir dort ein paar Änderungen vornehmen müssen.

cpp_t01_03.png

Zunächst erweitern wir die Liste der Includeverzeichnisse. Klickt mit der linken Maustaste auf die entsprechende Zeile im rechten Bereich des Fensters. Am Ende der Zeile erscheint nun ein kleiner Pfeil, der nach unten gerichtet ist. Dieser muss nun ebenfalls angeklickt werden und dann wählt ihr im Menü das sich öffnet den Punkt Bearbeiten aus.

Nun klickt ihr auf das kleine Ordner-Symbol mit dem Stern. Der Tooltip beschreibt das Symbol mit Neue Zeile. Alternativ könnt ihr auch Strg + Einfügen drücken. Der Cursor landet nun in einer neuen Textbox in den ihr den Pfad eingeben könnt. Wer den Pfad nicht auswendig kennt, der klickt einfach auf den Button mit den drei Punkten am Ende der Zeile und wählt den Pfad mit einem der von Windows bekannten Verzeichnis-Auswahl-Dialoge aus.

Das Verzeichnis das ihr hier auswählen müsst ist im DirectX-SDK-Verzeichnis zu finden. Dieses befindet sich in der Regel unter C:\Program Files (x86) und heisst Microsoft DirectX SDK (June 2010). Als vollständigen Pfad fügen wir also

C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)\Include

hinzu.

Ein Bibliotheksverzeichnis benötigen wir ebenfalls. Wir gehen so vor wie bereits beschrieben, wählen aber anstatt dem Include-Verzeichnis aus dem DirectX-SDK das lib-Verzeichnis aus. Zunächst beschränken wir uns (auch auf einem 64Bit-System) auf die 32Bit-Variante von DirectX. Daher wählen wir auch das Unterverzeichnis x86 aus.

Wir können das Fenster nun mit OK schliessen. Ab jetzt sollten in diesem und auch in allen neuen Win32-Projekten DirectX-Programme problemlos kompilieren. Wir haben dies als Voreinstellung für alle zukünftigen Projekte eingestellt. Das klingt jetzt erstmal ziemlich kompliziert und nach ziemlich viel Arbeit für ein sehr kleines Ergebnis. Das ist es grundsätzlich auch, aber kompliziert ist es zumindest nicht wirklich und ausserdem müssen wir das nur einmal machen. Wenn man den Hintergrund kennt und weis, was da passiert, wird auch schnell klar was dort passiert und es ist dann auch nicht mehr weiter kompliziert und geht fast automatisch von der Hand. Und genau das möchte ich euch zum Abschluss noch kurz näher bringen.

Der C++-Compiler erzeugt beim Kompilieren sogenannte Objektdateien. Dies sind in Maschinensprache kompilierte Module mit Funktionen. Mehrere dieser Module können zu Funktionsbibliotheken zusammengefasst werden und der Linker fügt diese Programmteile dann zu unserem Programm hinzu, wenn diese benötigt werden. Dies ist meist der letzte Schritt der Kompilierung.

Um nun eine Beschreibung dieser vorkompilierten Funktionsbibliotheken zu haben gibt es die sogenannten Header-Dateien (Endung .h). Diese enthalten die Beschreibung dessen, was in der Bibliothek enthalten ist. Dabei handelt es sich nur um Klassendefinitionen und Funktionsköpfe, normalerweise aber nicht um ausführbaren Code (es gibt Ausnahmen, aber die sind für das generelle Verständnis erstmal nicht weiter wichtig).

Wir müssen also zwei Schritte machen um eine Bibliothek zu verwenden:

1. Header-Datei einbinden 2. Library linken

Beides übernimmt der Compiler für uns, aber wir müssen ihn dabei ein klein wenig unterstützen. Zum einen muss dem Compiler natürlich mitgeteilt werden wo er nach Headern und Libraries suchen soll und wir müssen die notwendigen Header in unseren Source-Code inkludieren. Den ersten Schritt haben wir in diesem Artikel gemacht, den zweiten Schritt lernen wir in den weiteren Teilen dieser Artikelreihe kennen. Da wir mit DirectX arbeiten wollen haben wir die entsprechenden Verzeichnisse aus dem DirectX-SDK referenziert und damit stehen uns die Header und Libraries von DirectX nun zur Verfügung.

Es gibt übrigens zwei Arten von Libraries: statische und dynamische. Die dynamischen sind sogenannte DLLs (so werden die Dynamic Link Libraries unter Windows genannt). Diese sind vergleichbar mit .NET-Assemblies. Die Library wird vom Betriebssystem geladen wenn sie benötigt wird und die Einsprungadressen werden automatisch so umgebogen, dass die richtigen Funktionen aufgerufen werden.

Beim statischen Linken werden die Libraries an unser Programm angehangen. Augenscheinlicher Vorteil ist, dass danach nur noch eine Datei vorhanden ist und eine .DLL-Datei nicht mehr notwendig ist. Der Nachteil dabei ist aber, dass das ausführbare Programm größer wird und damit auch die Ladezeiten und der Speicherverbrauch.

Beide Arten von Libraries haben eine Daseinsberechtigung. Auf die Details möchte ich hier jetzt nicht näher eingehen, wichtig ist nur, dass ihr beide Varianten kennt und schon mal davon gehört habt. Dies ist für das Verständnis wichtig und bietet eine gute Grundlage für weitere Arbeiten.

Zusammenfassung und Abschluss

In diesem kurzen Artikel haben wir gemeinsam die Entwicklungsumgebung installiert und alles soweit vorbereitet, dass wir im nächsten Schritt unser erstes DirectX-Programm entwickeln können. Wir haben ein paar Informationen über Libraries erhalten und wissen nun, was ein Linker ist.

Wir haben festgestellt, dass die Welt unter C++ und nativem DirectX deutlich komplizierter und arbeitsintensiver ist als zum Beispiel mit XNA und C#. Der Lohn für diese Mühe ist jedoch eine deutlich höhere Flexibilität und in einigen Fällen auch eine deutlich höhere Geschwindigkeit.

Ich hoffe, dass ich mit dem Beginn dieser neuen Artikelreihe das Interesse vom ein oder anderen Leser wecken konnte und freue mich schon euch im nächsten Teil wieder begrüßen zu dürfen.

Navigation
Tutorials und Artikel
Community Project
Werkzeuge