3D-Spieleprogrammierung mit DirectX 9 und C++
von: David Scherfgen
Carl Hanser Fachbuchverlag, 2006
ISBN: 9783446408456
Sprache: Deutsch
867 Seiten, Download: 14555 KB
Format: PDF, auch als Online-Lesen
geeignet für:
| Inhalt | 6 | ||
| Vorwort | 19 | ||
| 1 Einleitung | 22 | ||
| 1.1 Ein paar Dinge im Voraus | 23 | ||
| 1.1.1 Was Sie erwartet | 23 | ||
| 1.1.2 Was Sie nicht erwartet | 23 | ||
| 1.1.3 Voraussetzungen | 24 | ||
| 1.1.4 Die Schriftformate in diesem Buch | 24 | ||
| 1.1.5 Was tun bei Problemen? | 24 | ||
| 1.1.6 Zu DirectX 9.0 und DirectX 9.0c | 25 | ||
| 1.1.7 Die ungarische Notation | 25 | ||
| 1.2 Einführung in die Spieleprogrammierung | 26 | ||
| 1.2.1 Der kleine Unterschied | 26 | ||
| 1.2.2 Was macht ein Spiel eigentlich? | 27 | ||
| 1.2.3 Eingliederung in die Windows-Architektur | 29 | ||
| 1.2.4 Das Problem mit der Zeit | 30 | ||
| 1.2.5 Die verschiedenen Seiten eines Spiels | 34 | ||
| 1.2.6 Rückblick | 35 | ||
| 1.3 DirectX und C++ | 35 | ||
| 1.3.1 Was ist DirectX? | 35 | ||
| 1.3.2 Die perfekte Kombination mit C++ | 37 | ||
| 1.3.3 Das COM – Grundlage von DirectX | 39 | ||
| 1.3.4 Rückblick | 42 | ||
| 1.4 Wir bauen uns eine eigene Engine! | 42 | ||
| 1.4.1 Was versteht man unter einer Engine? | 42 | ||
| 1.4.2 Verschiedene Entwicklungsansätze | 42 | ||
| 1.4.3 Konkrete Planung | 43 | ||
| 1.4.4 Installation der Engine und Einrichten eines Projekts | 46 | ||
| 1.4.5 Vorgabefunktionen, Klassen und Makros | 47 | ||
| 1.4.6 Rückblick | 57 | ||
| 1.4.7 Übungsaufgaben | 57 | ||
| 1.5 Tipps zum Debuggen | 58 | ||
| 1.6 Ausblick | 61 | ||
| 2 3D-Grafik | 62 | ||
| 2.1 Was Sie in diesem Kapitel erwartet | 63 | ||
| 2.2 Einführung in die 3D-Grafik | 63 | ||
| 2.2.1 Ein neues Koordinatensystem | 63 | ||
| 2.2.2 Theorie der 3D-Grafik | 65 | ||
| 2.2.3 Vektoren | 67 | ||
| 2.2.4 Matrizen | 86 | ||
| 2.2.5 Ebenen | 109 | ||
| 2.2.6 Das RGB-Farbsystem | 115 | ||
| 2.2.7 Rückblick | 118 | ||
| 2.2.8 Übungsaufgaben | 119 | ||
| 2.3 Direct3D-Grundlagen | 119 | ||
| 2.3.1 Was ist Direct3D? | 119 | ||
| 2.3.2 Die Transformationspipeline | 120 | ||
| 2.3.3 Der Rasterizer | 121 | ||
| 2.3.4 Die wichtigsten Schnittstellen | 122 | ||
| 2.3.5 Ressourcen | 122 | ||
| 2.3.6 Oberflächen | 123 | ||
| 2.3.7 Direct3D im C++-Programm ansprechen | 127 | ||
| 2.3.8 Rückblick | 127 | ||
| 2.4 Initialisierung von Direct3D | 128 | ||
| 2.4.1 Erstellen der | 128 | ||
| Schnittstelle | 128 | ||
| 2.4.2 Adapterinformationen | 129 | ||
| 2.4.3 Caps – die Fähigkeiten eines Geräts | 133 | ||
| 2.4.4 Erstellen des Fensters | 134 | ||
| 2.4.5 Erstellen der | 137 | ||
| Schnittstelle | 137 | ||
| 2.4.6 Direct3D herunterfahren | 149 | ||
| 2.4.7 Beispielprogramm: eine komplette Direct3D-Anwendung | 149 | ||
| 2.4.8 Rückblick | 151 | ||
| 2.4.9 Übungsaufgaben | 152 | ||
| 2.5 Das erste Dreieck | 152 | ||
| 2.5.1 Vertizes | 152 | ||
| 2.5.2 Erste Render-States | 154 | ||
| 2.5.3 Setup der Transformationspipeline | 158 | ||
| 2.5.4 Der Zeichenvorgang | 160 | ||
| 2.5.5 Rückblick | 166 | ||
| 2.5.6 Übungsaufgaben | 167 | ||
| 2.6 Texturen | 167 | ||
| 2.6.1 Was Texturen sind | 167 | ||
| 2.6.2 Grundlegende Dinge | 170 | ||
| 2.6.3 Der bilineare Filter | 172 | ||
| 2.6.4 MIP-Mapping – schnell und schön | 174 | ||
| 2.6.5 Weitere Spielereien | 176 | ||
| 2.6.6 Texturen mit D3DX laden | 177 | ||
| 2.6.7 Texturinformationen abfragen | 180 | ||
| 2.6.8 Das Beispielprogramm | 181 | ||
| 2.6.9 Kachelfähige Texturen erzeugen | 186 | ||
| 2.6.10 Rückblick | 187 | ||
| 2.6.11 Übungsaufgaben | 188 | ||
| 2.7 Vertex- und Index-Buffer | 188 | ||
| 2.7.1 Zweck von Vertex- und Index-Buffern | 188 | ||
| 2.7.2 Der Vertex-Buffer im Detail | 189 | ||
| 2.7.3 Der Index-Buffer im Detail | 193 | ||
| 2.7.4 Das Beispielprogramm | 197 | ||
| 2.7.5 Rückblick | 202 | ||
| 2.7.6 Übungsaufgaben | 202 | ||
| 2.8 Nebel | 203 | ||
| 2.8.1 Die Theorie | 203 | ||
| 2.8.2 Nebel mit Direct3D | 205 | ||
| 2.8.3 Das Beispielprogramm | 207 | ||
| 2.8.4 Rückblick | 208 | ||
| 2.8.5 Übungsaufgaben | 209 | ||
| 2.9 Beleuchtung | 209 | ||
| 2.9.1 Ein einfaches Beleuchtungssystem | 209 | ||
| 2.9.2 Die Praxis – Beleuchtung mit Direct3D | 216 | ||
| 2.9.3 Das Beispielprogramm | 224 | ||
| 2.9.4 Rückblick | 225 | ||
| 2.9.5 Übungsaufgaben | 226 | ||
| 2.10 Alpha-Blending | 227 | ||
| 2.10.1 Die Theorie | 227 | ||
| 2.10.2 Alpha-Blending mit Direct3D | 229 | ||
| 2.10.3 Das Beispielprogramm | 232 | ||
| 2.10.4 Rückblick | 233 | ||
| 2.10.5 Übungsaufgaben | 234 | ||
| 2.11 Multi-Texturing | 234 | ||
| 2.11.1 Der theoretische Teil | 234 | ||
| 2.11.2 Multi-Texturing anwenden | 238 | ||
| 2.11.3 Mehr über Texturkoordinaten | 241 | ||
| 2.11.4 Das Beispielprogramm | 244 | ||
| 2.11.5 Rückblick | 246 | ||
| 2.11.6 Übungsaufgaben | 246 | ||
| 2.12 Exotische Texturformen | 247 | ||
| 2.12.1 Volumentexturen | 247 | ||
| 2.12.2 Umgebungstexturen | 251 | ||
| 2.12.3 Bump-Mapping | 261 | ||
| 2.12.4 Rückblick | 264 | ||
| 2.12.5 Übungsaufgaben | 265 | ||
| 2.13 Der Stencil-Buffer | 266 | ||
| 2.13.1 Was war das noch gleich? | 266 | ||
| 2.13.2 Die Details | 266 | ||
| 2.13.3 Das Beispielprogramm | 270 | ||
| 2.13.4 Rückblick | 273 | ||
| 2.13.5 Übungsaufgaben | 273 | ||
| 2.14 D3DX-Effekte | 273 | ||
| 2.14.1 Probleme beim Verwalten von Modellen | 273 | ||
| 2.14.2 „Effekte“ | 274 | ||
| 2.14.3 Laden eines Effekts | 277 | ||
| 2.14.4 Mit Effekten rendern | 278 | ||
| 2.14.5 Variablen von außen setzen und abfragen | 280 | ||
| 2.14.6 Das Beispielprogramm | 282 | ||
| 2.14.7 Rückblick | 284 | ||
| 2.14.8 Übungsaufgaben | 284 | ||
| 2.15 Transformierte Vertizes für 2D-Grafik | 285 | ||
| 2.15.1 Wozu denn noch 2D? | 285 | ||
| 2.15.2 Die Transformation umgehen | 285 | ||
| 2.15.3 Ein anderes Vertexformat | 286 | ||
| 2.15.4 DirectDraw imitieren | 287 | ||
| 2.15.5 Eine andere Methode für 2D-Grafik | 289 | ||
| 2.15.6 Rückblick | 290 | ||
| 2.15.7 Übungsaufgaben | 290 | ||
| 2.16 In Texturen rendern | 290 | ||
| 2.16.1 Schritt 1: Erstellen einer Textur und eines Z-Buffers | 290 | ||
| 2.16.2 Schritt 2: Das neue Render-Target setzen | 291 | ||
| 2.16.3 Schritt 3: Rendern! | 291 | ||
| 2.16.4 Einfacher mit D3DX | 291 | ||
| 2.16.5 Wozu braucht man das? | 292 | ||
| 2.17 Ausblick | 293 | ||
| 3 3D-Grafik mit der TriBase- Engine | 294 | ||
| 3.1 Was Sie in diesem Kapitel erwartet | 295 | ||
| 3.2 Direct3D mit der TriBase-Engine | 295 | ||
| 3.2.1 Was uns das Leben leichter machen kann | 295 | ||
| 3.2.2 Die Klasse | 297 | ||
| 3.2.3 Der Texturmanager – | 308 | ||
| 3.2.4 | 322 | ||
| und | 322 | ||
| 3.2.5 Die Effektklasse | 333 | ||
| 3.2.6 Ein allumfassendes Beispielprogramm | 337 | ||
| 3.2.7 Rückblick | 346 | ||
| 3.2.8 Ausblick | 346 | ||
| 3.3 Modelldateien | 346 | ||
| 3.3.1 Die Vorarbeit | 347 | ||
| 3.3.2 Der Konverter | 352 | ||
| 3.3.3 Eine Modellklasse | 354 | ||
| 3.3.4 Das Beispielprogramm | 366 | ||
| 3.3.5 Rückblick | 369 | ||
| 3.4 Texte zeichnen | 370 | ||
| 3.4.1 Speicherung der Zeichen | 370 | ||
| 3.4.2 Das Format der Textur | 371 | ||
| 3.4.3 Transformierte Vertizes für Texte | 371 | ||
| 3.4.4 Der Weg von TrueType zur Bitmap-Font | 372 | ||
| 3.4.5 Inhalt der TBF-Dateien | 372 | ||
| 3.4.6 Programmierung einer Schriftartklasse | 373 | ||
| 3.4.7 Das Beispielprogramm | 383 | ||
| 3.4.8 Rückblick | 385 | ||
| 3.5 Ausblick | 385 | ||
| 4 Eingabe | 386 | ||
| 4.1 Was uns in diesem Kapitel erwartet | 387 | ||
| 4.2 DirectInput kurz vorgestellt | 387 | ||
| 4.2.1 Was kann DirectInput besser als Windows? | 387 | ||
| 4.2.2 Geräte und Geräteklassen | 388 | ||
| 4.2.3 GUIDs | 388 | ||
| 4.2.4 Achsen und Knöpfe | 388 | ||
| 4.2.5 Die Funktionsweise von DirectInput | 389 | ||
| 4.2.6 Ein paar Worte zum Debuggen | 390 | ||
| 4.3 Der Startschuss fällt | 390 | ||
| 4.3.1 Erstellen des | 390 | ||
| Objekts | 390 | ||
| 4.3.2 Eingabegeräte abzählen | 392 | ||
| 4.3.3 Rückblick | 393 | ||
| 4.4 Initialisierung eines Geräts und Datenabfrage | 394 | ||
| 4.4.1 Keine Angst vor | 394 | ||
| 4.4.2 Vorbereitungen treffen | 394 | ||
| 4.4.3 Auf verlorene Eingabe achten! | 396 | ||
| 4.4.4 Hinterlassen Sie Ihren Platz … | 396 | ||
| 4.4.5 Einmal Daten, bitte! | 396 | ||
| 4.4.6 Rückblick | 397 | ||
| 4.5 Die Tastatur | 397 | ||
| 4.5.1 Das Datenformat der Tastatur | 397 | ||
| 4.5.2 Tastencodes | 398 | ||
| 4.5.3 Das Beispielprogramm | 400 | ||
| 4.5.4 Begrenzungen der Tastatur | 401 | ||
| 4.5.5 Rückblick | 402 | ||
| 4.6 Die Maus | 402 | ||
| 4.6.1 Das Datenformat der Maus | 402 | ||
| 4.6.2 Relative Achsen | 402 | ||
| 4.6.3 Die Mausknöpfe | 403 | ||
| 4.6.4 Der exklusive Modus | 403 | ||
| 4.6.5 Das Beispielprogramm | 404 | ||
| 4.6.6 Rückblick | 405 | ||
| 4.7 Der Joystick | 405 | ||
| 4.7.1 Achsen, Knöpfe, POVs und Schieberegler | 405 | ||
| 4.7.2 Das Joystick-Datenformat | 406 | ||
| 4.7.3 Das Beispielprogramm | 407 | ||
| 4.7.4 Rückblick | 408 | ||
| 4.8 Objekte abzählen und kalibrieren | 409 | ||
| 4.8.1 Objekte abzählen | 409 | ||
| 4.8.2 Eigenschaften festlegen | 410 | ||
| 4.8.3 Achsenmodus | 411 | ||
| 4.8.4 Achsenskalierung | 411 | ||
| 4.8.5 Die tote Zone | 412 | ||
| 4.8.6 Sättigung | 413 | ||
| 4.8.7 Das Beispielprogramm | 413 | ||
| 4.8.8 Gepufferte Daten und direkte Daten | 413 | ||
| 4.8.9 Rückblick | 414 | ||
| 4.9 Übungsaufgaben | 414 | ||
| 4.10 Eine Eingabeklasse für die Engine | 414 | ||
| 4.10.1 Probleme mit DirectInput | 414 | ||
| 4.10.2 Das Prinzip der analogen Knöpfe | 415 | ||
| 4.10.3 Die | 417 | ||
| Klasse | 417 | ||
| 4.10.4 Das Beispielprogramm | 435 | ||
| 4.10.5 Rückblick | 437 | ||
| 4.11 Ausblick | 437 | ||
| 5 Sound und Musik | 438 | ||
| 5.1 DirectSound kurz vorgestellt | 439 | ||
| 5.1.1 Was kann DirectSound besser als Windows? | 439 | ||
| 5.1.2 Soundpuffer und Mixer | 439 | ||
| 5.1.3 Die Schnittstellen | 441 | ||
| 5.2 Initialisierung von DirectSound | 441 | ||
| 5.2.1 Formale Dinge | 441 | ||
| 5.2.2 Abzählen der DirectSound-Geräte | 441 | ||
| 5.2.3 Erstellung der | 442 | ||
| Schnittstelle | 442 | ||
| 5.2.4 Die Kooperationsebene wählen | 443 | ||
| 5.2.5 Rückblick | 443 | ||
| 5.3 Erstellen von Soundpuffern | 443 | ||
| 5.3.1 Eigenschaften der Soundpuffer | 444 | ||
| 5.3.2 Das Format eines Soundpuffers | 446 | ||
| 5.3.3 Anfordern der | 447 | ||
| Schnittstelle | 447 | ||
| 5.3.4 Der primäre Soundpuffer | 448 | ||
| 5.3.5 Rückblick | 449 | ||
| 5.4 Füllen eines sekundären Soundpuffers | 449 | ||
| 5.4.1 Eine kleine Einführung in die Akustik | 449 | ||
| 5.4.2 Wir sperren den Soundpuffer | 454 | ||
| 5.4.3 Entsperren | 456 | ||
| 5.4.4 Hinein mit den Daten! | 456 | ||
| 5.4.5 Rückblick | 458 | ||
| 5.5 Kontrolle eines Sounds | 459 | ||
| 5.5.1 Die | 459 | ||
| Methode | 459 | ||
| 5.5.2 Festlegen der Lautstärke | 460 | ||
| 5.5.3 Festlegen der Balance | 461 | ||
| 5.5.4 Festlegen der Abspielfrequenz | 461 | ||
| 5.5.5 Das Beispielprogramm | 462 | ||
| 5.5.6 Rückblick | 462 | ||
| 5.6 WAV-Dateien laden | 463 | ||
| 5.6.1 Der RIFF-Header | 463 | ||
| 5.6.2 Die WAV-Chunks | 464 | ||
| 5.6.3 Die Funktion | 464 | ||
| 5.7 3D-Sound | 467 | ||
| 5.7.1 Theorie des 3D-Sounds | 467 | ||
| 5.7.2 Die | 467 | ||
| Schnittstelle | 467 | ||
| 5.7.3 Die | 469 | ||
| Schnittstelle | 469 | ||
| 5.7.4 Das Beispielprogramm | 471 | ||
| 5.7.5 Rückblick | 472 | ||
| 5.8 Echtzeiteffekte | 472 | ||
| 5.8.1 Effekte – vorberechnet und in Echtzeit | 472 | ||
| 5.8.2 Verschiedene Effektschnittstellen | 473 | ||
| 5.8.3 Vorwarnung erforderlich! | 474 | ||
| 5.8.4 Effekte mit | 474 | ||
| anfordern | 474 | ||
| 5.8.5 Die Effektschnittstelle abfragen | 475 | ||
| 5.8.6 Effektparameter am Beispiel des Echos | 476 | ||
| 5.8.7 Experimentieren ist angesagt! | 477 | ||
| 5.8.8 Rückblick | 477 | ||
| 5.9 Ergänzende Informationen | 478 | ||
| 5.9.1 Die verschiedenen Schnittstellen | 478 | ||
| 5.9.2 Klonen von Sounds | 479 | ||
| 5.9.3 Status eines Soundpuffers | 479 | ||
| 5.10 Die Klasse | 480 | ||
| 5.10.1 Erweiterung des Konfigurationsdialogs | 480 | ||
| 5.10.2 Was | 481 | ||
| können soll | 481 | ||
| 5.10.3 Die Klassendefinition | 481 | ||
| 5.10.4 Die Initialisierungsmethode | 483 | ||
| 5.10.5 Der Umgang mit dem Hörer | 484 | ||
| 5.11 Die | 485 | ||
| Klasse | 485 | ||
| 5.11.1 Fähigkeiten der Klasse | 485 | ||
| 5.11.2 Das Prinzip der Soundpufferliste | 486 | ||
| 5.11.3 Die Klassendefinition | 486 | ||
| 5.11.4 Laden des Sounds | 488 | ||
| 5.11.5 Die | 490 | ||
| Methode | 490 | ||
| 5.11.6 Die | 491 | ||
| Methode | 491 | ||
| 5.11.7 Einen Sound abspielen | 492 | ||
| 5.11.8 Abspielen des nächsten Soundpuffers | 492 | ||
| 5.11.9 Die restlichen Methoden … | 493 | ||
| 5.12 Musik ins Spiel bringen | 493 | ||
| 5.12.1 Was unterscheidet Musik von Soundeffekten? | 493 | ||
| 5.12.2 DirectShow-Grundlagen | 494 | ||
| 5.12.3 Kontrolle über den Filtergraphen | 496 | ||
| 5.12.4 Die Klasse | 497 | ||
| 5.12.5 Das Beispielprogramm | 500 | ||
| 5.13 Ausblick | 501 | ||
| 6 Theorie der Spieleprogrammierung | 502 | ||
| 6.1 Was Sie in diesem Kapitel erwartet | 503 | ||
| 6.2 Warum Planung wichtig ist | 503 | ||
| 6.3 Am Anfang steht die Idee | 503 | ||
| 6.3.1 Inspiration | 504 | ||
| 6.3.2 Auf Ideen vorbereitet sein | 505 | ||
| 6.3.3 Aussortieren | 505 | ||
| 6.3.4 Storydesign | 505 | ||
| 6.3.5 Entwicklung eines Ablaufschemas | 507 | ||
| 6.4 Suche nach Teammitgliedern | 507 | ||
| 6.5 Vermitteln des Spiels und gemeinsame Analyse | 507 | ||
| 6.5.1 Die Absichten klarmachen | 508 | ||
| 6.5.2 Machbarkeitsanalyse | 508 | ||
| 6.5.3 Tipps | 509 | ||
| 6.6 Ausarbeitung der Details | 509 | ||
| 6.7 Einteilung in Module | 510 | ||
| 6.8 Level-Design und Atmosphäre | 510 | ||
| 6.8.1 Abenteuer-, Action- und Rollenspiele | 510 | ||
| 6.8.2 Puzzlespiele | 511 | ||
| 6.8.3 Simulatoren | 511 | ||
| 6.8.4 Wann eine Aufgabe zu schwer ist | 511 | ||
| 6.8.5 Tipps für das Level-Design | 512 | ||
| 6.8.6 Allgemeine Tipps für eine bessere Spielatmosphäre | 514 | ||
| 6.9 Tipps zum Programmieren | 516 | ||
| 6.9.1 Planung und Standard | 516 | ||
| 6.9.2 Implementierung neuer Features | 516 | ||
| 6.9.3 Die Liebe zum Detail | 518 | ||
| 6.10 Testen Ihres Spiels | 518 | ||
| 6.10.1 Testen während des Entwicklungsprozesses | 518 | ||
| 6.10.2 Testen des fertigen Spiels | 518 | ||
| 6.11 Ausblick | 520 | ||
| 7 Das erste Spiel | 522 | ||
| 7.1 Was Sie in diesem Kapitel erwartet | 523 | ||
| 7.2 Planung | 523 | ||
| 7.2.1 Das Spielprinzip und der Name des Spiels | 523 | ||
| 7.2.2 Die Darstellung | 524 | ||
| 7.2.3 Die Spielzustände | 524 | ||
| 7.2.4 Das Spielgerüst | 525 | ||
| 7.3 Die Grundklasse | 526 | ||
| 7.3.1 Variablen | 526 | ||
| 7.3.2 Methoden | 527 | ||
| 7.3.3 Die | 532 | ||
| Funktion | 532 | ||
| für Breakanoid | 532 | ||
| 7.4 Das Titelbild | 532 | ||
| 7.4.1 Planung des Titelbilds | 533 | ||
| 7.4.2 Die Schriftarten | 533 | ||
| 7.4.3 Initialisieren, Laden und Entladen des Titelbilds | 534 | ||
| 7.4.4 Rendern des Titelbilds | 535 | ||
| 7.4.5 Bewegung des Titelbilds | 537 | ||
| 7.5 Das Hauptmenü | 537 | ||
| 7.5.1 Planung des Hauptmenüs | 537 | ||
| 7.5.2 Laden, Entladen, Betreten und Verlassen | 538 | ||
| 7.5.3 Rendern | 538 | ||
| 7.5.4 Bewegen des Hauptmenüs | 540 | ||
| 7.5.5 Sound für das Hauptmenü! | 541 | ||
| 7.6 Das Spiel | 542 | ||
| 7.6.1 Planung des Spiels | 543 | ||
| 7.6.2 Schritt 1: die | 544 | ||
| Klasse | 544 | ||
| 7.6.3 Schritt 2: Anzeigen des Levelmodells | 545 | ||
| 7.6.4 Schritt 3: Her mit dem Schläger! | 547 | ||
| 7.6.5 Schritt 4: Ein Levelsystem | 551 | ||
| 7.6.6 Schritt 5: Bälle hinzufügen | 552 | ||
| 7.6.7 Schritt 6: Die Blöcke | 558 | ||
| 7.6.8 Schritt 7: Versuche | 564 | ||
| 7.6.9 Schritt 8: Punkte | 566 | ||
| 7.6.10 Schritt 9: Sound für das Spiel | 567 | ||
| 7.6.11 Schritt 10: Hier spielt die Musik! | 568 | ||
| 7.7 Minimieren im Vollbildmodus | 569 | ||
| 7.7.1 Das Problem | 569 | ||
| 7.7.2 Die Lösung | 569 | ||
| 7.8 Motion-Blurring | 570 | ||
| 7.9 Erweiterungsvorschläge | 573 | ||
| 7.10 Ausblick | 573 | ||
| 8 Das zweite Spiel | 574 | ||
| 8.1 Was Sie in diesem Kapitel erwartet | 575 | ||
| 8.2 Planung | 575 | ||
| 8.2.1 Das Spielprinzip und der Name des Spiels | 575 | ||
| 8.2.2 Die Spielzustände | 576 | ||
| 8.2.3 Die Schiffe | 576 | ||
| 8.2.4 Die Waffensysteme | 577 | ||
| 8.2.5 Speicherung der Informationen | 578 | ||
| 8.2.6 Die Schiffssysteme | 579 | ||
| 8.3 Schiffs- und Waffentypen | 580 | ||
| 8.3.1 Die Struktur | 580 | ||
| 8.3.2 Die Struktur | 581 | ||
| 8.3.3 Laden aus der INI-Datei | 582 | ||
| 8.4 Die Klasse | 584 | ||
| 8.4.1 Unser bisheriger Ansatz | 584 | ||
| 8.4.2 Das neue Prinzip | 584 | ||
| 8.4.3 Position und Skalierung | 585 | ||
| 8.4.4 Ein Fall für die Matrix! | 585 | ||
| 8.4.5 Relativ zu absolut – und zurück | 586 | ||
| 8.4.6 Die Physik kommt hinzu | 587 | ||
| 8.4.7 Implementierung von | 588 | ||
| 8.5 Der Umgang mit Schiffen | 594 | ||
| 8.5.1 Die | 594 | ||
| Klasse | 594 | ||
| 8.5.2 Integrierung in | 596 | ||
| 8.5.3 Bewegen der Schiffe | 597 | ||
| 8.5.4 Kontrolle eines Schiffs | 602 | ||
| 8.5.5 Rendern der Schiffe | 604 | ||
| 8.5.6 Aufschalten von Zielen | 605 | ||
| 8.6 Alle Waffen abfeuern! | 607 | ||
| 8.6.1 Die | 607 | ||
| Klasse | 607 | ||
| 8.6.2 Feuern | 608 | ||
| 8.6.3 Bewegen | 610 | ||
| 8.6.4 Rendern | 612 | ||
| 8.7 Sprites | 612 | ||
| 8.7.1 Was sind Sprites? | 612 | ||
| 8.7.2 Missbrauch der Kameraachsen | 613 | ||
| 8.7.3 Die TriBase-Sprite-Engine | 613 | ||
| 8.7.4 Zurück zum Spiel: Rendern der Laser | 619 | ||
| 8.8 Kollisionserkennung | 623 | ||
| 8.8.1 Rückblick: Umgebungskugel und Umgebungsquader | 623 | ||
| 8.8.2 Das Prinzip der Kollisionserkennung | 623 | ||
| 8.8.3 Kugel – Kugel | 623 | ||
| 8.8.4 Linie – Kugel | 625 | ||
| 8.8.5 Linie – Dreieck | 630 | ||
| 8.8.6 Dreieck – Dreieck | 637 | ||
| 8.8.7 Linie – Quader | 642 | ||
| 8.8.8 Quader – Quader | 647 | ||
| 8.8.9 Wie wir mit Modellen umgehen | 649 | ||
| 8.8.10 Vorberechnungen | 651 | ||
| 8.8.11 Linien und Modelle | 660 | ||
| 8.8.12 Kollision zwischen zwei Modellen | 664 | ||
| 8.8.13 Hardcore-Kollisionserkennung | 668 | ||
| 8.8.14 Volltreffer! | 669 | ||
| 8.8.15 Zusammenstoß zweier Schiffe | 672 | ||
| 8.9 Auto-Aiming | 675 | ||
| 8.9.1 Definition | 675 | ||
| 8.9.2 Der mathematische Hintergrund | 675 | ||
| 8.9.3 Die neue | 676 | ||
| Methode | 676 | ||
| 8.10 „Künstliche Intelligenz“ | 677 | ||
| 8.10.1 Das Verhalten eines Schiffs | 678 | ||
| 8.10.2 Schritt 1: Kurs auf das Ziel nehmen | 678 | ||
| 8.10.3 Schritt 2: Feuern | 680 | ||
| 8.10.4 Schritt 3: Ausweichmanöver bei Treffer | 681 | ||
| 8.10.5 Schritt 4: Ausweichmanöver bei drohender Kollision | 682 | ||
| 8.10.6 Schritt 5: Wechseln des Ziels | 683 | ||
| 8.11 Partikel | 683 | ||
| 8.11.1 Was Partikel sind | 683 | ||
| 8.11.2 Das Partikelsystem der TriBase-Engine | 684 | ||
| 8.11.3 Antriebs- und Raketenflammen | 685 | ||
| 8.11.4 Explosionen | 686 | ||
| 8.11.5 Aufleuchten des Schutzschilds | 689 | ||
| 8.11.6 Trümmer | 691 | ||
| 8.12 Weitere optische Verfeinerungen | 692 | ||
| 8.12.1 Sky-Box, Licht und Nebel | 692 | ||
| 8.12.2 Ein „Sternenfeld“ | 695 | ||
| 8.12.3 Glühen von Projektilen | 697 | ||
| 8.13 Die Kamera | 697 | ||
| 8.14 Das Cockpit | 700 | ||
| 8.14.1 Das Cockpitmodell | 700 | ||
| 8.14.2 Die Anzeigen | 701 | ||
| 8.14.3 Das HUD | 704 | ||
| 8.14.4 Radar | 705 | ||
| 8.15 Der Sound | 711 | ||
| 8.15.1 Schüsse | 711 | ||
| 8.15.2 Antriebssounds | 712 | ||
| 8.15.3 Der Hörer | 713 | ||
| 8.16 Die Benutzeroberfläche | 713 | ||
| 8.16.1 Die TriBase-Benutzeroberfläche | 714 | ||
| 8.16.2 Erstellung des Hauptmenüs | 723 | ||
| 8.17 Optimierungen und der Feinschliff | 730 | ||
| 8.17.1 Sichtbarkeit eines Objekts | 730 | ||
| 8.17.2 Render-Modell und Kollisionsmodell | 734 | ||
| 8.17.3 Musik | 735 | ||
| 8.17.4 Wackelndes Cockpit | 735 | ||
| 8.17.5 Screenshots schießen | 735 | ||
| 8.18 Erweiterungsvorschläge | 736 | ||
| 8.19 Ausblick | 737 | ||
| 9 Fortgeschrittene Techniken | 738 | ||
| 9.1 Was Sie in diesem Kapitel erwartet | 739 | ||
| 9.2 Schatten mit dem Stencil-Buffer | 739 | ||
| 9.2.1 Schatten in der 3D-Grafik | 739 | ||
| 9.2.2 Ansätze | 739 | ||
| 9.2.3 Das Prinzip | 740 | ||
| 9.2.4 Die Klasse | 745 | ||
| 9.2.5 Das Beispielprogramm | 754 | ||
| 9.3 Videos abspielen | 754 | ||
| 9.3.1 Zielsetzung | 754 | ||
| 9.3.2 Schreiben eines eigenen Filters | 754 | ||
| 9.3.3 Verwenden des Filters | 764 | ||
| 9.3.4 Der Back-Buffer-Mechanismus | 767 | ||
| 9.3.5 Videos in den Speicher laden | 767 | ||
| 9.4 Stereo-3D-Grafik | 768 | ||
| 9.4.1 Das räumliche Sehen | 768 | ||
| 9.4.2 Trennen der Bilder | 769 | ||
| 9.4.3 Implementierung | 771 | ||
| 9.4.4 Beispielprogramme | 772 | ||
| 9.5 Raumaufteilung | 772 | ||
| 9.5.1 Rekursives Rendern | 772 | ||
| 9.5.2 PVS und Portale | 773 | ||
| 9.5.3 Light-Mapping | 774 | ||
| 9.5.4 Die TriBase-Klasse | 776 | ||
| 9.6 Terrain-Rendering | 776 | ||
| 9.6.1 Repräsentierung eines Terrains | 777 | ||
| 9.6.2 Unterteilung des Terrains | 777 | ||
| 9.6.3 Erzeugen der Dreiecke | 778 | ||
| 9.6.4 Terrain-Rückruffunktion | 779 | ||
| 9.6.5 Geo-MIP-Mapping | 779 | ||
| 9.6.6 Texturierung | 779 | ||
| 9.6.7 Beleuchtung | 781 | ||
| 9.6.8 Das TriBase-Tool | 781 | ||
| 9.7 Die Welt der Shader | 783 | ||
| 9.7.1 Was ein Shader ist | 783 | ||
| 9.7.2 Einsatzgebiete | 783 | ||
| 9.7.3 Die fixe und die programmierbare Rendering-Pipeline | 784 | ||
| 9.7.4 Ein einfacher Vertex-Shader | 784 | ||
| 9.7.5 Ein einfacher Pixel-Shader | 787 | ||
| 9.7.6 Praktischer Einsatz von Shadern | 789 | ||
| 9.7.7 Weiterführende Quellen und Referenz | 799 | ||
| 9.8 Charakteranimation | 800 | ||
| 9.8.1 Das Grundprinzip | 800 | ||
| 9.8.2 Skinning in Hardware | 801 | ||
| 9.8.3 Skinning mit D3DX | 802 | ||
| 9.8.4 Weitere Informationen | 802 | ||
| 9.9 PlugIns schreiben und laden | 802 | ||
| 9.9.1 DLL-Dateien explizit laden | 802 | ||
| 9.9.2 Adresse einer Funktion abfragen | 803 | ||
| 9.9.3 DLL-Dateien erzeugen | 804 | ||
| 9.9.4 Die Kommunikation zwischen Anwendung und PlugIn | 806 | ||
| 9.9.5 Das Beispielprogramm | 806 | ||
| 9.10 Arbeiten mit Threads | 806 | ||
| 9.10.1 Prozesse im Betriebssystem | 806 | ||
| 9.10.2 Was ist ein Thread? | 807 | ||
| 9.10.3 Die Thread-Funktion | 808 | ||
| 9.10.4 Erzeugen eines Threads | 808 | ||
| 9.10.5 Verwaltungsfunktionen | 809 | ||
| 9.10.6 Thread-Synchronisierung | 810 | ||
| 9.10.7 Zusammenfassung | 815 | ||
| 9.11 Eine einfache Skriptsprache | 815 | ||
| 9.11.1 Einsatzgebiet von Skriptsprachen | 815 | ||
| 9.11.2 Ein Skript als Liste von Befehlen | 816 | ||
| 9.11.3 Verwendung von Funktionszeigern | 816 | ||
| 9.11.4 Übergabe von Parametern | 817 | ||
| 9.11.5 Einen Thread verwenden | 818 | ||
| 9.11.6 Die Klasse | 818 | ||
| 9.11.7 Das Beispielprogramm | 824 | ||
| 9.11.8 Fortgeschrittene Skriptsprachen | 825 | ||
| 9.12 Interpolationen | 825 | ||
| 9.12.1 Nachteil linearer Interpolationen | 825 | ||
| 9.12.2 Hermite-Interpolation mit Tangenten | 826 | ||
| 9.12.3 In zwei Richtungen – die bilineare Interpolation | 830 | ||
| 9.13 Abstrakte Spiel- und Spielzustandsklassen | 831 | ||
| 9.13.1 Die Spielzustandsklasse | 831 | ||
| 9.13.2 Die Spielklasse | 833 | ||
| 9.13.3 Die Anwendung | 835 | ||
| 9.14 Fixed-Step-Spiellogik | 835 | ||
| 9.14.1 Die Problematik | 835 | ||
| 9.14.2 Ein Lösungsansatz | 836 | ||
| 9.15 Online-Highscores und Versionskontrolle | 840 | ||
| 9.15.1 Die Möglichkeiten | 840 | ||
| 9.15.2 Die Realisierung | 840 | ||
| 9.15.3 Internetseiten in einem C++-Programm abrufen | 841 | ||
| 9.16 Ausblick | 842 | ||
| 10 FAQ, Internetseiten und CD- ROM (Inhalte auf Anfrage erhältlich) | 844 | ||
| 10.1 FAQ | 845 | ||
| 10.2 Interessante Internetseiten | 846 | ||
| 10.3 Die Programme auf der Begleit-CD-ROM | 848 | ||
| 10.3.1 3Dografe | 848 | ||
| 10.3.2 AC3D v5.021 Demo | 849 | ||
| 10.3.3 MilkShape 3D v1.76 Demo | 850 | ||
| 10.3.4 POV-Ray v3.6 | 851 | ||
| 10.3.5 Sound Forge 7 Demo | 852 | ||
| 10.3.6 Terragen 0.943 | 853 | ||
| 10.3.7 Texture Maker v2.81 Demo | 854 | ||
| 10.3.8 Visual Assist X Demo | 855 | ||
| 10.3.9 2D-Game-Framework | 855 | ||
| 10.4 Das Ende | 855 | ||
| Index | 856 | ||
| Mehr eBooks bei www.ciando.com | 0 |