3D-Spieleprogrammierung mit DirectX 9 und C++ (eBook)

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

3 3D-Grafik mit der TriBase-Engine (S. 274-275)

3.1 Was Sie in diesem Kapitel erwartet

Nun sind alle grundlegenden Direct3D-Themen abgehandelt. Wir beschäftigen uns jetzt damit, wie man sich die Arbeit mit Direct3D ein wenig erleichtern kann – nämlich durch die Einführung einer Klasse für 3D-Grafik in der TriBase-Engine. Sie werden zum Beispiel lernen, wie man Modelldateien lädt oder Texte darstellt. Diese Techniken werden später zur Erstellung der Spiele verwendet.

3.2 Direct3D mit der TriBase-Engine
Sie haben nun die wichtigsten Dinge über Direct3D gelernt. Natürlich war das noch längst nicht alles, doch sehen Sie bitte ein, dass es unmöglich ist, alle Themen in einem Buch zu behandeln, das einen möglichst breitflächigen Überblick über das große Gebiet der Spieleprogrammierung vermitteln soll. Wer genauer wissen möchte, wie Direct3D im Inneren funktioniert und welche weiteren Techniken es bietet, sollte sich unbedingt Literatur speziell über das Thema Direct3D anschaffen (zum Beispiel vom Microsoft Press-Verlag). Nun, da Sie einen Überblick über Direct3D erhalten haben, können wir damit beginnen, die TriBase-Engine so zu erweitern, dass viele Arbeitsschritte vereinfacht werden können.

3.2.1 Was uns das Leben leichter machen kann
3.2.1.1 Automatische Initialisierung von Direct3D
Die bisherigen Beispielprogramme verwendeten alle die Dateien INITWINDOW.CPP, INITDIRECT3D. CPP und DIRECT3DENUM.CPP. Mit den in diesen Dateien enthaltenen Funktionen wurde dann ein Fenster erstellt, der Direct3D-Konfigurationsdialog angezeigt, und schließlich wurden alle für die Arbeit mit Direct3D notwendigen Schnittstellen erzeugt, so dass sich die Beispielprogramme auf das Wesentliche beschränken konnten. Den Konfigurationsdialog werden wir auch für die TriBase-Engine übernehmen, und auch die Initialisierung wird ähnlich vonstatten gehen. Wichtig ist, dass der Benutzer stets freie Kontrolle über die verwendete Auflösung, den Direct3D-Adapter, die Oberflächenformate und sonstige Einstellungen hat, um für sich die optimale Kombination finden zu können. Die neue Funktion zum Aufrufen des Konfigurationsdialogs – der nicht nur für Direct3D zuständig sein wird – heißt tbDoConfigDialog. Die Konfigurationsstruktur heißt nun tbConfig und besteht aus Unterstrukturen, wovon eine den Namen Direct3D trägt; darin befinden sich alle wichtigen Direct3D-Einstellungen wie Adapter, Videomodus oder Oberflächenformate.

3.2.1.2 Statusänderungen minimieren

Immer wenn wir ein Render- oder ein Texturschicht-State, eine Matrix, eine Lichtquelle, ein Material, eine Textur oder Sonstiges mit irgendeiner Set-Methode der IDirect3DDevice9- Schnittstelle aktivieren, muss Direct3D das dem Grafikkartentreiber mitteilen, der es wiederum – je nach Art der Änderung – an die Grafikkarte weiterleitet. Vor allem beim Setzen einer neuen Textur, die vielleicht noch im Systemspeicher wartet und dann zur Grafikkarte transferiert werden muss, kann dabei eine Menge Zeit verloren gehen. Daher sollte man als „umweltbewusster" Programmierer immer darauf achten, nicht unnötig viele Änderungen vorzunehmen (zum Beispiel Alpha-Blending ein- und direkt danach wieder auszuschalten).

Die Direct3D-Komponente der TriBase-Engine werden wir daher so entwerfen, dass sie unnötige – doppelte – Statusänderungen wie Render-States, Texturen oder was auch immer automatisch erkennt und gar nicht erst an die Geräteschnittstelle weiterleitet. Es wird dazu eine interne Tabelle mit den Werten aller Render- und Texturschicht-States, Texturen und dem aktuellen Vertexformat angelegt, welche die Engine stets aktualisiert und zum Vergleich heranzieht, wenn ein neuer Status gesetzt werden soll. Wenn dieser dann bereits in der Tabelle steht, wäre es unsinnig, ihn erneut zu aktivieren.

Nach Angaben von Microsoft sollte man sich niemals darauf verlassen, dass der Grafikkartentreiber sich um solche Probleme kümmert – also lieber selbst die Initiative ergreifen!

3.2.1.3 Texturverwaltung

Oft kann es vorkommen, dass ein Spiel Ressourcen verschwendet, indem es bestimmte Texturen zweimal lädt (wenn zum Beispiel zwei verschiedene 3D-Modelle die gleiche Textur verwenden). Um das zu verhindern, werden wir eine automatische Texturverwaltung implementieren, bei welcher das Programm Texturen anfordern und später wieder löschen kann. Existiert eine angeforderte Textur noch nicht, wird sie geladen – andernfalls wird die bereits geladene Textur zurückgeliefert. Die Texturverwaltung wird vollen Gebrauch von der TriBase- Klasse tbVFile machen. Erinnern Sie sich noch an diese Klasse? Mit ihr können wir virtuelle Dateien aus echten Dateien, aus dem Speicher, aus Ressourcen und aus eventuell verschlüsselten Zip-Archiven laden und alle auf die gleiche Weise behandeln.

3.2.1.4 Vertex- und Index-Buffer einfacher erstellen

Oftmals schreckt man vor der Arbeit mit Vertex- und Index-Buffern zurück, da sie immer einen gewissen Arbeitsaufwand mit sich bringen: Erst muss man sie mühsam erstellen, dann sperren, mit Daten füllen, wieder entsperren, vor dem Zeichnen als Datenstromquelle festlegen und am Ende wieder freigeben. Wie Sie vielleicht bemerkt haben, habe auch ich mich um die Vertex- und Index-Buffer gedrückt, wenn es ging: Die meisten Beispielprogramme, die nur wenige Primitiven zu zeichnen hatten (zum Beispiel ein Rechteck), legten die Vertizes lieber im Systemspeicher an, als dafür Puffer zu erstellen.

Dem soll nun ein Ende gemacht werden, indem wir zwei Klassen für Vertex- und Index- Buffer implementieren werden. Ein einfacher Aufruf des Konstruktors soll dabei reichen, um einen Puffer generieren zu lassen, und auch das Füllen mit Daten soll wesentlich einfacher werden.