Spiele effektiv programmieren mit VB.NET und DirectX

Die Reihe Xpert.press vermittelt Professionals in den Bereichen Softwareentwicklung, Internettechnologie und IT-Managem...

Author: Uwe Kettermann | Andreas Rohde

63 downloads 1155 Views 5MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

Die Reihe Xpert.press vermittelt Professionals in den Bereichen Softwareentwicklung, Internettechnologie und IT-Management aktuell und kompetent relevantes Fachwissen über Technologien und Produkte zur Entwicklung und Anwendung moderner Informationstechnologien.

Uwe Kettermann · Andreas Rohde

Spiele effektiv programmieren mit VB.net und DirectX

Mit 84 Abbildungen und CD-ROM

123

Uwe Kettermann Schützenstraße 36 59457 Werl [email protected]

Andreas Rohde Hahnenmühlenweg 17 44147 Dortmund [email protected]

Bibliografische Information der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.

ISSN 1439-5428 ISBN 3-540-21080-6 Springer Berlin Heidelberg New York Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere d ie der Übersetzung, des Nachdr ucks , des Vortrags, der Entnahme von Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfältigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfältigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. September 1965 in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich vergütungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes. Springer ist nicht Urheber der Daten und Programme. Weder Springer noch die Autoren übernehmen die Haftung für die CD-ROM und das Buch, einschließlich ihrer Qualität, Handels- und Anwendungseignung. In keinem Fall übernehmen Springer oder die Autoren Haftung für direkte, indirekte, zufällige oder Folgeschäden, die sich aus der Nutzung der CD-ROM oder des Buches ergeben. Springer ist ein Unternehmen von Springer Science+Business Media springer.de © Springer-Verlag Berlin Heidelberg 2005 Printed in Germany Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutzgesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Text und Abbildungen wurden mit größter Sorgfalt erarbeitet. Verlag und Autor können jedoch für eventuell verbliebene fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Umbruch: Gerd Blumenstein DA-TEX, Leipzig Herstellung: LE-TEX Jelonek, Schmidt & Vöckler GbR, Leipzig Umschlaggestaltung: KünkelLopka Werbeagentur, Heidelberg Gedruckt auf säurefreiem Papier 33/3142/YL - 5 4 3 2 1 0

Danksagung Die Autoren bedanken sich bei Christoph, Kim, Sebastian, Vera und Yvonne, ohne deren Geduld und Unterstützung dieses Buch nicht hätte realisiert werden können.

Vorwort Bevor Sie in die aufregende Welt der Programmierung einsteigen, müssen Sie sich für eine Programmiersprache entscheiden. In der klassischen Sichtweise werden Programmiersprachen in Compiler- und Interpretersprachen unterschieden. Mit den neuen .NET-Sprachen ändert sich das. Hier wird ein vorkompilierter Sourcecode erstellt, welche dann per Microsoft Framework interpretiert und final kompiliert wird. Die wesentliche Vorteile dieser Handhabung liegen auf der Hand. Eine außergewöhnlich hohe Performance sowie eine plattformunabhängige Kompatibilität sind die Merkmale dieses Konzepts. VB.NET ist der Nachfolger von Visual Basic 6. Visual Basic ist vor allem durch die leichte Syntax sowie einer benutzerfreundlichen Entwicklungsumgebung bekannt geworden. Die Einfachheit dieser Sprache forderte aber einen hohen Preis. Visual Basic-Programme waren langsam und in Ihrer Funktionalität eingeschränkt. Dies änderte sich bereits mit der Version 5 und wurde in der Version 6 nochmals verbessert. Die perfekte Symbiose zwischen Leichtigkeit und Leistungsfähigkeit wird aber mit VB.NET erzielt. Neben den Vorzügen, welche VB.NET für die Entwicklung von Officeapplikationen bietet, fordern wir aber mehr. Wir wollen DirectX beherrschen. Wir müssen uns die Frage stellen: Ist VB.NET zur Programmierung mit DirectX geeignet? Die Antwort lautet: JA! VB.NET bietet zum einen die notwendige Performance und zum anderen eine ideale Integration von Managed DirectX. Managed DirectX ist speziell auf die neuen Programmiersprachen C# und VB.NET zugeschnitten. Diese Programmiersprachen sind feste Bestandteile der Microsoft Visual Studio.NET-Philosophie und werden kontinuierlich gefördert und weiterentwickelt. Dieses Buch wird Ihnen in beeindruckender Art und Weise die Leistungsfähigkeit von VB.NET und Managed DirectX demonstrieren. Sie werden tiefe Einblicke in die Welt der Multimediaprogrammierung erhalten. Wir werden mit Ihnen zusammen ein komplette Direct3D-Spiel gestalten und programmiertechnisch umsetzen. Spezialeffekte wie Transparenz, Nebel, Lichteffekte, Partikeleffekte, Billboarding usw. werden für Sie nicht länger im Verborgenen bleiben.

Inhaltsverzeichnis

Inhaltsverzeichnis ....................................................................................IX 1

Die Buchstruktur............................................................................... 1

2

Was ist VB.NET? .............................................................................. 3 2.1 Unterschiede zu Visual Basic 6................................................ 3 2.1.1 Rapid Application Development ................................ 4 2.1.2 Vererbung................................................................... 4 2.1.3 Ausnahmebehandlung ................................................ 4 2.1.4 Überladung ................................................................. 4 2.1.5 Overrides: Überschreiben von Methoden und Eigenschaften ............................................................. 5 2.1.6 Konstruktoren und Destruktoren ................................ 6 2.1.7 Datentypen.................................................................. 6 2.1.8 Verweise..................................................................... 7 2.1.9 Namespaces ................................................................ 7 2.1.10 Assemblies.................................................................. 7 2.1.11 Multithreading ............................................................ 7 2.1.12 Common Language Runtime (CLR) .......................... 7 2.1.13 Garbage Collection..................................................... 8

3

Die Entwicklungsumgebungen von VB.NET................................ 11 3.1 Das Visual Studio .NET ......................................................... 13 3.1.1 Formdesigner............................................................ 15 3.1.2 Werkzeugfenster....................................................... 16 3.1.3 Eigenschaftenfenster ................................................ 16 3.1.4 Projektexplorer ......................................................... 17 3.1.5 Pin-Nadel-Symbol .................................................... 17 3.2 SharpDevelop ......................................................................... 18 3.2.1 Code-Competion-Datenbank.................................... 18 3.2.2 Der erste Start........................................................... 20

4

„Hello World“ das erste .NET-Programm ................................... 23

X

Inhaltsverzeichnis

4.1 4.2

Ein einfaches Programm mit einem einfachen Editor............ 23 4.1.1 Der Sourcecode ........................................................ 23 4.1.2 Der Compiler............................................................ 24 Ein Projekt im Visual Studio.NET......................................... 25

5

Variablen ......................................................................................... 29 5.1 Deklaration ............................................................................. 30 5.2 Datentypen und Konstanten ................................................... 30 5.2.1 Der richtige Datentyp ............................................... 32 5.2.2 Konstanten................................................................ 34 5.2.3 Strukturen ................................................................. 37 5.3 Typensicherheit ...................................................................... 38 5.4 Ermitteln des Variablentyps ................................................... 41

6

Operatoren....................................................................................... 43 6.1 Arithmetische Operatoren ...................................................... 43 6.2 Vergleichsoperatoren ............................................................. 45 6.2.1 Mit dem Gleich-Operator Werte zuweisen! ............. 45

7

Verzweigungen ................................................................................ 47 7.1 Verzweigungen oder Entscheidungen? .................................. 47 7.2 If-Then-Else-Anweisung........................................................ 47 7.2.1 Notationsunterschiede! ............................................. 50 7.2.2 Verschachtelungen oder ElseIf:ElseIf ...................... 50 7.3 Select-Case-Anweisungen...................................................... 53

8

Schleifen ........................................................................................... 57 8.1 For-Next-Schleife................................................................... 58 8.2 Do-Loop-Schleife................................................................... 59 8.2.1 Endlosschleifen ........................................................ 62 8.3 While-End-While-Schleife..................................................... 62 8.4 For-Each-Schleife .................................................................. 63

9

Arrays............................................................................................... 67 9.1 Statische Arrays ..................................................................... 67 9.2 Dynamische Arrays ................................................................ 68 9.2.1 GetUpperBound........................................................ 69 9.3 Mehrdimensionale Arrays ...................................................... 70

10

Funktionen und Subroutinen......................................................... 73 10.1 Subroutinen ............................................................................ 73 10.1.1 ByVal oder ByRef .................................................... 75 10.2 Funktionen.............................................................................. 75

Inhaltsverzeichnis

XI

10.2.1 Return ....................................................................... 76 10.2.2 Optionale Parameter ................................................. 77 10.3 Rekursives Programmieren .................................................... 78 11

Klassen ............................................................................................. 81 11.1 Was ist eine Klasse?............................................................... 81 11.2 Nothing................................................................................... 82 11.3 Felder...................................................................................... 83 11.4 Subroutinen und Funktionen .................................................. 84 11.5 Eigenschaften: Property ......................................................... 86 11.5.1 Parameter in Properties............................................. 87 11.5.2 Eingeschränkte Properties ........................................ 88 11.6 Enumerationen in Klassen...................................................... 89 11.7 Events..................................................................................... 90 11.8 Ein umfassendes Beispiel....................................................... 92 11.8.1 Erstellen der Klasse .................................................. 93 11.8.2 Klasse mit Daten füllen ............................................ 95 11.8.3 Daten aus der Klasse lesen ....................................... 95 11.9 Shared-Mitglieder................................................................... 96 11.10 Vererbung............................................................................... 97 11.10.1 Overrides .................................................................. 99 11.10.2 MyBase................................................................... 101 11.10.3 MustOverride und MustInherit............................... 102

12

Namespaces.................................................................................... 103 12.1 Namespaces ansprechen ....................................................... 104 12.1.1 Imports.................................................................... 104

13

Assemblies...................................................................................... 107 13.1 Arbeitsweise von Assemblies............................................... 108 13.2 Shared Assembly.................................................................. 108

14

Fehlerbehandlung ......................................................................... 109 14.1 Try-Catch-Finally-Anweisung ............................................. 109 14.1.1 Ausnahmebehandlung (Beispiel)............................ 110 14.2 OnError-GoTo-Befehl.......................................................... 111

15

Was ist DirectX.............................................................................. 113 15.1 Die Säulen von DirectX ....................................................... 113 15.2 Die Einsatzgebiete für DirectX ............................................ 115

16

DirectX-Grundlagen ..................................................................... 117 16.1 Das Koordinatensystem........................................................ 117

XII

Inhaltsverzeichnis

16.2 Primitives ............................................................................. 119 16.2.1 Primitives rendern .................................................. 121 16.2.2 Vorder- und Rückseite............................................ 125 17

Mein erstes DirectX-Programm .................................................. 127 17.1 Ein Visual Studio .NET-Projekt erstellen ............................ 127 17.2 Direct3D-Device erzeugen ................................................... 129 17.3 Rendern ................................................................................ 131

18

Mein erstes Objekt im 3D-Raum ................................................. 135 18.1 Vertexbuffer erstellen........................................................... 136 18.2 Vertexbuffer mit Objektdaten füllen .................................... 137 18.3 Vertexbuffer rendern ............................................................ 139

19

World-, View- und Projektionsmatrix ........................................ 141 19.1 Worldmatrix ......................................................................... 141 19.2 Viewmatrix........................................................................... 142 19.3 Projektionsmatrix ................................................................. 143

20

Device Enumeration...................................................................... 145 20.1 DXSettings ........................................................................... 145 20.1.1 Display-Adapter ..................................................... 148 20.1.2 Hardwarebeschleunigung (DeviceTyp).................. 149 20.1.3 Videomodus ........................................................... 150 20.1.4 Backbuffer-Format ................................................. 152 20.1.5 Z-Stencilbuffer-Format (Depth-Stencilbuffer-Format)................................. 154 20.1.6 Multisample-Typ .................................................... 155 20.1.7 Vertex-Processing .................................................. 157 20.2 DXSettings im praktischen Einsatz...................................... 159 20.2.1 Preset-Struktur........................................................ 160 20.2.2 DXSettings initialisieren ........................................ 162

21

Matrizen......................................................................................... 165 21.1 Was ist eine Matrix .............................................................. 165 21.1.1 Einheitsmatrix ........................................................ 166 21.1.2 Addition.................................................................. 166 21.1.3 Subtraktion ............................................................. 166 21.1.4 Multiplikation......................................................... 167 21.1.5 Division .................................................................. 167 -1 21.1.6 Berechnen der invertierten Matrix M ................... 168 21.2 Transformation ..................................................................... 169

Inhaltsverzeichnis

XIII

21.2.1 Bewegt sich die Welt oder bewegt sich das Objekt? ......................................... 170 21.2.2 Translation (Bewegung, Positionsveränderung).... 170 21.2.3 Skalieren (Größenänderung) .................................. 171 21.2.4 Rotation (Drehung)................................................. 172 21.2.5 Grad vs Radiant ...................................................... 174 21.2.6 Beispielprogramm für Matrizen ............................. 175 22

Texturen......................................................................................... 181 22.1 Texturkoordinaten ................................................................ 181 22.2 Kacheln einer Textur............................................................ 183 22.3 Das passende Vertexformat.................................................. 184 22.4 Größe einer Textur ............................................................... 185 22.4.1 Auslesen der maximalen Texturbreite und Höhe ... 186 22.5 Laden einer Textur ............................................................... 186 22.6 Texturfilter ........................................................................... 188 22.6.1 MinFilter und MagFilter......................................... 188 22.6.2 Nearest Point Sampling .......................................... 188 22.6.3 Linearer Texturfilter ............................................... 189 22.6.4 Anisotropic Filter (uneinheitlicher Filter) .............. 189 22.6.5 Bilineare und uneinheitliche Filterung ................... 190 22.6.6 Mipmaps................................................................. 190 22.7 Beispielprogramm für Texturen ........................................... 191 22.7.1 Ermitteln der maximalen Texturbreite und -höhe .. 192 22.7.2 Erstellen des Vertexbuffers .................................... 193 22.7.3 Erstellen und Laden einer Textur ........................... 195 22.7.4 Rendern .................................................................. 196 22.8 Multitexturing (Multi Texture Mapping) ............................ 197 22.8.1 Mischparameter ...................................................... 198 22.8.2 Multi-Pass-Technik vs. Single-Pass-Technik......... 201 22.8.3 Texturkoordinaten, Vertexformat und Vertexbuffer ........................................................... 202 22.8.4 Beispielprogramm für Multitexturing .................... 204 22.9 Alpha-Textur-Blending ........................................................ 211 22.9.1 Texturfaktor............................................................ 211

23

Licht: Beleuchtung........................................................................ 213 23.1 Licht und Material................................................................ 214 23.2 Direct3D.Lights.................................................................... 214 23.3 Normalvektor ....................................................................... 215 23.3.1 Berechnung des Normalvektors ............................. 217 23.4 Lichttypen ............................................................................ 218 23.4.1 Ambient-Light ........................................................ 219

XIV

Inhaltsverzeichnis

23.5

23.6 23.7 23.8 23.9

23.4.2 Point-Light ............................................................. 220 23.4.3 Directional-Light .................................................... 221 23.4.4 Spot-Light............................................................... 222 23.4.5 Welcher Lichttyp ist der beste? .............................. 224 Licht, Schatten und Polygone............................................... 225 23.5.1 Flat-Shading ........................................................... 225 23.5.2 Gouraud-Shading.................................................... 226 23.5.3 Phong-Shading ....................................................... 227 Licht und Polygone .............................................................. 227 Beispielprogramm für Licht und Polygone .......................... 228 23.7.1 Erstellen der Flächen .............................................. 229 23.7.2 Erstellen der Lichter ............................................... 232 Beispielprogramm für Lichttypen ........................................ 234 23.8.1 Boden und Wände erstellen.................................... 236 23.8.2 Lichtquellen initialisieren....................................... 239 Licht und Mesh .................................................................... 242 23.9.1 Beispielprogramm für Licht und Mesh .................. 243

24

Material.......................................................................................... 245 24.1 Zusammenspiel zwischen Material und Licht...................... 245 24.1.1 Die Bestandteile des Materials ............................... 246 24.1.2 Diffuse .................................................................... 246 24.1.3 Ambient .................................................................. 247 24.1.4 Specular .................................................................. 247 24.1.5 Emissive ................................................................. 247 24.2 Material initialisieren und aktivieren ................................... 247 24.3 Beispielprogramm für Material ............................................ 248

25

Meshobjekte................................................................................... 251 25.1 Erstellen eines Mesh–Objektes ............................................ 252 25.2 Laden eines Mesh-Objektes ................................................. 253 25.3 Darstellen eines Mesh-Objektes........................................... 255

26

Animation des Mesh-Objektes Frame-Animation ..................... 259 26.1 Prinzip der Frame-Animation............................................... 260 26.2 Timing bei der Frame-Animation ........................................ 260 26.3 Mesh-Objekte: Tweening/Keyframe-Animation ................. 263 26.4 Keyframe-Bestimmung ........................................................ 273 26.5 Keyframe-Interpolation........................................................ 274 26.6 Keyframe rendern................................................................. 278

27

Billboarding ................................................................................... 281 27.1 Was sind Billboards?............................................................ 281

Inhaltsverzeichnis

XV

27.2 Warum werden Billboards eingesetzt?................................. 282 27.2.1 Schlechtes Billboarding.......................................... 282 27.2.2 Gutes Billboarding ................................................. 282 27.3 Berechnungsmethoden ......................................................... 283 27.4 Beispielprogramm für Billboarding ..................................... 284 27.4.1 Textureoberfläche erstellen .................................... 285 27.4.2 Hauptspieleschleife erzeugen ................................. 286 27.4.3 Rendern .................................................................. 287 28

Wasser ............................................................................................ 291 28.1 Technik zum Erstellen der Wasseroberfläche ...................... 292 28.2 Aufbau der Wasseroberfläche (Gittergerüst) ....................... 294 28.3 Wasseroberfläche erstellen (inkl. Wellen und Textur)......... 295 28.4 Schwimmende Kisten integrieren ........................................ 297 28.5 Rendern Alpha-Blending...................................................... 298

29

Nebel............................................................................................... 301 29.1 Was kann Nebel?.................................................................. 302 29.2 Berechnungsarten ................................................................. 302 29.2.1 Linear Fog .............................................................. 302 29.2.2 Exponential Fog ..................................................... 303 29.3 VertexFog oder Pixel-Fog/Table-Fog .................................. 304 29.3.1 Prüfung ................................................................... 305 29.4 Die wahre Tiefe.................................................................... 306 29.5 Renderstates ......................................................................... 307 29.6 Beispielprogramm für Nebel ................................................ 308 29.6.1 Erstellen der Straße ................................................ 309 29.6.2 Einbinden der Meshes (Bäume und Auto) ............. 310 29.6.3 Initialisierung des Nebels ....................................... 311 29.6.4 Rendern .................................................................. 312

30

Partikeleffekte ............................................................................... 315 30.1 Partikelstruktur ..................................................................... 317 30.2 Zweidimensional vs. dreidimensional.................................. 318 30.3 Partikelklasse........................................................................ 320 30.4 Rendern ................................................................................ 323 30.5 GUI....................................................................................... 327

31

DirectSound: Modell..................................................................... 329 31.1 DirectSound-DeviceInformation .......................................... 330 31.2 DirectSound-Device ............................................................. 330 31.3 DirectSound-Buffer.............................................................. 331 31.4 DirectSound-3DBuffer ......................................................... 332

XVI

Inhaltsverzeichnis

31.4.1 Ausrichtung des 3DBuffers .................................... 333 31.5 DirectSound-3DListener ...................................................... 334 31.5.1 Ausrichtung des 3DListeners ................................. 334 31.6 DirectSound-CaptureBuffer ................................................. 334 32

2DSound-Demo ............................................................................. 337

33

3DSound-Demo ............................................................................. 345

34

AudioVideoPlayback .................................................................... 353 34.1 Ein Wort zu DirectMusic ..................................................... 353 34.2 AudioVideoPlayback generell.............................................. 353 34.3 Audio.................................................................................... 354 34.4 Video .................................................................................... 358

35

DirectInput .................................................................................... 361 35.1 Objekthierarchie ................................................................... 361 35.2 Geräteauflistung ................................................................... 362 35.2.1 Beispielprogramm .................................................. 363 35.2.2 Eingabegeräte ermitteln.......................................... 363 35.2.3 Objekte ermitteln.................................................... 365 35.3 Kooperationsebene ............................................................... 367 35.4 Datenformat.......................................................................... 368 35.5 Daten empfangen ................................................................. 368 35.6 Keyboard (Beispielprogramm)............................................. 369 35.6.1 Sourcecode-Beispiel 1 ............................................ 369 35.6.2 Sourcecode-Beispiel 2 ............................................ 370 35.7 Maus..................................................................................... 374 35.7.1 Kooperationsebene anlegen und das Device erzeugen............................................... 375 35.7.2 Daten abfragen ....................................................... 376 35.8 Joystick................................................................................. 377 35.8.1 Angeschlossene Joysticks ermitteln ....................... 379 35.8.2 Akquirieren und Achseneigenschaften festlegen ... 380 35.8.3 Daten abfragen ....................................................... 380 35.9 First-Person-Camera............................................................. 383 35.9.1 Variablen und Strukturen definieren ...................... 384 35.9.2 Erzeugen der DirectInput-Devices ......................... 385 35.9.3 Maus- und Tastaturdaten empfangen ..................... 386 35.9.4 Maus- und Tastaturdaten auswerten....................... 387

36

DirectPlay ...................................................................................... 391 36.1 Service-Provider................................................................... 392

Inhaltsverzeichnis

36.2 36.3 36.4 36.5 36.6 36.7 36.8 36.9

XVII

Wie ist eine Peer-to-Peer Verbindung aufgebaut? ............... 393 Erstellen einer GUID............................................................ 394 Host ...................................................................................... 395 Player.................................................................................... 395 36.5.1 Host suchen ............................................................ 396 36.5.2 Player erstellen und an der Session anmelden........ 398 Senden von Daten................................................................. 398 Empfangen von Daten.......................................................... 399 Beispielprogramm: Simple Chat .......................................... 400 Kommunikationsmodelle ..................................................... 402 36.9.1 Peer-to-Peer-Session .............................................. 402 36.9.2 Client/Server-Session ............................................. 402 36.9.3 Sicherheit................................................................ 402

37

Das Spiel: Return From Orion .................................................... 405 37.1 Erste Gedanken zum Spiel ................................................... 406 37.2 Von der ersten Spielidee zu einem Konzept ........................ 406 37.3 Der Entwicklungsprozess oder die Arbeit vor der Arbeit ... 408 37.4 Festlegung des Spielprinzips/Spielablaufs ........................... 408 37.5 Die Storyline – eine Geschichte entsteht.............................. 409 37.6 Festlegen des Designs mit Designstudien ............................ 410 37.7 Das Konzept des Spiels ........................................................ 411

38

Das Projekt startet ........................................................................ 413 38.1 Erstellen der ersten Objekte ................................................. 413 38.2 Erstellen des Basis-Devices für das Projekt ......................... 415

39

Eine Welt erschaffen..................................................................... 419 39.1 Die Theorie des Spielfeldes.................................................. 419 39.2 Das Spielfeld in der Praxis ................................................... 420 39.2.1 Spielfelddaten auslesen .......................................... 421 39.2.2 Performance-Steigerung im Spielfeld .................... 424 39.2.3 Das Spielfeld erstellen............................................ 426 39.2.4 Die Bitmaske .......................................................... 427 39.2.5 Das Spielfeld rendern ............................................. 428 39.3 Skydome: Die Begrenzung der Spielwelt ............................ 432

40

Die Spielfigur ................................................................................. 435 40.1 Die Techniken der Spielfigur ............................................... 436 40.1.1 Bewegungsablauf – Animation der Spielfigur ....... 436 40.1.2 Bewegung der Spielfigur........................................ 440 40.1.3 Relative Bewegungen im Spiel .............................. 441 40.1.4 Logik der Bewegung .............................................. 443

XVIII

Inhaltsverzeichnis

40.1.5 Drehung der Spielfigur........................................... 446 40.1.6 Laufen der Spielfigur.............................................. 448 40.2 Einfügen der Tastaturabfrage ............................................... 451 40.3 Einfügen des Kameramoduls ............................................... 457 41

Gegner: Computergesteuerte Elemente...................................... 461 41.1 Arten von Gegnern ............................................................... 461 41.1.1 Festgelegte Bewegungen und Aktionen ................. 461 41.1.2 Intelligente Bewegungen und Aktionen ................. 462 41.1.3 Intelligente Bewegungen, Aktionen und Kommunikation...................................................... 463 41.2 Einfügen der Gegner in „Return From Orion“..................... 464

42

Künstliche Intelligenz ................................................................... 471 42.1 Was ist künstliche Intelligenz?............................................. 471 42.1.1 Menschlich handeln................................................ 472 42.1.2 Menschlich denken................................................. 472 42.1.3 Rational denken...................................................... 473 42.1.4 Rational handeln..................................................... 473 42.2 KI in Computerspielen ......................................................... 473 42.3 KI in „Return From Orion“ .................................................. 474 42.3.1 Random-Strategie................................................... 476 42.3.2 Vertikale Strategie.................................................. 478 42.3.3 Horizontale Strategie.............................................. 482 42.3.4 Änderung der KI-Strategie ..................................... 485

43

Kollision ......................................................................................... 487 43.1 Kollision in DirectX ............................................................. 487 43.1.1 BoundingBox ......................................................... 487 43.1.2 BoundingSphere ..................................................... 488 43.1.3 Feintuning............................................................... 489 43.2 Kollision im Spiel ................................................................ 490

44

Soundeffekte .................................................................................. 493

45

Abschließende Funktionen ........................................................... 497 45.1 Statusanzeigen erstellen und integrieren .............................. 497 45.2 Splash-Screens ..................................................................... 502 45.3 Kamerafahrt am Anfang jedes Levels .................................. 504 45.4 Framerate begrenzen ............................................................ 506

46

Leveleditor ..................................................................................... 509 46.1 Zeichnen des Spielfeldes...................................................... 510

Inhaltsverzeichnis

XIX

46.2 Editieren der Spielfelddaten ................................................. 513 46.3 Steuerelemente des Leveleditors .......................................... 518 46.4 Das Programm-Menü ........................................................... 524 46.4.1 Level neu erstellen.................................................. 524 46.4.2 Level laden ............................................................. 526 46.4.3 Level speichern....................................................... 527 46.4.4 Direkt Zugriff auf ein Level ................................... 527 46.4.5 Spielfeld umranden................................................. 529 46.4.6 Dynamische Objekte einfügen: Random................ 530 46.5 Hilfsfunktionen..................................................................... 531 47

Fragen und Antworten zu VB.NET............................................. 535

48

Fragen und Antworten zu DirectX.............................................. 541 48.1 Fragen und Antworten zu Texturen...................................... 542

Glossar .................................................................................................... 545 Anhang.................................................................................................... 549 Datentypen...................................................................................... 549 Index........................................................................................................ 551

1 Die Buchstruktur

Wir haben ein praxisorientiertes Buch erstellt. Hierbei bieten wir allen Programmiereinsteigern sowie allen Visual Basic 6-Umsteigen eine fundierte Einführung in VB.NET. Mit Hilfe von DirectX entwickeln wir ein komplettes Spiel. Bevor wir uns der Spielprogrammierung widmen können, müssen Sie DirectX kennen lernen. Aus dieser Aufgabenteilung haben wir das Buch dreigeteilt aufgebaut. • • •

Teil 1: VB.Net Teil 2: Managed DirectX Teil 3: Spieleprogrammierung: Return From Orion

Diese Aufteilung bietet einen fachlich sortierten Kontext und erleichtert das Nachschlagen von spezifischen Themen. Obwohl die Teile eindeutig voneinander getrennt sind, sind sie nicht zusammenhanglos. Sie sollten mit Teil 1 beginnen und mit Hilfe des zweiten Teils das notwendigen Wissen über DirectX erlangen. Dieses Wissen benötigen Sie im dritten Abschnitt und fruchtet in der Realisierung des Spiels „Return from Orion“. Natürlich empfehlen wir, die einzelnen Teile der Reihe nach zu lesen, sollten Sie aber über genügend Programmierpraxis verfügen, dann können Sie auch direkt in Teil 2 oder 3 einsteigen. Dies ist ein Vorteil dieser Buchstruktur. Kompatibilität Hier müssen wir ein ernstes Thema ansprechen. VB.NET und das Microsoft Framework sind recht junge Techniken und unterliegen genauso wie DirectX einer kontinuierlichen Weiterentwicklung. Natürlich werden hierdurch mehr Probleme gelöst, als das neue entstehen. Dennoch ist eine Veränderung einer dieser Komponenten nicht problemlos. Diese Probleme beziehen sich weniger auf bereits erstellte Programme, sondern vielmehr auf deren Sourcecode. So halten wir es für recht wahrscheinlich, dass im Laufe der Zeit der Sorucecode der Beispielprogramme nicht problemlos kompiliert werden kann. An dieser Stelle können wir Ihnen keine Universallösung präsentieren, vielmehr möchten wir auf unsere Internetseite

2

Die Buchstrukture

(www.directxATvb.de) hinweisen. Hier finden Sie Aktualisierungen und Foren, welche sich mit den Themen des Buches beschäftigen. Als wir den Sourcecode für das Buch erstellt haben, haben wir folgende Versionen verwendet: • • •

®

®

Microsoft DirectX 9.0b SDK Update (Summer 2003) ® ® Microsoft Framework 1.1 (Version 1.1.4322) ® ® Microsoft Visual Studio.NET 2003 (Version 7.1.3088)

Wichtiger Hinweis Die in diesem Buch wiedergegebenen Verfahren und Programme werden ohne Rücksicht auf die Patentlage mitgeteilt. Sie sind für Amateur- und Lehrzwecke bestimmt. Alle technischen Angaben und Programme in diesem Buch wurden von den Autoren mit größter Sorgfalt erarbeitet bzw. zusammengestellt und unter Einschaltung wirksamer Kontrollmaßnahmen reproduziert. Trotzdem sind Fehler nicht ganz auszuschließen. Deshalb sind wir gezwungen, darauf hinzuweisen, dass weder eine Garantie noch die juristische Verantwortung oder irgendeine Haftung für Folgen, die auf fehlerhafte Angaben zurückgehen, übernommen werden kann. Für die Mitteilung eventueller Fehler sind die Autoren jederzeit dankbar. Eingetragene Warenzeichen – Registered trademark of – ®

®

®

®

®

Microsoft , Windows , DirectX , Visual Studio , Visual Studio.NET , ®, ® VB.NET Visual Basic The Microsoft Network und andere Namen von MSP- und/oder Microsoft-Produkten sind eingetragene Warenzeichen von MSP und/oder Microsoft Corporation in USA u.a. Staaten. Microsoft, Windows, Windows logo sind eingetragene Warenzeichen von Microsoft Corporation. ®

SharpDevelop ist eingetragene Marke oder Warenzeichen ihrer Eigentümer und/oder ihrer Hersteller.

2

Was ist VB.NET?

VB.NET ist eine Programmiersprache basierend auf dem Microsoft .NETFramework. Das Framework verbindet verschiedene Programmiersprachen. Programme werden zwar in den jeweiligen Programmierspachen geschrieben, diese werden aber in ein und dieselbe Common Language Runtime kompiliert. Dies ist geradezu ein revolutionäres Konzept, denn bis dato waren wir (die Progrmmierer) unterschiedliche Kompiler mit unterschiedlichen Ergebnissen gewohnt. So konstantierten sich Stärken und Schwächen der einzelnen Programmiersprachen und daraus resultierent schrieb man einer Programmiersprache einem bestimmten Aufgabenbereich zu. Der Aufgabenbereich von Viausl Basic (der Vorgängerversion von VB.NET) war die Datenbankprogrammierung im Officeumfeld. Hier lagen die Stärken dieser Programmierspachen. Mit den neuen Spachen von .NET sind die Grenzen gefallen. Ein Kompiler für alle Sprachen offenbart die Leistungsfähigkeit aller angeschlossenen Programmierspachen. Nun ist es egal ob der Sourccode in C# oder VB.NET erstellt wird. Das Ergebnis ist ein zum Framework kompatibeles Programm mit identischen Leistungsmerkmalen. Für uns bedeutet dies: wir können mit einer relativ leicht verständlichen Syntax sowie einer übersichtlichen Programmierumgebung arbeiten und leistungsstarke Programme erstellen, welche einem Vergleich zu C# nicht scheuen müssen.

2.1 Unterschiede zu Visual Basic 6 Diese Erläuterungen werden nur für Leser mit VisualBasic6-Erfahrung von Interesse sein. Für Einsteiger werden die aufgelisteten Neuerungen noch keine Aussagekraft haben. Natürlich wird sich das mit wachsender Erfahrung ändern und dann werden Sie sicherlich einige der Neuerungen von VB.NET als selbstverständlich ansehen. VB.NET ist der Nachfolger von Visual Basic 6. VB.NET ist aber auch Bestandteil von Visual Studio.NET. Hier haben wir bereits einen Unterschied zu VB 6: Visual Basic 6 war nicht in das Visual Studio-Paket integriert.

4

Was ist VB.NET?

Zwar wurde VB gemeinsam mit dem Visual Studio-Paket ausgeliefert, aber sie verwendeten unterschiedliche IDEs. Integrated Development Environment (IDE) beschreibt die integrierte Entwicklungsumgebung von Visual Studio.NET. Mit Visual Studio.NET wird ein C++-, C#- oder VB.NET- Programmierer mit der gleichen Entwicklungsumgebung arbeiten. Dies ist ein bedeutender Vorteil. So rücken Programmierer der unterschiedlichen Programmiersprachen enger zusammen und die Wahl, in welcher Programmiersprache das nächste Projekt verwirklicht wird, ist leichter zu treffen. 2.1.1 Rapid Application Development VB.NET unterstützt die schnelle Anwendungsentwicklung (RAD, Rapid Application Development) mit Projektvorlagen, Designern und anderen Features in der Visual Studio.NET-Entwicklungsumgebung. 2.1.2 Vererbung Ein weiterer Fortschritt ist die Vererbung. Vererbung ist das Ableiten einer Klasse von einer anderen. Abgeleitete Klassen erben die Eigenschaften, Methoden und Ereignisse der Basisklasse und können diese erweitern. Abgeleitete Klassen können auch vererbte Methoden mit neuen Implementierungen überschreiben. 2.1.3 Ausnahmebehandlung Außerdem wurde eine verbesserte Fehlerhandhabung (Ausnahmebehandlung) implementiert. Visual Basic verwendet eine erweiterte Version der Try-Catch-Finally-Syntax, die bereits von anderen Sprachen (z.B. von C++) unterstützt wurde. Die strukturierte Ausnahmebehandlung kombiniert eine moderne Kontrollstruktur (vergleichbar mit Select…Case oder While) mit Ausnahmen, geschützten Codeblöcken und Filtern. 2.1.4 Überladung Überladung ist das Erstellen von mehreren Prozeduren, Eigenschaften oder Instanzkonstruktoren in einer Klasse, die zwar denselben Namen verwenden, aber über andere Argumenttypen verfügen. Overloads sind am besten an einem einfachen Beispiel zu erklären. Nehmen wir an, dass Sie eine Klasse nutzen, welche einmal einen String und einmal eine Zahl ausgeben

Unterschiede zu Visual Basic 6

5

soll. Ohne Overload würden Sie zwei Prozeduren mit zwei unterschiedlichen Namen verwenden (DisplayChar und DisplayInt). Ohne Overload 1 2 3

4 5 6

Sub DisplayChar(ByVal theChar As Char) ' Add code that displays Char data. End Sub Sub DisplayInt(ByVal theInteger As Integer) ' Add code that displays Integer data. End Sub

Mit Overload benötigen wir ebenfalls zwei Prozeduren, jedoch teilen sich beide denselben Namen Display. Dies ist eine wesentliche Erleichterung. Schließlich wollen wir mit dem Aufruf der Prozedur das gleiche Ziel erreichen. Ob dieses Ziel mit DisplayChar, DisplayInt oder einfach von Display erreicht wird, ist dabei nebensächlich. Mit Overload 1 2 3

4 5 6

Overloads Sub Display(ByVal theChar As Char) ' Add code that displays Char data. End Sub Overloads Sub Display(ByVal theInteger As Integer) ' Add code that displays Integer data. End Sub

Jenach dem, welches Argument übergeben wird, wird die entsprechende Prozedur aufgerufen. Hierbei ist es nicht mehr von Bedeutung, ob das Argument einen Integer-Wert oder einen Char-Wert beinhaltet. Diese Entscheidung wird im Hintergrund für den Anwender unsichtbar getroffen. 2.1.5 Overrides: Überschreiben von Methoden und Eigenschaften Abgeleitete Klassen erben Eigenschaften und Methoden, die in ihrer Basisklasse definiert sind. Dies ist praktisch, da Sie diese Elemente wiederverwenden können, sobald sie für die von Ihnen verwendete Klasse erforderlich sind. Wenn der vererbte Member nicht in seiner ursprünglichen Form verwendet werden kann, können Sie mit dem Overrides-

6

Was ist VB.NET?

Schlüsselwort eine neue Implementierung definieren, vorausgesetzt, dass die Eigenschaft oder Methode in der Basisklasse durch das OverridableSchlüsselwort gekennzeichnet ist. 2.1.6 Konstruktoren und Destruktoren Mit Konstruktoren und Destruktoren wird das Erstellen oder Zerstören von Klassen gesteuert. Hierzu werden Prozeduren Sub New und Sub Finalize verwendet. Insbesondere mit Blick auf die Systemressourcen sollten nicht mehr verwendete Klassen freigegeben werden. Freie Objekte werden von VB.NET mit Nothing bezeichnet. 2.1.7 Datentypen In VB.NET werden drei neue Datentypen eingeführt. Der Char-Datentyp ist eine vorzeichenlose 16-Bit-Größe, mit der Unicode-Zeichen gespeichert werden. Er entspricht dem System.Char-Datentyp von .NET-Framework. Der Short-Datentyp, eine 16-Bit-Ganzzahl mit Vorzeichen, wurde in früheren Versionen von Visual Basic als Integer bezeichnet. Der DecimalDatentyp ist eine 96-Bit-Ganzzahl mit Vorzeichen, die mit einer variablen Potenz zur Basiszahl 10 skaliert wird. In früheren Versionen von Visual Basic war dieser Typ nur in einer Variante verfügbar. Für alle Visual Basic 6-Umsteiger haben wir eine tabellarische Gegenüberstellung der Datentypen erstellt. Tabelle 1. Datentypen Visual Basic 6

VB.NET

Boolean

Boolean

Byte

Byte

Date

Date

Single

Single

Integer (2 Byte)

Short (2 Byte)

Long (4 Byte)

Integer (4 Byte) Long (8 Byte)

Currency (8 Byte)

Decimal (12 Byte)

Unterschiede zu Visual Basic 6 Object

Object

Variant

Object

String

String

7

Char (Unicode Character)

2.1.8 Verweise Mit Hilfe von Verweisen können Sie in anderen Assemblies definierte Objekte verwenden. In VB.NET zeigen Verweise auf Assemblies statt auf Typbibliotheken. 2.1.9

Namespaces

Namespaces verhindern Namenskonflikte, indem Klassen, Schnittstellen und Methoden in Hierarchien organisiert werden. 2.1.10 Assemblies Assemblies ersetzen die Typbibliotheken und erweitern ihre Funktionalität, da alle erforderlichen Dateien für eine bestimmte Komponente oder Anwendung beschrieben werden. Eine Assembly kann einen oder mehrere Namespaces enthalten. 2.1.11 Multithreading In VB.NET können Anwendungen programmiert werden, die mehrere Aufgaben unabhängig voneinander ausführen. Eine Aufgabe, durch die andere Aufgaben möglicherweise verzögert werden, kann in einem separaten Thread ausgeführt werden. Dieser Vorgang wird als Multithreading bezeichnet. Multithreading ermöglicht eine schnelle Reaktion von Anwendungen auf Benutzereingaben, da komplexe Aufgaben in von der Benutzeroberfläche getrennten Threads ausgeführt werden. 2.1.12 Common Language Runtime (CLR) Die Laufzeitumgebung des .NET-Frameworks heißt Common Language Runtime oder kurz CLR. Sie ist auf den Betriebssystemdiensten aufgebaut und legt fest, wie .NET-Programme ausgeführt und unterstützt werden.

8

Was ist VB.NET?

Zur Unterstützung gehören u.a. die Garbage Collection, Sicherheit und JIT-Compilation. Die CLR basiert auf einem eigenen Befehlssatz der CIL – Common Intermediate Language. Der Sorcecode einer .NETProgrammiersprache wird in die CIL übersetzt. Diese Übersetzung ist aber nicht lauffähig. Hierzu bedarf es einer weiteren Übersetzung (just-in-time) des Frameworks. Das Framework ist auf die jeweilige Plattform (System) angepasst. Hierdurch ist es möglich, dass ein und derselbe Sourcecode auf unterschiedlichen Systemen funktioniert. Diese Technik ist bereits aus anderen Programmiersprachen wie Java bekannt. Sie ermöglicht die Implementierung von Sourcecodes einer anderen .NET-Programmiersprache. Ein weiteres Merkmal der CLR sind Sicherheitsmerkmale, wie der Garbage Collector. Er ist für die Speicherverwaltung eines Programms zuständig. Hierdurch sollen .NET-Programmiersprachen sicherer und robuster werden. Eine manuelle Speicherverwaltung wie bei C++ oder C entfällt weitgehend. So wird z. B. der Speicher für ungebundene Objekte autonom freigegeben. Zusammenfassend können wir sagen, dass die CLR eine gemeinsame Plattform für alle .NET-Programme darstellt. Hierbei ist es nebensächlich, auf welcher Zielmaschine das Programm ausgeführt werden soll. 2.1.13 Garbage Collection Der Garbage Collector (GC) ist für die Speicherverwaltung der Programme verantwortlich. Sie als Programmierer müssen sich nicht mehr um die Speicherbereinigung kümmern, sondern überlassen dies dem GC. Dynamisch erzeugte Objekte können in Lebenszyklen mit dem folgendem Ablauf eingeteilt werden: 1. Speicher reservieren (Allokation) 2. Initialisierung 3. Nutzungsdauer (mindestens eine Referenz existiert) 4. Ressource freigeben 5. Speicherplatz des Objektes kann neu belegt werden. Wenn der Programmierer für das Speichermanagement die Verantwortung trägt, kann es vorkommen, dass reservierter Speicher nicht mehr freigegeben wird. Es entsteht ein Speicherloch. Das kommt häufiger vor, als man glaubt. Außerdem könnte der Programmierer ein Objekt löschen, obwohl es noch gebunden ist, d.h., es besteht noch eine Referenz. Unter .NET darf nur der GC den Speicher freigeben.

Unterschiede zu Visual Basic 6

9

Speicher für Objekte von Klassen und Arrays werden auf dem Heap (managed heap) erzeugt. Der Heap ist ein zusammenhängender Speicherbereich. Er besitzt einen Zeiger, welcher auf die Stelle zeigt, an der ein neues Objekt angelegt werden kann. Wenn der Speicherbereich einmal nicht ausreicht, wird es schwierig. In diesem Fall müssen zuerst alle Threads gestoppt werden. Anschließend beginnt der GC mit der Arbeit. Er versucht, Speicherbereiche zu verschieben, zu löschen und zu optimieren, bis ausreichend Platz geschaffen wurde. Hierbei kann es zu längeren Bearbeitungszeiten kommen, welche besonders bei Echtzeitanwendungen zu spürbaren Unterbrechungen führen können.

3 Die Entwicklungsumgebungen von VB.NET

Was ist zum Erstellen eines VB.NET-Programms erforderlich? Zur Erstellung eines VB.NET-Programms benötigen wir ausschließlich das Microsoft .NET-Framework und einen Editor zum Schreiben des Quellcodes. Hier wird ein elementarer Unterschied zu früheren Visual Basic-Versionen deutlich. Bis zur Version 6 musste die IDE (Integrated Development Environment) von Microsoft gekauft werden. Diese gibt es bekanntlich in verschiedenen Versionen und zu unterschiedlichen Preisen (z.B. Standard, Professionell und Enterprise).

Abb. 1. Entwicklungsumgebung von Visual Basic 6

Mit VB.NET ist es möglich, Programme mit einfachen Editoren wie Wordpad oder Edit zu erstellen. Das notwendige .NET-Framework gibt es als kostenlosen Download direkt bei Microsoft. Das kostenlose SDK (Software Development Kit) beinhaltet alles, was man zum Programmieren braucht. Etwas später werden wir Ihnen zeigen, wie Sie ein VB.NETProgramm mit Wordpad erstellen und mit dem .NET-Framework kompilieren können. Allerdings stößt man auch schnell an Grenzen. Komplexere Programme sind so nicht zu erzeugen.

12

Die Entwicklungsumgebungen von VB.NET

Abb. 2. Entwicklungsumgebung von VB.NET

Natürlich bietet Microsoft auch eine spezielle IDE. Diese hat alles, was wir zum Erstellen komplexer Programme benötigen. Die IDE ist eingebettet im dem Microsoft Visual Studio.NET-Paket. Dieses Paket ist nicht kostenlos und es ist wie gewohnt in verschiedenen Ausführungen erhältlich. Neben der kostenpflichtigen Lösung von Microsoft gibt es auch eine kostenlose Alternative. Auf der Internetseite des Entwicklers C# Code1 erhalten Sie SharpDevelop. SharpDevelop ist eine unglaublich leistungsstarke IDE. Für SharpDevelop sprechen einige Vorteile: • Es ist kostenlos verfügbar • SharpDevelop besitzt einen leistungsstarken Editor mit Syntaxhervorhebung und Autovervollständigung. • Es verfügt über eine integrierte Projektverwaltung. • Es ist multilingual. • Und es hat einen geringen Speicherverbrauch auf dem System. Leider gibt es noch den Nachteil, dass für VB.NET-Projekte noch kein Formeditor implementiert ist. Wir werden Ihnen beide IDEs vorstellen und überlassen Ihnen die Entscheidung, mit welcher IDE Sie arbeiten möchten oder können.

1

http://www.icsharpcode.NET/OpenSource/SD/Download/default.asp

Das Visual Studio .NET

13

3.1 Das Visual Studio .NET Im Folgenden, stellen wir Ihnen die Microsoft VB.NET IDE vor. Eigentlich dürfen wir nicht von einer VB.NET IDE sprechen, sondern von einer Microsoft Visual Studio.NET IDE. Die volle Integration von VB.NET in Studio.NET ist eine der hilfreichen Neuerungen von Visual Studio.NET. Alle Programmiersprachen von Visual Studio.NET (C++, C#, VB. NET, …) benutzen die gleiche IDE. Nach der korrekten Installation von VS.NET haben Sie die Möglichkeit, ein eigenes Benutzerprofil zu definieren. Dieses bezieht sich auf Tastaturlayout, Fensterlayout und Hilfefilter. Für Umsteiger von Visual Basic 6 auf VB.NET empfehlen wir, die Einstellungen des Visual Basic-Entwicklers. Hiermit fällt der Umstieg nicht mehr ganz so schwer.

Abb. 3. Benutzerprofil einstellen in Visual Studio .NET

Unter dem Menüpunkt „Erste Schritte“ können wir ein neues Projekt starten. Visual Studio.NET bietet uns eine Auswahl von verschiedenen Grundgerüsten an.

14


Abb. 4. Projektauswahl in Visual Studio.NET

Hier entscheiden wir uns im Regelfall für eine Windows-Anwendung. Bevor der Assistent das entsprechende Basisgerüst erstellen kann, müssen wir einen Projektnamen angeben. Das Projekt wird in einem eigenen Ordner im Arbeitsverzeichnis von VB.NET erzeugt. In diesem Projektordner werden alle kontextbezogenen Dateien gespeichert. Dies ist wichtig, damit es zu keinen Überschneidungen mit anderen Projekten kommt. Es führt zu irreparablen Schäden, wenn ein neues Projekt die Dateien eines alten überschreibt. Nachdem das Projekt erstellt wurde, gelangen wir auf die Entwicklungsoberfläche der Microsoft IDE.

Abb. 5. Hauptoberfläche von Microsoft VB.NET


15

Normalerweise beginnt ein Projekt mit einem leeren Formular. Dies ist wirklich nicht zwingend erforderlich. Einige Programme benötigen kein Formular und arbeiten somit vom Anwender unbemerkt im Hintergrund. 3.1.1 Formdesigner

Abb. 6. Formdesigner von VB.NET

Im Formdesigner werden die Programmfenster (Visual Basic = Forms) dargestellt. Mit Hilfe der VB.NET IDE können die Forms gestaltet werden. Das bedeutet, dass Steuerelemente wie Buttons, Textfelder, Listfelder, Checkboxen usw. platziert werden. Dies geschieht nach einem Baukastenprinzip. Steuerelemente werden im Werkzeugfenster selektiert und anschließend auf der Form angeordnet. Hierzu muss kein Sourcecode erstellt werden. Der zugehörige Sourcecode wird von der IDE automatisch generiert.

16


3.1.2 Werkzeugfenster

Abb. 7. Werkzeugfenster von VB.NET

Am linken Rand finden Sie das Werkzeugfenster (Toolbox). Die Toolbox beherbergt alle Steuerelemente, die auf einer Form platziert werden dürfen. Ebenfalls findet wir unsichtbare Steuerelemente, die jedoch einen logischen Bezug zum Form-Objekt besitzen. 3.1.3

Eigenschaftenfenster

Abb. 8. Eigenschaftenfenster von VB.NET


17

Im Eigenschaftenfenster werden die Eigenschaften von den jeweils selektierten Steuerelementen im Formdesigner aufgeführt. Mit seiner Hilfe können die Eigenschaften angezeigt und bei Bedarf verändert werden. 3.1.4

Projektexplorer

Abb. 9. Projektexplorer von VB.NET

Der Projektexplorer ist eine Auflistung aller im Projekt verwendeten Dateien. Hier finden wir alle Forms, ebenso wie alle Klassen oder Module. Hinter dem Eintrag Projektmappe (ganz oben im Projektexplorer) steht der Projektname. Dort kann dieser auch verändert werden. 3.1.5

Pin-Nadel-Symbol

Abb. 10. Pin-Nadel-Symbol

Wer mit der VB.NET IDE bereits gearbeitet hat und lediglich über einen Monitor verfügt, wird das Pin-Nadel-Symbol zu schätzen wissen. Hiermit können Fenster automatisch ausgeblendet werden. Sie werden, sobald die Maus in den Fensterrandbereich fährt, wieder eingeblendet. Diese Interaktion ist eine große Hilfe. Ohne diese Möglichkeit würde man vom Sourcecode lediglich einen unzureichend kleinen Ausschnitt erhalten.

18


3.2 SharpDevelop SharpDevelop ist eine kostenlose IDE für VB.NET, die Ihnen uner der GNU-Lizenze zur Verfügung steht. Auf einige Highlights haben wir bereits zu Beginn des Kapitels hingewiesen. In diesem Abschnitt des Buches wollen wir uns mit der Bedienoberfläche beschäftigen und prüfen, ob es sich wirklich um einen ernsthaften Konkurrenten zu der Microsoft VB.NET IDE handelt.

Abb. 11. GNU General Public License von SharpDevelop

3.2.1 Code-Competion-Datenbank Bevor das Programm zum ersten Mal gestartet wird, sollte eine CodeCompetion-Datenbank angelegt werden. Hierbei handelt es sich um eine Datenbank zur Verwaltung der .NET-Framework-Klassen. Das Anlegen der Datenbank besteht aus drei Schritten: Schritt 1. Sie müssen lediglich das Anlegen der Datenbank in Auftrag geben. Dies sollten sie erledigen, bevor SharpDevelop gestartet wird, es geht aber auch später. Das Anlegen der Datenbank dauert nur kurze Zeit.

SharpDevelop

19

Abb. 12. Code Completion Setup

Schritt 2. Bitte nutzen Sie die Defaulteinstellungen. Die Datenbank wird im aktuellen Userverzeichnis angelegt. Hierdurch vermeiden Sie auf einem Multiusersystem unnötige Konflikte.

Abb. 13. Pfad für die Code-Completion-Datenbank wählen

20


Schritt 3. Je nach Systemausstattung sollten Sie schnelles oder langsames Erstellen der Datenbank wählen. Wir haben uns für das langsame Generieren entschieden. Mit einem Klick auf die Schaltfläche „Datenbank anlegen“ wird der Installationsprozess abgeschlossen. Anschließend erhalten Sie den Hinweis, die Datenbank sei erstellt. Diesen müssen Sie lediglich bestätigen.

Abb. 14. Code-Completion-Datenbank anlegen

3.2.2

Der erste Start

Beim Starten von SharpDevelop können Sie ein vorhandenes Combine öffnen oder ein neues erstellen. Ein Combine ist vergleichbar mit einem Projekt unter VB.NET. Sollten Sie ein neues Combine erstellen, erhalten Sie die Auswahl mehrerer Grundgerüste. Dies unterscheidet sich nur unwesentlich von den Möglichkeiten, die uns die Microsoft IDE bietet.

SharpDevelop

21

Abb. 15. Combine (Projekt) – Auswahl von SharpDevelop

Nachdem das neue Combine erstellt wurde, gelangen wir auf die Hauptansicht von SharpDevelop.

Abb. 16. Hauptansicht von SharpDevelop

22


Wie Sie erkennen, besitzt die SharpDevelop IDE eine ähnliche Funktionalität wie die Microsoft Visual Studio.NET IDE. In der uns vorliegenden Version fehlt jedoch ein Formeditor. Forms müssen per Sourcecode erstellt werden und entsprechend müssen auch die Steuerelemente per Sourcecode platziert werden. Das fehlende Drag and Drop vermisst man sehr. Dennoch halten wir den Editor für eine gelungene Umsetzung und eine echte Alternative zur Microsoft IDE.

4 „Hello World“ das erste .NET-Programm

Wenn man sich mit der Einführung in eine Programmiersprache beschäftigt, darf ein Programm nicht fehlen: HELLO WORLD. Es ist einfach strukturiert und wird immer wieder als Lernprogramm verwendet.Auch wir werden es Ihen hier vorstellen.

4.1 Ein einfaches Programm mit einem einfachen Editor Auf den vorhergehenden Seiten haben wir behauptet, dass wir zum Programmieren von VB.NET lediglich einen einfachen Texteditor und das .NET-Framework benötigen. Wir werden Ihnen dies im Folgenden erklären. 4.1.1

Der Sourcecode

Öffnen Sie ein MS-DOS-Fenster und erstellen Sie ein Verzeichnis C:\HelloWorld. Anschließend starten Sie den Editor. • Mit dem Befehl cd.. wechseln Sie die Verzeichnisebene. Wiederholen Sie solange den Befehl cd.., bis Sie sich im Rootverzeichnis des Laufwerks C: befinden. • Mit dem Befehl md (make Directory) erstellen Sie ein neues Verzeichnis. • Mit dem Befehl edit rufen Sie den Standardeditor auf.

Abb. 17. MS-DOS-Fenster unter Windows XP

24

„Hello World“ das erste .NET-Programm

Nachdem der Editor gestartet wurde, können Sie folgenden Code eingeben. 1 2 3 4 5

Module HelloWorld Sub Main Console.WriteLine(“Hello World”) End Sub End Module

Abb. 18. Einfacher Texteditor mit dem Sorcecode für Hello World

Speichern Sie das Programm unter: C:\HelloWorld\HelloWorld.vb

4.1.2

Der Compiler

Nachdem das Programm fertig ist, muss es kompiliert werden. Der VB.NET-Compiler liegt in der Datei vbc.exe. Diese Datei finden Sie unter: C:\windows\Microsoft.NET\Framework\Vx.x.xxxx. Bei Vx.x.xxxx handelt es sich um die Version des eingesetzten Frameworks. Da sich diese im Laufe der Zeit ändern wird, müssen die Pfadangaben angepasst werden. Um das Programm zu kompilieren, verwenden wir folgenden Aufruf: c:\windows\Microsoft.NET\Framework\V1.0.3705\ vbc.exe c:\helloworld\helloworld.vb /nologo /imports:system

Ein Projekt im Visual Studio.NET

25

Achtung! Bei den beiden oberen Zeilen handelt es sich um eine zusammenhängende Zeile. Diese wird lediglich durch den Zeilenumbruch im Buch mehrzeilig dargestellt.

Abb. 19. HelloWorld.vb kompilieren

Nachdem das Programm kompiliert wurde, finden wir eine HelloWorld.exe im Projektordner. Wenn wir diese ausführen, wird Hello World auf dem Bildschirm ausgegeben.

4.2 Ein Projekt im Visual Studio.NET Wenn wir ein Programm mit einfachsten Mitteln erstellen, stoßen wir schnell an die Grenzen dieser Technik. Außerdem ist die Verwendung eines einfachen Texteditors nicht besonders komfortabel. Als Visual BasicProgrammierer bzw. angehender VB.NET-Programmierer erwarten wir etwas mehr Luxus. Dieser wird uns von der Visual Studio.NET IDE geboten. Betrachten wir nun, was zu tun ist, um das gleiche Ergebnis mit der Visual Studio.NET IDE zu erreichen. Zuerst erstellen wir ein neues Projekt. Hier wählen wir die Konsolenanwendung.

26

„Hello World“ das erste .NET-Programm

Abb. 20. Neues Projekt in der VS.NET IDE

Nachdem der Visual Studio-Assistent das Grundgerüst erstellt hat, gelangen wir in folgende Ansicht.

Abb. 21. Sourcecode von Module1 des HelloWorld-Projektes

Dies wird Ihnen vertraut vorkommen. Um das HelloWorld-Projekt zu vervollständigen, müssen wir den Sourcecode wie folgt ergänzen. 1 2 3

Sub Main() Console.WriteLine(„Hello World!”) End Sub

Beim Vervollständigen des Sourcecodes haben Sie wahrscheinlich die Autovervollständigung bemerkt. Beim Programmieren mit einem Texteditor muss auf dieses Hilfsmittel verzichtet werden. Hierdurch entstehen we-

Ein Projekt im Visual Studio.NET

27

sentlich längere Entwicklungszeiten. Die Bedeutung einer ausgereiften IDE wird immer klarer, je größer die Projekte werden. Zurück zu unserem Programm. Wenn Sie es ausführen, wird ein Konsolenfenster geöffnet und „Hello World!“ geschrieben. Anschließend wird das Fenster direkt geschlossen. Von dem Ergebnis haben wir nicht viel gesehen. Um das Konsolenfenster in Ruhe betrachten zu können, ergänzen wir den Sourcecode: 1 2 3 4 5

Sub Main() Console.WriteLine("Hello World") Console.WriteLine("Bitte Enter drücken.") Console.Read() End Sub

Jetzt wird das Programm erst nach Drücken der Entertaste beendet.

5 Variablen

Variablen könnte man als das Gedächtnis eines Programms beschreiben. Mit Variablen speichern Sie Werte aus Ihrem Programm und können diese zu einem späteren Zeitpunkt verarbeiten. Dies ist z.B. der Fall, wenn Sie Adressdaten sowie Interessengebiete eines Users erfassen wollen. Die Daten werden über eine Bildschirmmaske eingegeben und in Variablen zwischengespeichert. Nachdem alle Daten vollständig sind und evtl. eine Gültigkeitsprüfung durchgeführt wurde, können sie abschließend verarbeitet (z.B. in einer Datenbank gespeichert) werden. Wenn Variablen angelegt werden, werden sie irgendwo im Arbeitsspeicher hinterlegt. Um mit der Variablen arbeiten zu können, würden Sie als Assembler-Programmierer die Adresse der Variablen auslesen. Als VB.NET Programmierer bleibt uns das erspart. Wir können die Variable über Ihren Namen ansprechen und erhalten so den gespeicherten Wert. Dass man Variablen über ihren Namen anspricht, erleichtert die Lesbarkeit des Sourcecodes. Schließlich ist es leicht, zu verstehen, was unter einer Variablen mit dem Namen Nettogehalt zu erwarten ist. Damit ein Programm mit Variablen arbeiten kann, müssen einige Regeln eingehalten werden. Um den Namen einer Variablen erkennbar zu machen, müssen folgende Punkte beachtet werden: • Er muss mit einem alphabetischen Zeichen oder einem Unterstrich (_) beginnen. • Er darf nur alphanumerische Zeichen und Unterstriche enthalten. • Er muss mindestens ein alphanumerisches Zeichen enthalten, wenn er mit einem Unterstrich beginnt. • Er darf nicht mehr als 16.383 Zeichen umfassen. • Schlüsselwörter dürfen nicht als Variablennamen verwendet werden. • Es wird nicht zwischen Groß- und Kleinschreibung unterschieden. VARIABLE1 = variable1

30

Variablen

5.1 Deklaration Wir wissen, was eine Variable ist, aber wie können wir sie erzeugen? Hierzu wird die DIM-Anweisung verwendet. Sie kann auf Modul-, Struktur-, Prozedur- oder Blockebene angewandt werden, um Variable zu deklarieren und Speicherplatz im Arbeitsspeicher zu reservieren. Das Erzeugen einer Variablen wird auch als Deklaration bezeichnet. Hier ein paar Beispiele: 1 2 3 4

Dim Dim Dim Dim

Zahl1 Zahl2, Zahl3 Automarke Das_ist_eine_lange_Variable

Die Deklaration einer Variablen kann man auch mit ihrer Initialisierung erledigen. In VB 6 waren hierzu noch zwei Codezeilen nötig. In VB.NET geht das in einem Rutsch. Hier ein Beispiel: 1 2 3

Dim Zahl1 = 12 Dim Zahl2 = 23.54 Dim Automarke = „MeinAuto“

Natürlich kann man auch den Wert eines Steuerelementes übergeben. Dies ist recht praktisch und aus VB 6 bereits bekannt. Hier ein Beispiel: Dim Automarke = txtAutomarke.Text

5.2 Datentypen und Konstanten Wenn Variablen deklariert werden, wird ein bestimmter Speicherplatz im Arbeitsspeicher reserviert. Wie viel Speicherplatz hängt von dem Datentyp ab. Deklarieren wir eine Variable, ohne ihr einen Datentyp zuzuweisen, erhält diese automatisch den Datentyp Object. Dieser Datentyp Object ist der Nachfolger des Variant aus Visual Basic 6. Eine Variable vom Typ Variant konnte die Daten von jedem anderen Datentyp speichern. In VB.NET gibt es ihn nicht mehr. Aus Variant wurde Object. Die gesamte Funktionalität von Variant wird von dem neuen Datentyp Object bereitgestellt.

Datentypen und Konstanten

31

Um einer Variablen einen bestimmten Datentyp zuzuweisen, müssen wir die Deklaration ein wenig modifizieren. Wenn wir bei der Deklaration einen Datentypen angeben, sollten wir uns auch an die Restriktionen halten. Wir können beispielsweise einer Integer-Variablen keine Zeichenkette übergeben. Hier ein Beispiel: 1 2 3

Dim Zahl1 as Integer Dim Automarke as String Dim Zahl2, Zahl3 as Long

Besonders die letzte Deklaration ist interessant. Die Variablen Zahl2, und Zahl3 erhalten den Datentyp Long. Dies ist neu in VB.NET. In Visual Basic 6 hätte die Variable Zahl2 den Datentyp Variant erhalten und die Variable Zahl3 den Datentyp Long. Natürlich kann man auch eine direkte Initialisierung vornehmen. Dies haben wir bereits kennen gelernt. Diesmal müssen wir jedoch auf Fehler achten. Hier ein paar Beispiele mit der richtigen Syntax: Dim Zahl1 As Integer = 12 Dim Automarke As String = “MeinAuto“

Eine falscher Syntax wäre: Dim Zahl1 As Integer = 12.234

Bei der letzten Deklaration würde VB.NET keinen Fehler generieren, aber die Variable Zahl1 würde auch nicht den Wert 12.234 enthalten. Da der Variablen der Datentyp Integer zugewiesen wurde, kann sie keine Gleitkommawerte aufnehmen. Der Wert von Zahl1 ist 12. Es stellt sich die Frage, warum Sie Variablen einen Datentyp zuweisen sollen. Schließlich gibt es doch den Datentyp Object. Dieser Datentyp kann alle anderen Datentypen in sich aufnehmen und sollte somit für jede Aufgabe geeignet sein. Die Antwort darauf lautet: Der Programmstil ist sauberer, wenn alle Variablen explizit deklariert werden. Außerdem ist der Datentyp Object recht langsam. Dies macht sich in zeitkritischen Aufgaben (DirectX- Programmierung) bemerkbar. Zusätzlich wird mit einem sauberen Variablenumgang die Lesbarkeit des Sourcecodes gesteigert und die Fehlersuche optimiert. Im Anhang des Buches haben wir eine Tabelle mit allen verfügbaren Datentypen angehängt.

32

Variablen

5.2.1 Der richtige Datentyp Bei der Wahl des richtigen Datentyps gibt es die Grundregel, niemals überdimensionale Datentypen zu wählen. Das bedeutet, dass wir den Datentyp Short benötigen, wenn wir eine Zahl im Wertebereich 1289 bis 25000 speichern müssen. Dieser besetzt lediglich 2 Byte Speicherplatz. Wenn wir z.B. den Datentyp Long wählten, würde das Programm immer noch lauffähig sein, wir würden jedoch 8 Byte Speicherplatz belegen. Das scheint zunächst unerheblich, betrachten wir jedoch die Gesamtheit des Programms, ist es ratsam, auf die Ressourcenverteilung zu achten und nicht verschwenderisch zu sein. Je schlanker ein Programm, desto agiler, schneller kann es arbeiten. Die folgenden Erläuterungen sollen Ihnen bei der Wahl des richtigen Datentyps helfen. String-Datentyp. Es gibt, von Object abgesehen, nur einen Datentyp, der Zeichenketten aufnehmen kann. Strings speichern 16-Bit-Zahlen (2 Byte). Jede Zahl nimmt ein Unicodezeichen auf. Abhängig von der Implementierungsplattform dürfen bis zu ca. 2 Mrd. Zeichen enthalten sein. Dim strVariable As String Dim strVariable$

Unicode. Unicodezeichen werden als 16-Bit-Zahlen gespeichert. Daraus ergibt sich ein Wertebereich von 0 bis 65535. Die ersten 128 Zeichen (0 bis 127) entsprechen den Buchstaben einer Standardtastatur. Die zweiten 128 Zeichen ( 128 bis 255) sind diverse Sonderzeichen. Object-Datentyp. Dieser Datentyp wird als 32-Bit-Adresse (4 Byte) gespeichert. Dies ist allerdings lediglich ein Zeiger auf den Anfang des Variablenwertes. Hinter diesem Datentyp kann sich jeder beliebige andere Datentyp verbergen. Dim objVariable Dim objVariable As Object

Boolean-Datentyp. Dieser Datentyp wird als 16-Bit-Zahl (2 Byte) gespeichert. Er kann die Werte TRUE oder FALSE annehmen. Hierbei entspricht 0 = FALSE und alle anderen Werte werden als TRUE interpretiert. False und True sind Schlüsselwörter von VB.NET und haben folgende numerische Werte. • False = 0 • True = -1


33

Dim bolVariable As Boolean

Byte-Datentyp. Der Byte-Datentyp ist ein Vertreter der rein numerischen Ecke. Er wird als 8-Bit-Zahl (1 Byte) gespeichert und hat einen Wertebereich von 0 bis 255. Da er der kleinste Vertreter der numerischen Liga ist, kann er problemlos in die Datentypen Short, Integer, Long, Single, Double oder Decimal konvertiert werden. Er wird häufig zur Speicherung binärer Daten verwendet. Dim bytVariable As Byte

Char-Datentyp. Dieser Datentyp wird als 16-Bit-Zahl (2 Byte) gespeichert. Der Wertebereich liegt zwischen 0 und 65535. Jede Zahl steht für ein einziges Unicodezeichen. Dim chaVariable As Char

Short-Datentyp. Auch dieser Datentyp ist ein numerischer Vertreter. Er wird als 16-Bit-Zahl (2 Byte) mit Vorzeichen gespeichert und hat einen Wertebereich zwischen –32.768 und 32.767. Er kann in die Datentypen Integer, Long, Single, Double und Decimal konvertiert werden. Dim shortVariable As Short

Integer-Datentyp. Dieser numerische Vertreter wird als 32-Bit-Zahl (4 Byte) mit Vorzeichen gespeichert. Sein Wertebereich liegt zwischen -2.147.483.648 und 2.147.483.647. Er kann in die Datentypen Long, Single, Double und Decimal konvertiert werden. Dieser Datentyp ist mit Sicherheit der beliebteste. Dies liegt zum einen an dem ausgewogenen Wertebereich und zum anderem an seiner 32-BitStruktur. Diese Struktur kann von einem 32-Bit-Prozessor besonders schnell verarbeitet werden. Dim intVariable As Integer Dim intVariable%

Long-Datentyp. Das ist der größte Vertreter der ganzzahligen Variablen. Er wird als 64-Bit-Zahl (8 Byte) mit Vorzeichen gespeichert und hat einen Wertebereich zwischen -9.223.372.036.854.775.808 und 9.223.372.036.854.775.807. Aufgrund seiner Größe sollte der Einsatz dieses Datentyps gut überlegt werden. Er kann in die Datentypen Single, Double und Decimal konvertiert werden.

34

Variablen Dim lngVariable As Long Dim lngVariable&

Single-Datentyp. Diese Variablen werden als 32-Bit-Gleitkommazahlen (4 Byte) mit doppelter Genauigkeit nach IEEE gespeichert. Die Werte reichen von –3,4028235E+38 bis –1,401298E–45 für negative und von 1,401298E–45 bis 3,4028235E+38 für positive Werte. Er kann in die Datentypen Double oder Decimal konvertiert werden. Dim sinVariable As Single Dim sinVariabel!

Double-Datentyp. Diese Variablen werden als 64-Bit-Gleitkommazahlen (8 Byte) mit doppelter Genauigkeit nach IEEE gespeichert. Die Werte reichen von –1,79769313486231570E+308 bis –4,94065645841246544E– 324 für negative Werte und von 4,94065645841246544E–324 bis 1,79769313486231570E+308 für positive Werte. Er kann in den Datentyp Decimal konvertiert werden. Dim dblVariable As Double Dim dblVariable#

Decimal-Datentyp. Dieser Typ ist gewaltig. Er wird als 128-Bit-Zahl gespeichert (16 Byte) mit Vorzeichen und einer variablen Potenz zur Basis 10. (Er beherrscht das Arbeiten mit Zahlen im Trilliardenbereich oder mit 28 Nachkommastellen.) Die Potenz gibt die Anzahl der Stellen rechts vom Dezimalzeichen an und liegt im Bereich von 0 bis 28. Bei einer Skalierung von 0 (keine Dezimalstellen) ist der größte mögliche Wert +/– 79.228.162.514.264.337.593.543.950.335. Bei 28 Dezimalstellen ist der größte Wert +/–7,9228162514264337593543950335. Der kleinste Wert ungleich 0 ist +/–0,0000000000000000000000000001 (+/–1E–28). Dim decVariable As Decimal Dim decVariable@

5.2.2

Konstanten

Konstanten müssen als fester Wert betrachtet werden. Wenn sie einmal deklariert und initialisiert wurden, können Sie nicht mehr verändert werden. Den Vorteil von Konstanten sehen wir uns anhand eines Beispiels an: In fast allen kaufmännischen Programmen benötigt man die Mehrwertsteuer (MwSt) als festen Rechenfaktor. Sie können natürlich in jeder Rechnung mit MwSt den aktuellen Steuersatz eintragen oder eine Kon-


35

stante, z.B. MwSt-Satz, verwenden. Der Sourcecode wird hierdurch wesentlich lesbarer. Auf den ersten Blick wird deutlich, dass es sich um eine Rechnung mit ausgewiesener Mehrwertsteuer handelt. Was passiert, wenn sich der aktuelle MwSt-Satz ändert? Haben Sie ohne Konstante gearbeitet, müssen Sie jede Rechnung in Ihrem Programm überarbeiten. Sollten Sie Konstanten eingesetzt haben, reicht es, die Konstante am Anfang des Programms zu aktualisieren und alle Rechnungen werden automatisch auf den neusten Stand gebracht. Deklaration und Initialisierung Um eine Konstante zu deklarieren, wird die Const-Anweisung verwendet. Hier ein Beispiel: Const Const Const Const

Fünf As Integer = 5 Vier% = 4 Automarke As String = „MeinAuto“ Straße$ = „Hauptstraße“

Es können auch mehrere Konstanten gleichzeitig deklariert und initialisiert werden, wie im folgenden Beispiel: Const Automarke As String = „MeinAuto“, _ Sechs As Integer = 6

Für Schreibfaule darf der Datentyp, wie im Folgenden beschrieben, fehlen. Const Automarke = „MeinAuto“ Const Straße = „Hauptstraße“, Sieben = 7

Eine Konstante muss direkt bei der Deklaration initialisiert werden. Ein Merkmal von Konstanten ist die Unveränderlichkeit. Ein Zugriff nach der Deklaration ist nicht erlaubt. Hier zeigen wir ein nicht erlaubtes Beispiel: Const Automarke As String Automarke = “MeinAuto”

Dieser Versuch wird augenblicklich mit einer Fehlermeldung quittiert. Enumerationen Hier machen wir einen kleinen Abstecher in den Fortgeschrittenenbereich. Enumerationen kann man als gruppierte Konstantenliste bezeichnen. Übli-

36

Variablen

cherweise werden Konstante aus einem spezifischen Kontext in Enumerationen zusammengefasst. Betrachten wir einmal die Deklaration: Enum Tage Montag 3 … 4 Sonntag 5 End Enum 1 2

Die Enumeration wird als Tage bezeichnet. Die einzelnen Mitglieder sind Konstanten und tragen die Wochentag. In diesem Beispiel wurden den einzelnen Mitgliedern keine expliziten Werte zugewiesen. Hierdurch erfolgt die Zuweisung der Werte automatisch. Die erste Konstante (Montag) der Enumeration erhält den Wert 0. Die folgenden Konstanten (Dienstag, Mittwoch,…) erhalten einen Initialisierungswert jeweils um 1 erhöht. 1 2 3 4 5 6

Enum Autoteile Motorhaube = 1 Radaufhängung = 1234 Ledersitz = 12 Scheinwerfer = 2 End Enum

In diesem Beispiel haben wir die Konstanten mit einem individuellen Wert initialisiert. Bitte beachten Sie, dass die zugewiesenen Werte nur vom Datentyp Integer sein dürfen. Wie kann ich auf die Mitglieder einer Enumeration zugreifen? Hierzu betrachten wir direkt ein Beispiel: 1 2 3 4 5 6 7 8 9 10 11 12 13

Module Module1 Enum Autoteile Motorhaube = 1 Radaufhängung = 1234 Ledersitz = 12 Scheinwerfer = 2 End Enum Sub Main() Console.WriteLine(Autoteile.Radaufhängung) Console.WriteLine("Bitte Enter drücken!") Console.Read() End Sub End Module


37

Die Sub-Anweisung kennen wir bereits aus dem „Hello World!“Kapitel. Die einzige Änderung haben wir in Zeile 9 vorgenommen. Hier greifen wir auf die Enumeration Autoteile und deren Mitglied (Konstante) Radaufhängung zu. Das Ergebnis auf dem Bildschirm sieht so aus: 1234 Bitte Enter drücken!

Hier noch einmal der Zugriff auf die Konstante (Radaufhängung) im Klartext: Autoteile.Radaufhängung

Sobald Sie den Punkt nach Autoteile gesetzt haben, wird Ihnen eine vollständige Liste aller Enumerationsmitglieder angeboten. Sie müssen nur noch wählen. 5.2.3 Strukturen Ähnlich wie Enumerationen werden mit Strukturen Daten organisiert. Anders als bei Enumerationen handelt es sich aber bei Strukturen nicht um eine Konstantenliste, sondern um eine Zusammenfassung von beliebigen Variablen oder Funktionen. Sinnvollerweise fasst man zum Kontext passende Variablen zusammen. Wenn unsere Struktur den Namen Auto trägt, sollten wir Variablen wie Reifen, Auspuff, Motorleistung und Verbrauch zusammenfassen. In solch einer Struktur hätte eine Variable mit dem Namen Kleidergröße nichts zu suchen. Eine Struktur wird mit dem Structure-Befehl eingeleitet. Beendet wird sie mit dem End Structure-Befehl. 1 2 3 4 5 6 7 8 9 10 11 12

Structure Automobile Dim MeinAuto As String Dim DeinAuto As String Dim UnsereAutos() As String Dim AnzahlAutos As Integer Sub FülleUnsereAutos() ReDim UnsereAutos(1) UnsereAutos(0) = MeinAuto UnsereAutos(1) = DeinAuto AnzahlAutos = 2 End Sub End Structure

38

Variablen

Unsere Struktur besitzt vier Variablen. Hierunter finden wir auch ein Array. Beachten Sie, dass das Array bei der Deklaration nicht dimensioniert werden darf. Dies geschieht in Zeile 7 über die ReDim-Anweisung. Außerdem haben wir eine Sub-Anweisung integriert. Sie soll unser Array mit Daten füllen und gleichzeitig die Anzahl der Autos festlegen. Sub Main() Dim Autos As Automobile Dim i As Integer Autos.MeinAuto = "Altes Auto" Autos.DeinAuto = "Neues Auto" Autos.FülleUnsereAutos() For i = 0 To UBound(Autos.UnsereAutos) Console.WriteLine(Autos.UnsereAutos(i)) Next i Console.WriteLine("Wir haben zusammen " & _ Autos.AnzahlAutos.ToString & " Autos.") Console.ReadLine() End Sub

13 14 15 16 17 18 19 20 21 22

23 24

In Zeile 14 deklarieren wir die Variable Autos mit der Struktur Automobile. Hierdurch können wir auf die Mitglieder der Struktur zugreifen. Jetzt wird der Sinn von Strukturen klar erkennbar. Geben wir den Variablennamen Autos mit anschließendem Punkte ein, werden die Mitglieder der Struktur sichtbar. Dese folgen einem bestimmten Kontext und wir müssen nicht an die Namen der einzelnen Variablen denken. Dies ist insbesondere bei der Bearbeitung älterer Programme eine große Hilfe.

5.3 Typensicherheit Typensicherheit verfolgt in erster Linie das Ziel, einen möglichen Datenverlust zu vermeiden. Ein Datenverlust kann genau dann auftreten, wenn wir Datentypen mischen, wie im folgenden Beispiel: 1 2 3

Dim dblZahl As Double = 12.1234 Dim lngZahl As Long lngZahl = dblZahl

Der Variablentyp Long ist nicht in der Lage, Nachkommazahlen zu speichern. Somit kann die Variable lngZahl nicht den gesamten Inhalt der Variable dblZahl aufnehmen. Die Nachkommastellen gehen verloren. Die Einstellungen des Compilers lassen diesen Datenverlust zu. Normalerweise ist ein Datenverlust auf jeden Fall zu vermeiden. Es kommt zwar vor, dass wir einen Datentyp in einen anderen konvertieren möchten, das

Typensicherheit

39

sollte jedoch über eine geeignete Programmstruktur erfolgen. Die Compilereinstellungen können wir auch aus dem Sourcecode beeinflussen. Hierzu gibt es zwei hilfreichen Einstellungen: • Option Explicit On / Off (Voreinstellung: On) Dieser Befehl erzwingt die explizite Deklaration aller Variablen. • Option Strict On / Off (Voreinstellung: Off) Mit der Option Strict-Anweisung muss jede Variable explizit mit der AS-Klausel deklariert werden. Eine Zuweisung; wie sie in Zeile 3 zu sehen war, wird durch den Compiler mit einer Fehlermeldung quittiert. Folgender Fehler wird ausgegeben: Option Strict On lässt keine impliziten Konvertierungen von Double in Long zu. Jedoch ist es manchmal nötig, den Datentyp zu wechseln. Wenn wir bei unserem Beispiel bleiben und den Datentyp Double in den Datentyp Long umwandeln möchten, wird das durch die Anweisung unterbunden. Um die Wandlung in geordneten Bahnen durchzuführen, gibt es die Ctype-Funktion. CType (expression, typname)

CType gibt das Ergebnis einer expliziten Konvertierung eines Ausdrucks in einem angegebenen Datentyp zurück. In unserem Beispiel sieht das wie folgt aus: lngZahl = CType(dblZahl, Long)

CType verwendet als ersten Parameter den Ausdruck, welcher konvertiert werden soll. Der zweite Parameter gibt den Datentyp an, in den der Ausdruck konvertiert werden soll. Der zweite Parameter kann auch ein Objekt, eine Struktur, eine Klasse oder eine Schnittstelle sein. Warum sollten Sie immer mit den Anweisungen Option Explicit On und Option Strict On arbeiten? Ist es nicht sehr viel einfacher, Option Strict und Option Explicit zu deaktivieren? Es ist einfacher, aber weniger hilfreich. Zum einen führt das Vernachlässigen von Deklarationen mit Sicherheit früher oder später zu schwer auffindbaren

40

Variablen

Programmfehlern. Zum anderen werden Sie Probleme haben, den Sorcecode zu lesen. Betrachten wir nochmals zwei Beispiele: • Beispiel 1 1 2 3

Option Strict Off Option Explicit Off Dim Var = „Das ist eine Variable.“

• Beispiel 2 1 2 3

Option Strict Off Option Explicit Off Dim Var = 123.345

Sie erkennen, dass den Dim-Anweisungen die As-Klauseln fehlen. Hierdurch ist es möglich, dass die Variable Var im Beispiel 1 den Datentyp String annimmt und im zweiten Beispiel den Datentyp Double erhält. Es ist offensichtlich, dass solch eine Freiheit nicht zur Übersichtlichkeit eines Programms beiträgt. Abschließend wollen wir an einem weiteren Beispiel demonstrieren, wie schnell es zu einem Tippfehler kommen kann und wie schwer die Fehlersuche danach sein kann. • Beispiel 3 1 2 3 4 5

Option Strict On Option Explicit On Dim iMyObject As Object iMyObject = “Das ist ein Text!” Console.WriteLine(iMyObjct)

Dieser Sourcecode wird problemlos kompiliert. Es wird kein Fehler gemeldet, obwohl das gewünschte Ergebnis nicht erzielt wird. Wir wollten der Variablen den Text „Das ist ein Text!“ zuweisen. Wir haben die Variable iMyObject nicht als String deklariert, sondern als Object. Durch die Option Strict On-Anweisung ist diese Zuweisung ungültig. Jetzt stellen Sie sich den Fehler in einem komplexen Source-Code mit mehreren tausend Zeilen vor.

Ermitteln des Variablentyps

41

5.4 Ermitteln des Variablentyps Schauen wir uns folgenden Sourcecode an. 1 2 3

Option Strict Off Option Strict Off Dim Var = 123.456

Welchen Datentyp hat die Variable Var angenommen? Es ist der Datentyp Double. Die TypeName-Funktion hilft uns bei der Ermittlung des Datentyps. TypeName (VarName) As String

Die Funktion TypeName liefert uns einen String. Der String benennt den abgefragten Variablentyp. Betrachten Sie dazu nachfolgende Tabelle. Tabelle 2. TypeName VarName 16-Bit-Wert, True oder False 8-Bit-Binärwert 16-Bit-Zeichenwert 64-Bit-Datums- und -Uhrzeitwert Verweistyp, der fehlende oder nicht vorhandene Daten anzeigt Numerischer 128-Bit-Festkommawert Numerischer 64-Bit-Gleitkommawert 32-Bit-Ganzzahlwert Verweistyp, der auf ein nicht spezialisiertes Objekt zeigt Verweistyp, der auf ein aus der Klasse erstelltes spezialisiertes Objekt zeigt 64-Bit-Ganzzahlwert Verweistyp, dem gegenwärtig kein Objekt zugewiesen ist 16-Bit-Ganzzahlwert Numerischer 32-Bit-Gleitkommawert Verweistyp, der auf eine Zeichenfolge aus 16-Bit-Zeichen zeigt

Rückgabewert Boolean Byte Char Date DBNull Decimal Double Integer Object Long Nothing Short Single String

6 Operatoren

Das Gedächtnis eines Programms (die Variablen) haben Sie bereits kennen gelernt, ebenso wie die zur Verfügung stehenden Datentypen. Sie können Variablen deklarieren und auch initialisieren. Um Variablen nutzen zu können, müssen Sie auf deren Inhalt zurückgreifen. Hierfür nutzen wir Operatoren. Einen Operator haben wir bereits häufiger verwendet, den =Operator, der beim Initialisieren von Variablen zum Einsatz kommt. Dim Automarke As String = „MeinAuto“

Operatoren können wir in Gruppen aufteilen: • • • •

Arithmetische Operatoren Vergleichsoperatoren Verkettungsoperatoren Logische Operatoren

Die vergleichsweise wichtigen Gruppen sind die Arithmetische Operatoren sowie die Vergleichsoperatoren. Diese werden detailliert erläutert. Auf eine Detailbetrachtung der Verkettungsoperatoren und der Logischen Operatoren verzichten wir.

6.1 Arithmetische Operatoren Arithmetische Operatoren werden für arithmetische Operationen verwendet. Mit ihnen werden numerische Werte berechnet. Zum Addieren zweier Werte wird der Plus(+)-Operator verwendet, zum Subtrahieren der Minus(-)-Operator. Hier finden Sie zwei Beispiele: 1 2 3

Dim Ergebnis As Integer Ergebnis = 23 + 79 Ergebnis = 56 – 12

44

Operatoren

Für die Negation wird ebenfalls der Minus-Operator eingesetzt. Die korrekte Syntax lautet: 1 2 3

Dim Zahl1 As Integer = 23 Dim Ergebnis As Integer Ergebnis = -Zahl1

Nach dieser Rechnung ist der Wert von Ergebnis = -23. Zwei weitere Operatoren sind der Multiplikations(*)-Operator bzw. der Divisions(/)-Operator. Hier die Beispiele zu diesen Operatoren: 1 2 3

Dim Ergebnis As Double Ergebnis = 25 * 25454 Ergebnis = 23 / 356

Bitte beachten Sie, dass wir die Variable Ergebnis diesmal als Datentyp Double deklariert haben. Dies ist notwendig, um das korrekte Ergebnis aus der Divisionsaufgabe aufzunehmen. Zur Division gibt es noch eine Sonderform. Der \-Operator teilt ganze Zahlen und liefert ein Ergebnis, das angibt, wie oft eine ganze Zahl durch eine andere geteilt werden kann. 1 2

Dim Ergebnis As Integer Ergebnis = 13 \ 6

Die Variable Ergebnis hat hierbei den Wert 2. Mit dem mod-Operator ermitteln Sie den Restwert einer Division. 1 2

Dim Ergebnis As Integer Ergebnis = 7 Mod 3

Die Variable Ergebnis hat den Wert 1. Potenziert wird mit dem ^-Operator. 1 2

Dim Ergebnis As Double Ergebnis = 12 ^ 4

Vergleichsoperatoren

45

6.2 Vergleichsoperatoren Vergleichsoperatoren liefern einen Boolean-Wert als Ergebnis und treten in drei Aufgabengruppen auf: • Vergleichen von numerischen Werten • Vergleichen von Zeichenfolgen • Vergleichen von Objekten Betrachen wir die Operatoren zum Vergleichen von numerischen Werten. Folgende Tabelle verschafft Ihnen einen Überblick. Tabelle 3. Vergleichsoperatoren für numerische Werte Operator

Beispiel

Ergebnis

= (gleich)

124 = 12

False

389 = 389

True

124 12

True

389 389

False

124 < 12

False

124 < 125

True

124 > 12

True

124 > 125

False

124 < = 12

False

389 = 389

True

124 >= 125

False

(ungleich) < (kleiner als) > (größer als) = (größer oder gleich)

6.2.1 Mit dem Gleich-Operator Werte zuweisen! Mit dem Gleich-Operator kann man nicht nur Werte oder Zeichenketten vergleichen, sondern auch zuweisen. Hier folgt ein typisches Beispiel:

46

Operatoren 1 2 3 4

Dim Ergebnis As Integer Dim Automarke As String Ergebnis = 12 Automarke = „MeinAuto“

Falls möglich, wird der zugewiesene Wert in den zur Variable passenden Datentyp konvertiert. Dies geht nicht immer und kann zu unvorhersehbaren Effekten führen, wie folgendes Beispiel zeigt. 1 2 3 4 5

Dim Ergebnis1 As Integer Dim Ergebnis2 As Date Dim Text1 As String = „01.01.1900“ Ergebnis1 = 3 / 2 Ergebnis2 = Text1

Ergebnis1 hat den Wert 1 und Ergebnis2 hat den Wert 01.01.1900 angenommen. Beachtenswert ist das Ergebnis2. Hier wurde eine Zeichenkette (Text1) in ein Datumsformat umgewandelt. Dies ist nur dann möglich, wenn die Zeichenkette wie ein Datum aufgebaut ist. Würde die Zeichenkette z.B. den Wert „aa121“ enthalten, könnte dieser Wert nicht in ein Datumsformat umgewandelt werden. Kommen wir nun zum Vergleichen von Zeichenketten. Hierzu können wir die gleichen Operatoren nutzen wie zum Vergleichen von numerischen Werten. Beachten Sie die Beispiele: • Ergebnis = True 1 2 3 4

Dim Ergebnis As Boolean Ergebnis = „Uwe“ = „Uwe“ Ergebnis = „Andreas“ „Uwe“ Ergebnis = „aaa“ > „aa“

• Ergebnis = False 1 2 3 4

Dim Ergebnis As Boolean Ergebnis = „Uwe“ = „Andreas“ Ergebnis = „Andreas“ „Andreas“ Ergebnis = „aaa“ < „aa“

Vergleichsoperatoren für Objekte sind für fortgeschrittene Programmierer interessant. Hier möchten wir nur auf die Möglichkeit hinweisen, mit dem Is-Operator bzw. TypeOf-Is-Operator Objekte zu vergleichen.

7 Verzweigungen

Interaktive Reaktionen, wie z.B. die Begrüßung des Computers mit einem „Guten Morgen!“, sind fester Bestandteil des Programmcodes.

7.1 Verzweigungen oder Entscheidungen? Auf den ersten Blick macht ein Computer einen außerordentlich schlauen Eindruck. Wir können ihn mit unzähligen Informationen füttern und er bringt innerhalb kürzester Zeit wieder Ordnung in das Chaos. Er misst sich mit den besten Schachgroßmeistern der Erde und hilft bei taktischen Problemen. Einige Programme täuschen sogar Emotionen vor. Insbesondere Jugendliche sprechen vom schlauen Computergegner. Ein Computer ist aber nicht in der Lage, selbst Entscheidungen zu treffen. Jedes Mal, wenn interaktive Reaktionen gefordert sind, folgt der Computer einer vordefinierten Verzweigung des Programmierers. Um Verzweigungen einzubauen, stehen zwei Möglichkeiten zur Verfügung: • If-Then-Else-Anweisung • Select-Case-Anweisung Beide Verzweigungsformen werden wir Ihnen jetzt vorstellen:

7.2 If-Then-Else-Anweisung Als Erstes sehen wir uns die Syntax einer solchen Anweisung einmal an. If condition [Then] [statements] [Elseif elseifcondition [Then]

48

Verzweigungen [elseifstatement]] [Else [elsestatement]] End If

Versuchen wir die Syntax der If-Anweisung etwas verständlicher auszudrücken: Wenn eine Bedingung gegeben ist, dann führe folgendes aus. Solche Verzweigungen sind keine Besonderheit. Die If-Then-ElseAnweisung ist die wichtigste Technik, um Verzweigungen einzuleiten. Die Prüfung, ob eine Bedingung erfüllt ist, liefert einen booleschen Ausdruck. Diese Prüfungen sind immer digitale Entscheidungen. Es existiert immer ein Ergebnis, welches mit True oder False interpretiert wird. Betrachten wir ein kleines Beispielprogramm: 1 2 3 4

5

6

7 8

9 10 11 12

13 14 15 16

Module Module1 Dim Automarke As String = "MeinAuto" Sub Main() Console.WriteLine("Die Prüfung der Bedingung_ ergab TRUE") If Automarke = "MeinAuto" Then _ Console.WriteLine("Die Automarke ist -MeinAuto-") If 2 < 5 Then _ Console.WriteLine("2 ist kleiner als 5") Console.WriteLine(" ") Console.WriteLine("Die Prüfung der Bedingung_ ergab FALSE") If Automarke = "DeinAuto" Then Console.WriteLine("Die Automarke ist -DeinAuto- ") Else Console.WriteLine("Die Automarke ist nicht _ -DeinAuto-, sondern -MeinAuto-") End If Console.Read() End Sub End Module

Bevor wir das Programm besprechen, sollten wir uns das Ergebnis anschauen. Die Prüfung der Bedingung ergab TRUE Die Automarke ist –MeinAuto2 ist kleiner als 5 Die Prüfung der Bedingung ergab FALSE

If-Then-Else-Anweisung

49

Die Automarke ist nicht –DeinAuto-, sondern – MeinAuto-

Das Programm ist wiederum ein Kommandozeilenprogramm, wie das „Hello World!“- Beispiel. Dieses zu erstellen, bereitet keine Probleme. Alternativ finden Sie das Programm auf unserer CD. In Zeile 2 deklarieren wir die Variable Automarke als Zeichenkette und initialisieren diese mit dem Wert MeinAuto. In Zeile 5 prüfen wir den Inhalt der Variablen Automarke: If Automarke = "MeinAuto" Then_ Console.WriteLine("Die Automarke ist -MeinAuto-")

In Zeile 6 prüfen wir eine Bedingung, welche auf numerischen Werten basiert. Auch hier ergibt die Prüfung das Ergebnis True. Dies wird durch eine Bildschirmausgabe bestätigt. If 2 < 5 Then_ Console.WriteLine("2 ist kleiner als 5")

Beide Beispiele haben eine Gemeinsamkeit: Die Prüfung der Bedingung muss True ergeben. Hier kann man noch nicht von einer richtigen Verzweigung sprechen. Aber das ändert sich jetzt. In Zeile 9 bis 13 wird es interessanter. Wir prüfen erneut die Variable Automarke: If Automarke = "DeinAuto" Then Console.WriteLine_ ("Die Automarke ist -DeinAuto- ") Else Console.WriteLine_ ("Die Automake ist nicht –DeinAuto-,_ sondern –MeinAuto-") End If

Der Wert von Automarke ist nicht DeinAuto. Die Überprüfung der Bedingung (Automarke = „DeinAuto“) würde False ergeben. Somit tritt die Else-Anweisung in Kraft. Natürlich dürfen Sie mehr als eine Anweisung ausführen. Hier finden Sie das Schema:

50

Verzweigungen 1 2 3 4 5

If Bedingung Then Anweisung Anweisung … End If

7.2.1 Notationsunterschiede! Bisher haben wir unsere Verzweigung folgendermaßen aufgebaut: If Bedingung Then Anweisung

Hierbei setzen wir voraus, dass die Prüfung der Bedingung True ergibt. Dies kann man auch explizit zum Ausdruck bringen. Die Syntax sieht dann so aus: If Bedingung Then Anweisung

oder If Bedingung = True Then Anweisung

Beide Anweisungen haben die gleiche Bedeutung. Beispiele: If (1 < 2) = True Then Console.WriteLine(„Eins ist kleiner zwei.“) If (1 > 2) = False Then Console.WriteLine(„Eins ist nicht größer zwei!“)

7.2.2 Verschachtelungen oder ElseIf:ElseIf Oftmals wird man vor das Problem gestellt, mehrere Bedingungen prüfen zu müssen. Dann kann man die If-Then-Else-Anweisungen ineinander verschachteln. Wenn Ihr Programm z.B. auf unterschiedliche Gehaltsgruppen reagieren soll, können Sie das mit einer Verschachtelung prüfen: 1 2 3 4 5 6

Module Module1 Dim Gehalt As Integer = 2500 Sub Main() If Gehalt > 1000 Then Console.WriteLine("Das Gehalt ist größer 1000") If Gehalt > 2000 Then

If-Then-Else-Anweisung 7 8 9

10 11 12 13 14 15

51

Console.WriteLine("Das Gehalt ist größer 2000") If Gehalt > 3000 Then Console.WriteLine_ ("Das Gehalt ist größer 3000") End If End If End If Console.ReadLine() End Sub End Module

Hier sehen Sie das Ergebnis: Das Gehalt ist größer 1000 Das Gehalt ist größer 2000

Das Programm besteht aus drei in sich verschachtelten If-Then-ElseAnweisungen. Die ersten beiden Bedingungen werden erfüllt (Das Gehalt ist größer 1000 und das Gehalt ist größer 2000). Zur Bestätigung erhalten wir jeweils eine Bildschirmausgabe. Die dritte Bedingung (Gehalt ist größer 3000), wird nicht mehr erfüllt, so dass keine Bildschirmausgabe erfolgt. Eine Verschachtelung wird durch eine ElseIf-Anweisung interessanter: 1 2 3 4

5 6

7 8

9 10 11 12

Module Module1 Dim Gehalt As Integer = 2500 Sub Main() If Gehalt >= 1000 And Gehalt < 2000 Then _ Console.WriteLine("Das Gehalt ist größer oder gleich 1000 und kleiner 2000") ElseIf Gehalt >= 2000 And Gehalt < 3000 Then Console.WriteLine("Das Gehalt ist größer oder gleich 2000 und kleiner 3000") ElseIf Gehalt >= 3000 Then Console.WriteLine("Das Gehalt ist größer oder gleich 3000") End If Console.ReadLine() End Sub End Module

Sie sehen das Ergebnis: Das Gehalt ist größer oder gleich 2000 und kleiner 3000

52

Verzweigungen

Wir erhalten jetzt eine wesentlich eindeutigere Antwort. Dazu haben wir einige Änderungen vorgenommen. Innerhalb der If-Then-ElseAnweisungen haben wir kombinierte Bedingungen verwendet: If Gehalt >= 1000 And Gehalt < 2000 Then

Bedingung Nr1: Gehalt >= 1000 Bedingung Nr2: Gehalt < 2000 Beide Bedingungen müssen mit True erfüllt werden, sonst wird die Anweisung Console.WriteLine("Das Gehalt ist größer oder gleich 1000 und kleiner 2000")

nicht ausgeführt. Dieser Sourcecode wirkt wesentlich strukturierter und Fehler sind schneller auffindbar. Durch Hinzufügen von weiteren ElseIf-Anweisungen kann der Sourcecode schnell erweitert werden und Sie sind somit in der Lage, zügiger auf veränderte Verhältnisse zu reagieren. Wie arbeitet die ElseIf-Anweisung? Um die Arbeitsweise einer ElseIf-Anweisung zu erläutern, benötigen wir eine schematische Darstellung: 1 2 3 4 5 6 7 8 9 10 11 12

Dim Zahl1 As Integer = 310 If Zahl1 > 100 Then Anweisung 1 ElseIf Zahl1 > 200 Then Anweisung 2 ElseIf Zahl1 > 300 Then Anweisung 3 ElseIf Zahl1 > 400 Then Anweisung 4 Else Anweisung 5 End If

Wenn Sie das Beispiel betrachten, stellen Sie fest, das lediglich Anweisung 1 ausgeführt wird, obwohl die Bedingungen zwei und drei ebenfalls mit True beantwortet werden. Sobald eine Bedingung True ergibt wird ( in unserem Beispiel ist das die erste Bedingung), werden die anderen Be-

Select-Case-Anweisungen

53

dingungen nicht mehr geprüft und das Programm springt direkt zur EndIf-Zeile.

7.3 Select-Case-Anweisungen Wieder sehen wir uns als Erstes die generelle Syntax der Anweisung an. Select [ Case ] testexpression [ Case expressionlist [ statements ] ] [ Case Else [ elsestatements ] ] End Select

Müssen viele Entscheidungen getroffen werden, bietet sich die SelectCase-Anweisung an. Vergleichen wir sie mit der bekannten If-ThenElse-Anweisung, erkennen wir eine deutlich klarere Struktur, Der Parameter testexpression beinhaltet eine Variable, die durch die verschiedenen Einträge der expressionlist geprüft wird. Sollte keine der Prüfungen erfolgreich sein, werden die Case-Else-Anweisungen ausgeführt. Hier zeigen wir eine schematische Darstellung: 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Select Case Variable Case Wert 1 Anweisung … Case Is > Wert 2 Anweisung … Case Is < Wert 3 Anweisung … Case Is > Wert 4, Is < Wert 5 Anweisung … Case Wert 6, Wert 7 Anweisung … Case Else Anweisung … End Select

Unser kleines Würfelspiel demonstriert den Einsatz der Select-CaseAnweisung und zeigt Ihnen gleichzeitig, wie Sie eine Zufallszahl generieren können: 1 2 3

Module Module1 Dim Run As Boolean = True Dim Zahl As Integer

54

Verzweigungen 4 5 6 7 8 9

10 11

12 13 14 15 16 17

18 19

20 21

22 23

24 25

26 27

28 29

30 31 32

33

34

35 36 37 38 39

Dim Eingabe As String Sub Main() Do While Run = True Console.WriteLine(" ") Console.WriteLine("Das Spiel beginnt!") Console.WriteLine("------------------") Zahl = Int(Rnd() * 9) Console.WriteLine("Der Wert von Zahl ist: "_ & Zahl) Console.WriteLine("------------------") Select Case Zahl Case 0 Console.WriteLine("Eine Null?") Case 1 Console.WriteLine_ ("Sie haben eine 1 gewürfelt!") Case 2 Console.WriteLine_ ("Nun 2 ist besser als 1.") Case 3 Console.WriteLine_ ("Das ist die goldene Mitte - eine 3") Case 4 Console.WriteLine_ ("Sie entwickeln sich langsam zum _ Profi - eine 4") Case 5 Console.WriteLine_ ("Jetzt haben Sie sich so bemüht und _ dennoch nur eine 5") Case 6 Console.WriteLine_ ("Volltreffer, eine 6") Case Is > 6 Console.WriteLine_ ("Illegaler Würfel! Gehen Sie nicht_ über Los ...") End Select Console.WriteLine(" ") Console.WriteLine_ ("---------------------------------------------") Console.WriteLine ("Drücken Sie w + Enter um _ das Spiel fortzusetzen") Console.WriteLine("Drücken Sie e + Enter um _ das Spiel zu beenden") Eingabe = Console.ReadLine() If Eingabe "w" Then Run = False Loop End Sub End Module

Select-Case-Anweisungen

55

In diesem Beispiel haben wir eine Do-Loop-Schleife verwendet. Dies ist ein Thema des nächsten Kapitels. Die Select-Case-Anweisung erstreckt sich über die Zeilen 13 bis 30. Die zu prüfende Variable heißt Zahl und bewegt sich in einem Wertebereich von 0 bis 9. Dieser wird über einen Zufallsgenerator erstellt. Zahl = Int(Rnd() * 9)

Da die Rnd-Funktion einen Wert vom Datentyp Single zurück gibt, konvertieren wir diesen Wert direkt in einen Integer Wert. Dieser Wert kann von der Select-Case-Anweisung gut ausgewertet werden. An diesem Beispiel können wir die Arbeitsweise der Select-CaseAnweisung sehr gut beobachten. Sobald eine Bedingung eines CaseZweiges erfüllt ist, werden die verbleibenden Bedingungen nicht mehr geprüft. Wird eine 3 gewürfelt, werden folgende Bedingungen geprüft: Case 0

… Ergebnis: False… die Anweisungen werden nicht ausgeführt Case 1 … Ergebnis: False… die Anweisungen werden nicht ausgeführt Case 2 … Ergebnis: False… die Anweisungen werden nicht ausgeführt Case 3 … Ergebnis: True… die Anweisungen werden ausgeführt

Alle nachfolgenden Bedingungen unterliegen keiner weiteren Prüfung und das Programm springt zur Zeile 30 (End Select). Sollte keine Bedingung dem Kriterium entsprechen, würde die CaseElse-Anweisung in Kraft treten. Fehlt diese, wird nichts ausgeführt und die Select-Case-Anweisung wird ohne Ergebnis beendet.

8 Schleifen

Computer sind praktisch, um langweilige, immer wiederkehrende Abläufe zu bearbeiten. Was liegt näher, als diese ungeliebten Aufgaben einem Computer zu übertragen. Dies geschieht mit Hilfe von Schleifen. Wir suchen uns ein Beispiel, welches besonders monoton und langweilig ist: Eine Zahl wird immer wieder um einen Zähler erhöht, bis 30 erreicht wird. Schematisch würde die Aufgabe wie folgt aussehen: Zahl Zahl Zahl … Zahl

= 0 = Zahl +1 … Zahl hat den Wert 1 = Zahl +1 … Zahl hat den Wert 2 = Zahl +1 … Zahl hat den Wert 30

Mit unseren bisherigen programmiertechnischen Mitteln könnten wir das Problem folgendermaßen lösen: Module Module1 Dim Zahl As Integer = 0 3 Sub Main() 4 Zahl += 1 5 Zahl += 1 6 Zahl += 1 7 Zahl += 1 8 Zahl += 1 9 Zahl += 1 10 Zahl += 1 ... 33 Zahl += 1 34 Console.ReadLine() 35 End Sub 36 End Module 1 2

Dies ist keine Lösung und wäre bei einem Zahlenwert von einhunderttausend nicht zumutbar. Wir benötigen für eine elegantere Lösung Schleifen.

58

Schleifen

8.1 For-Next-Schleife Die For-Next-Schleife dürfte wohl die beliebteste Vertreterin aller Schleifen sein. Dies liegt wohl auch an der einfachen Struktur und den eindeutigen Parametern. Sie arbeitet mit festen Dimensionen: For counter = start To end [ Step] [ statements ] Next [ counter ]

Counter ist eine Variable, die in der Schleife durch die Schrittweite (Step) verändert wird. Die Angabe der Schrittweite ist ein optionaler Parameter. Im Regelfall ist sie eins. Der Wertebereich von Zähler liegt zwischen Anfangswert (start) und Endwert (end). Für die praktische Umsetzung verwenden wir unser Beispiel von der vorhergehenden Seite: 1 2 3 4 5

6 7 8 9

Module Module1 Dim Zähler As Integer = 0 Sub Main() For Zähler = 1 To 30 Step 1 Console.WriteLine_ ("Der Wert von Zähler ist: " & Zähler) Next Zähler Console.ReadLine() End Sub End Module

Hier die dazugehörige Bildschirmausgabe. Der Der Der Der Der Der … Der Der Der

Wert Wert Wert Wert Wert Wert

von von von von von von

Zähler Zähler Zähler Zähler Zähler Zähler

ist: ist: ist: ist: ist: ist:

1 2 3 4 5 6

Wert von Zähler ist: 28 Wert von Zähler ist: 29 Wert von Zähler ist: 30

Dies ist eine vernünftige Lösung. Das Addieren der Variablen Zähler wurde auf einen schlanken Dreizeiler (Zeile 4 bis 6) reduziert. Ohne Schleifen würden wir hierfür immerhin dreißig Zeilen benötigen. In Zeile 4 haben wir … Step 1 angegeben. Diese Angabe ist eigentlich nicht nötig. Wie bereits erwähnt, ist die Angabe der Schrittweite freiwil-

Do-Loop-Schleife

59

lig. Sollten Sie keine Schrittweite angeben, wird automatisch eine Schrittweite von 1 angenommen. Sie dürfen auch negative Schrittweiten angeben. Dann muss der Startwert aber größer sein als der Endwert (z.B. bei einem Countdown). Für das Beenden einer Schleife nehmen wir die Exit-For-Anweisung. Sie veranlasst einen Abbruch des Schleifenzyklus. Das Programm springt zur ersten Anweisung nach der Next-Anweisung, wie ein weiteres Beispiel zeigt: 1 2 3 4 5

6 7 8

9 10 11

Module Module1 Dim Zähler As Integer = 0 Sub Main() For Zähler = 1 To 30 Step 1 Console.WriteLine_ ("Der Wert von Zähler ist: " & Zähler) If Zähler = 9 Then Exit For Next Zähler Console.WriteLine("Dies ist die erste _ Anweisung nach der Next-Anweisung") Console.ReadLine() End Sub End Module

Betrachten Sie die Bildschirmausgabe: Der Wert von Der Wert von Der Wert von … Der Wert von Der Wert von Dies ist die Anweisung

Zähler ist: 1 Zähler ist: 2 Zähler ist: 3 Zähler ist: 8 Zähler ist: 9 erste Anweisung nach der Next-

In Zeile 6 überprüfen wir, ob die Variable Zähler den Wert 9 hat. Falls dies der Fall ist, soll die For-Next-Schleife abgebrochen werden. Nach dem Abbruch der Schleife geht es mit Zeile 8 weiter.

8.2 Do-Loop-Schleife Do-Loop-Schleifen sind ein fester Bestandteil jeder Programmiersprache. Der wesentlichste Unterschied zu der For-Next-Schleife besteht darin, dass es keinen Zähler gibt. Ohne Zähler gibt es auch keinen fest definierten

60

Schleifen

Anfang, sowie ein offenes Ende. Die Do-Loop-Schleife besitzt somit ein Höchstmaß an Flexibilität. Syntax der kopfgesteuerten Do-Loop-Schleife: Do { While | Until } condition [ statements ] Loop

oder Syntax der fußgesteuerten Do-Loop-Schleife: Do [ statements ] Loop { While | Until } condition

Unsere Aussage, dass eine Do-Loop-Schleife keinen Zähler besitzt, soll direkt modifiziert werden. Es ist möglich, mit externen Variablen ein Zählerkonstrukt zu erstellen. Dazu kommen wir später. Betrachten wir zunächst das Grundgerüst der Do-Loop-Schleife: 1 2 3 4 5 6 7 8 9

Module Module1 Dim Zähler As Integer = 0 Sub Main() Do Zähler += 1 Console.WriteLine(Zähler) Loop End Sub End Module

Was zwischen Zeile 4 und Zeile 7 geschieht, muss nicht mehr erklärt werden. Die Variable Zähler wird aufaddiert und auf dem Bildschirm ausgegeben. Achtung! Dieses Programm ist gefährlich. Erkennen Sie das Problem? Wir haben eine Schleife konstruiert, welche kein Ende besitzt. Wir haben auch kein Abbruchkriterium integriert. Die Schleife wird endlos laufen, ohne dass wir sie abbrechen können, bis sie irgendwann mit einem Fehler (System.OverflowException) beendet wird. Die Variable Zähler ist vom Datentyp Integer, dessen Wertebereich auf 2.147.483.647 begrenzt ist. Wenn dieser Wert überschritten wird, kommt es zu diesem Fehler.

Do-Loop-Schleife

61

Natürlich wollen wir die Do-Loop-Schleife kontrollieren. Hierfür gibt es die While- bzw. Until-Anweisung. Betrachten wir eine kopfgesteuerte Do-Loop-Schleife mit integrierter While-Anweisung: 1 2 3 4 5 6 7 8 9 10

Module Module1 Dim Zähler As Short = 0 Sub Main() Do While Zähler 10 Zähler += 1 Console.WriteLine(Zähler) Loop Console.ReadLine() End Sub End Module

Diesmal wird die Schleife nicht endlos laufen. Wenn der Zähler den Wert 10 erreicht hat, wird sie beendet und das Programm wird mit Zeile 9 fortgesetzt. Dieses Konstrukt ist fast identisch mit einer For-Next-Schleife. Der wesentliche Unterschied ist die Variable Zähler. Diese Variable ist nicht Bestandteil der Do-Loop-Schleife, sondern kann aus einem ganz anderen Kontext kommen. Das Ganze funktioniert natürlich auch bei der fußgesteuerten Do-Loop-Schleife mit integrierter Until-Anweisung. 1 2 3 4 5 6 7 8 9 10

Module Module1 Dim Zähler As Short = 0 Sub Main() Do Zähler += 1 Console.WriteLine(Zähler) Loop Until Zähler = 10 Console.ReadLine() End Sub End Module

Bei der For-Next-Schleife haben wir die Exit-For-Anweisung kennengelernt. Natürlich hat die Do-Loop-Schleife ein entsprechendes Äquivalent zu bieten. Mit der Exit-Do-Anweisung können wir den Schleifenzyklus vorzeitig beenden. 1 2 3 4 5 6 7 8

Module Module1 Dim Run As Boolean = True Dim Zähler As Integer = 0 Sub Main() Do While Run Zähler += 1 Console.WriteLine(Zähler) If Zähler = 10 Then Exit Do

62

Schleifen 9

10 11 12

Loop Console.ReadLine() End Sub End Module

Bitte beachten Sie die Variable Run. Sie ist vom Datentyp Boolean und wurde mit True initialisiert. In Zeile 8 haben wir eine kleine If-ThenAnweisung, die zum außerordentlichen Abbruch per Exit-DoAnweisung führt. Wir hätten aber auch die Variable Run auf False setzten können. In unserem Beispiel würde dies zum gleichen Ergebnis führen – die Schleife würde beendet. Der Unterschied besteht darin, dass diesmal die Schleife ordentlich beendet wird, d.h. programmtechnisch sauber. 8.2.1 Endlosschleifen Das Problem der Endlosschleifen haben wir bereits angesprochen. Eine Endlosschleife kann normalerweise nicht unterbrechen. Im schlimmsten Fall ist das System so stark mit der Abarbeitung der Schleife beschäftigt, dass nichts anderes mehr funktioniert. Da hilft nur noch (Strg) + (Alt) + (Entf). Um dies zu vermeiden, gibt es die DoEvents-Anweisung. Diese sorgt dafür, dass neben dem eigentlichen Programm auch noch Systemnachrichten verarbeitet werden. Allerdings steht die DoEvents-Anweisung in einer Konsolenanwendung nicht zur Verfügung. Das liegt daran, dass die Anweisung unter dem System.Windows.Forms.Application-Objekt zu finden ist. Wer diese Anweisung unbedingt in einer Konsolenanwendung benötigt, kann die System.Windows.Form.dll auch manuell einbinden, womit dann auch die DoEvents-Anweisung verfügbar ist.

8.3 While-End-While-Schleife Die Syntax einer While-End-While-Schleife ist der der Do-LoopSchleife sehr ähnlich. While condition [ statements ] End While

Wenn das Ergebnis von condition den Wert True ergibt, werden alle statements zwischen While und End While ausgeführt. Sobald

For-Each-Schleife

63

condition den Wert False ergibt, wird das Programm mit der ersten Anweisung nach End While fortgesetzt. 1 2 3 4

5 6 7 8 9 10

Sub Main() Dim Zähler As Integer While Zähler < 3 Console.WriteLine("Der Wert der Variable Zähler ist: " & Zähler) Zähler += 1 End While Console.WriteLine("") Console.WriteLine("Drücken Sie Enter zum Beenden!") Console.ReadLine() End Sub

Die Schleife wird in den Zeilen 3 bis 6 drei Mal durchlaufen. Erster Durchlauf Zweiter Durchlauf Dritter Durchlauf Vierter Durchlauf

--> --> --> -->

Zähler Zähler Zähler Zähler

= = = =

0 1 2 3

Hier die dazu gehörenden Bildschirmausgabe: Der Wert der Variable Zähler ist: 0 Der Wert der Variable Zähler ist: 1 Der Wert der Variable Zähler ist: 2 Drücken Sie Enter zum beenden!

Unsere Abbruchbedingung in Zeile 3 besagt, dass die Schleife so lange durchlaufen werden soll, solange Zähler kleiner 3 ist. Beim vierten Schleifendurchlauf ist der Wert = 3 und die Schleife wird nicht mehr durchlaufen.

8.4 For-Each-Schleife Auch die Erklärung dieser Schleife wollen wir mit einer schematischen Darstellung der Syntax beginnen. For Each element In group [ statements ] Next [ element ]

64

Schleifen

Die For-Each-Next-Schleife bearbeitet hauptsächlich VariablenArrays. Diese Schleifenart haben wir bisher noch nicht besprochen und möchten sie hier vorstellen. Nehmen wir folgenden Fall an: Sie möchten den Inhalt eines Arrays auf dem Bildschirm ausgeben. Dazu benutzen Sie die For-Next-Schleife wie in folgendem Beispiel: 1 2

3 4 5 6 7 8 9 10

Module Module1 Dim Array() As String = _ {"Vera", "Uwe", "Christoph", "Sebastian"} Dim Zähler As Integer = 0 Sub Main() For Zähler = 0 To 3 Console.WriteLine(Array(Zähler)) Next Console.ReadLine() End Sub End Module

Bei diesem Beispiel entdecken wir schnell ein entscheidendes Problem. Woher kennen wir den End-Parameter der For-Next-Schleife? Die Mitglieder des Arrays konnten durchgezählt werden. Das ist aber nicht immer möglich. Wir benötigen eine Technik, mit der wir ein komplettes Array durchforsten können, ohne die genaue Dimension zu kennen. Dies geschieht mit der For-Each-Next-Schleife. 1 2

3 4 5 6 7 8 9 10

Module Module1 Dim Array() As String = _ {"Vera", "Uwe", "Christoph", "Sebastian"} Dim Mitglied As String Sub Main() For Each Mitglied In Array Console.WriteLine(Mitglied) Next Console.ReadLine() End Sub End Module

Hier sehen Sie die Bildschirmausgabe: Vera Uwe Christoph Sebastian

For-Each-Schleife

65

Der Unterschied fällt sofort auf. Ohne die Arraydimensionen zu kennen, können wir auf den gesamten Inhalt des Arrays zugreifen. Dies funktioniert auch mit anderen Auflistungen wie dem Collection-Objekt.

9 Arrays

Die Verwendung von Arrays ermöglicht uns, mit einem Variablennamen auf mehrere Variablen zuzugreifen. Da bei jeder Variablen derselbe Name verwendet wird, nutzen wir als Unterscheidungskriterium einen Index. Dieser muss eine ganze Zahl sein. Wir unterscheiden statische und dynamische Arrays. Beim statischen Array ist die Dimension (d.h. wie viel Elemente in dem Array aufgenommen werden können) bekannt. Nachdem das Array deklariert wurde, kann die Dimension nicht mehr verändert werden. Beim dynamischen Array ist die Größe noch unbekannt. Sie ergibt sich während des Programmablaufs und kann verändert werden.

9.1 Statische Arrays Die Deklaration eines Arrays unterscheidet sich kaum von der einer normalen Variablen, wie Sie im folgenden Beispiel sehen: Dim arrZahlenreihe(10) As Integer

Der Name des Arrays ist arrZahlenreihe. Es werden uns 11 Elemente (0 bis 10) zur Verfügung gestellt. Um auf ein bestimmtes Element im Array zuzugreifen, verwenden wir einen Index. 1

2 3

Dim arrZahlenreihe(10) As Integer = _ {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} Dim Ergebnis As Integer Ergebnis = arrZahlenreihe(2)

Der Wert von Ergebnis ist in diesem Fall gleich 3. Die folgende Tabelle verdeutlicht die Wertezuweisung:

68

Arrays

Tabelle 4. Wertezuweisung des Arrays arrZahlenreihe() ArrZahlenreihe Index 0

1

2

3

4

5

6

7

8

9

10

Wert

2

3

4

5

6

7

8

9

10

11

1

Anhand der Tabelle können Sie erkennen, welcher Wert unter welchem Index gespeichert ist. Welchen Wert Sie unter einem bestimmten Index finden, ist von der Initialisierung abhängig. Um dies zu verdeutlichen, betrachten wir ein weiteres Beispiel: 1

2 3

Dim arrNamensliste(3) As String = _ {„Vera“, „Uwe“, „Sebastian“, „Christoph“} Dim Ergebnis As String Ergebnis = arrNamensliste(2)

Tabelle 5. Wertezuweisung des Arrays arrNamensliste() ArrNamensliste Index

0

1

2

3

Wert

Vera

Uwe

Sebastian

Christoph

Hier sehen Sie, dass wir nicht nur Arrays mit Zahlen initialisieren können, sondern auch Zeichenketten verwenden dürfen.

9.2 Dynamische Arrays Dynamische Arrays haben im Vergleich zu den statischen Arrays den wesentlichen Vorteil, dass die Dimension (Anzahl der Elemente eines Arrays) nicht festgelegt wurde. Durch diesen Unterschied ist das Array in der Lage, sich den spezifischen Bedingungen eines Programms anzupassen. Nehmen wir folgenden Fall an: Sie möchten die Filenamen aus dem Rootverzeichnis Ihrer Festplatte ermitteln. Diese Namen sollen in einem Array gespeichert werden. Ein Problem, das Sie lösen müssen, ist die Dimension des Arrays festzulegen. Wählen Sie eine zu kleine Dimension, können nicht alle Namen gespeichert werden. Überdimensionieren Sie das Array, vergeuden Sie Rechenleistung und Systemressourcen. Schauen wir uns die Lösung an:

Dynamische Arrays 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

69

Module Module1 Dim arrFiles() As String Dim strFile As String Dim Zähler As Integer = 0, i As Integer Sub Main() strFile = Dir("c:\", FileAttribute.Normal) Do While strFile "" Zähler += 1 ReDim Preserve arrFiles(Zähler) arrFiles(Zähler) = strFile strFile = Dir() Loop For i = 1 To Zähler Console.WriteLine(arrFiles(i)) Next Console.ReadLine() End Sub End Module

In Zeile 2 deklarieren wir ein dynamisches Array. Indem wir die Klammern (arrFiles()) leer lassen, weiß das System, dass es sich um ein dynamisches Array handelt. In Zeile 9 verändern wir die Dimension des Arrays. Dies geschieht mit der ReDim-Anweisung. Der PreserveParameter ist eine optionale Angabe. Er sorgt dafür, dass die bereits vorhandenen Elemente eines Arrays beim Redimensionieren nicht gelöscht werden. Sollte der Preserve-Parameter fehlen, würde beim Aufruf von ReDim das gesamte Array gelöscht. Falls im Rootverzeichnis Ihres Systems keine Files liegen, sollten Sie die Pfadangaben in Zeile 6 der Dir-Anweisung auf ein geeignetes Verzeichnis legen. 9.2.1 GetUpperBound In unserm ersten Beispiel zu dynamischen Arrays haben wir einen Zähler mitlaufen lassen. Diesen Zähler haben wir verwendet, um ein Array neu zu dimensionieren. In der Praxis ist dies eine äußerst umständliche Technik. Außerdem streben wir immer nach einem möglichst kurzen und eleganten Sourcecode. Die GetUpperBound-Methode ermittelt die aktuelle Dimension eines Arrays. Visual Basic Programmierern ist diese Methode als Ubound-Methode (sie existiert immer noch, sollte aber durch die GetUpperBound-Methode abgelöst werden) bekannt. Sie sollten wissen, dass die GetUpperBound-Methode einen Fehler liefert, wenn

70

Arrays

die Dimension des Arrays kleiner null ist. Dies ist der Fall, wenn das Array noch kein Element enthält. 1 2 3 4 5 6 7 8 9 10

11 12 13 14 15 16 17 18 19 20

Module Module1 Dim arrFiles() As String Dim strFile As String, i As Integer Sub Main() strFile = Dir("c:\", FileAttribute.Normal) Do While strFile "" If IsNothing(arrFiles) = True Then ReDim Preserve arrFiles(1) Else ReDim Preserve arrFiles_ (arrFiles.GetUpperBound(0) + 1) End If arrFiles(arrFiles.GetUpperBound(0)) = strFile strFile = Dir() Loop For i = 1 To arrFiles.GetUpperBound(0) Console.WriteLine(arrFiles(i)) Next Console.ReadLine() End Sub End Module

Die interessanten Abläufe spielen sich zwischen den Zeilen 7 und 11 ab. In Zeile 7 hinterfragen wir mit der IsNothing-Methode, ob das Array bereits Elemente besitzt. Falls das nicht der Fall ist, (IsNothing = True), nehmen wir eine erste Redimensionierung vor. Sollte das Array bereits einige Elemente beinhalten, ermitteln wir mit der Array.GetUpperBound-Methode (Zeile 10) die genaue Anzahl der eingebundenen Elemente der ersten Dimension. Da wir ein neues Element speichern wollten, addieren wir zu der ermittelten Größe noch einen Speicherplatz und verwenden diesen Wert zum Redimensionieren.

9.3 Mehrdimensionale Arrays Oftmals reichen eindimensionale Arrays nicht aus. Es wäre schön, wenn wir mehr als eine Dimension zur Verfügung hätten. Mehrdimensionale Arrays lassen sich vom Grundsatz her genau wie eindimensionale Arrays behandeln. Schauen wir uns die Deklaration an: Dim arrDoppelteZahlenreihe(10,2) As Integer

Dieses zweidimensionale Array würde uns 33 Speicherplätze anbieten.

Mehrdimensionale Arrays

71

Dim arrMehrfacheZahlenreihe(10,2,2) As Integer

Dieses dreidimensionale Array schafft es bereits, 99 Elemente aufzunehmen. Um dies zu verdeutlichen, betrachten wir den Zugriff auf ein mehrdimensionales Array. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

arrMehrfacheZahlenreihe(0,0,0) = Wert1 arrMehrfacheZahlenreihe (0,0,1) = Wert2 arrMehrfacheZahlenreihe (0,0,2) = Wert3 … arrMehrfacheZahlenreihe (0,1,0) = Wert4 arrMehrfacheZahlenreihe (0,1,1) = Wert5 arrMehrfacheZahlenreihe (0,1,2) = Wert6 … arrMehrfacheZahlenreihe (0,2,0) = Wert7 arrMehrfacheZahlenreihe (0,2,1) = Wert8 arrMehrfacheZahlenreihe (0,2,2) = Wert9 … arrMehrfacheZahlenreihe (1,0,0) = Wert10 arrMehrfacheZahlenreihe (1,0,1) = Wert11 arrMehrfacheZahlenreihe (1,0,2) = Wert12 … … … arrMehrfacheZahlenreihe (10,2,0) = Wert97 arrMehrfacheZahlenreihe (10,2,1) = Wert98 arrMehrfacheZahlenreihe (10,2,2) = Wert99

Um dieses Thema abzuschließen, haben wir noch ein umfassendes Beispiel erstellt: 1 2 3 4 5 6 7 8 9 10

11

12 13 14 15

Module Module1 Dim Dimension1, Dimension2, Dimension3 As Integer Dim arrArray(10, 2, 2) As Integer Dim Wert As Integer = 0 Sub Main() For Dimension1 = 0 To 10 For Dimension2 = 0 To 2 For Dimension3 = 0 To 2 Wert += 1 arrArray(Dimension1, Dimension2, Dimension3) =_ Wert Console.WriteLine("Array(" & Dimension1 & "," _ & Dimension2 & "," & Dimension3 & ")_ hat den Wert: " & Wert) Next Next Next Console.WriteLine_ ("...............................................")

72 16

17

18

19 20 21

Arrays Console.WriteLine_ ("Die Größe der 1. Dimension ist: " &_ arrArray.GetUpperBound(0)) Console.WriteLine_ ("Die Größe der 2. Dimension ist: " &_ arrArray.GetUpperBound(1)) Console.WriteLine_ ("Die Größe der 3. Dimension ist: " &_ arrArray.GetUpperBound(2)) Console.ReadLine() End Sub End Module

In Zeile 6 bis 14 haben wir ein verschachteltes For-Next-Konstrukt. Über die Start- bzw. Endwerte der einzelnen For-Next-Schleifen können wir die Größen der Arraydimensionen genau wiedergeben. Hierdurch ist es ein Leichtes, die Arrayelemente mit Werten zu füllen. In Zeile 16 bis 18 zeigen wir Ihnen, wie Sie die Dimensionsgrößen mit Hilfe der GetUpperBound-Methode ermitteln. Das funktioniert natürlich genau wie bei einem eindimensionalen Array.

10 Funktionen und Subroutinen

10.1 Subroutinen Subroutinen sind uns nicht unbekannt, schließlich arbeiten wir bereits mit der Subroutine Main(),dem Startpunkt eines Programms. Es gibt vier Arten, die Main-Prozedur einzuleiten: • • • •

Sub Main() Sub Main(ByVal CmdArgs() As String) Function Main() As Integer Function Main(ByVal CmdArgs() As String)_ As Integer

Obwohl es diese verschiedenen Techniken gibt, werden wir uns ausschließlich mit der Sub Main()-Routine beschäftigen. Diese Technik ist weit verbreitet und stellt für uns einen unkomplizierten und übersichtlichen Einstiegspunkt dar. Unsere bisherigen Programme arbeiten mit einer normalen Sub Main()Routine. Innerhalb der Sub Main()-Routine befindet sich unser gesamtes Programm. Wenn sie beendet wird, endet auch unser Programm. Wenn unsere Programme komplexer werden und wir weiterhin den gesamten Sourcecode in die Sub Main()-Routine unterbringen, führt dies zwangsläufig zu einem unübersichtlichen Sourcecode und dies ist viel zu kompakt für den Aufbau eines strukturierten Programms. Um dieses Problem zu umgehen, versuchen wir, einen Teil des Sourcecodes in untergeordnete Routinen (Subroutinen) auszulagern. Betrachten Sie dazu das folgende Beispiel. 1 2 3

Module Module1 Dim Zähler As Integer = 0 Sub Main()

74

Funktionen und Subroutinen 4 5 6 7

8 9 10 11 12

13 14 15 16

17

18 19

SchreibeAdresse() SchreibeDatum() Console.ReadLine() End Sub Sub SchreibeAdresse() Console.WriteLine("Hans Mustermann") Console.WriteLine("Musterstraße 111") Console.WriteLine("98989 Musterhausen") End Sub Sub SchreibeDatum() Console.WriteLine(" ") Console.WriteLine("... Datum und Uhrzeit ...") Console.WriteLine_ ("Wir haben folgendes Datum: " & Today) Console.WriteLine_ ("Wir haben folgende Uhrzeit: " & TimeOfDay) End Sub End Module

Unsere gesamte Sub Main()-Routine ist lediglich fünf Zeilen (Zeile 3 bis 7) lang. In Zeile 4 und 5 werden Subroutinen aufgerufen. Es ist leicht zu erkennen, dass die Verwendung von Subroutinen ein strukturiertes Programmieren erleichtert. Natürlich dürfen wir beim Aufruf einer Subroutine auch Parameter übergeben, wie im folgenden Beispiel vorgeführt: 1 2 3 4 5 6 7 8

9 10 11 12 13 14 15 16

17

18 19

Module Module1 Dim Zähler As Integer = 0 Sub Main() SchreibeAdresse("Hans", "Mustermann") SchreibeDatum() Console.ReadLine() End Sub Sub SchreibeAdresse(ByVal Vorname As String,_ ByVal Nachname As String) Console.WriteLine(Vorname & " " & Nachname) Console.WriteLine("Musterstraße 111") Console.WriteLine("98989 Musterhausen") End Sub Sub SchreibeDatum() Console.WriteLine(" ") Console.WriteLine("... Datum und Uhrzeit ...") Console.WriteLine_ ("Wir haben folgendes Datum: " & Today) Console.WriteLine_ ("Wir haben folgende Uhrzeit: " & TimeOfDay) End Sub End Module

Funktionen

75

Betrachten wir die Subroutine SchreibeAdresse(). In diesem Beispiel haben wir zwei Parameter übergeben. Vorname ist der erste Parameter und Nachname der zweite. Beide Parameter sind durch ein Komma getrennt und genau so wird die Subroutine auch aufgerufen. Den Aufruf sehen wir in Zeile 4. 10.1.1 ByVal oder ByRef Wenn ein Parameter (eine Variable) mit dem Zusatz ByVal (Call by Value) übergeben wird, bleibt der Wert der Ursprungsvariablen unverändert. 1 2 3 4 5

Dim Zahl As Integer = 1 Call Addiere(Zahl) Sub Addiere(ByVal Wert As Integer) Wert += 1 End Sub

Bevor die Subroutine Addiere() aufgerufen wurde, war der Wert von Zahl = 1. Nach Durchlauf der Subroutine ist dieser Wert gleich. Wird ein Parameter mit dem Zusatz ByRef (By Referenz) übergeben, wird nicht der Wert einer Variablen übergeben, sondern die Variable selbst. Hierdurch wird der Wert der Ursprungsvariablen verändert. 1 2 3 4 5

Dim Zahl As Integer = 1 Call Addiere(Zahl) Sub Addiere(ByRef Wert As Integer) Wert += 1 End Sub

Vor dem Durchlaufen der Subroutine Addiere() ist der Wert von Zahl = 1. Nachdem die Routine durchlaufen wurde, ist der Wert von Zahl=2.

10.2 Funktionen Funktionen sind einer Subroutine ganz ähnlich. Beide lagern Sourcecodes aus der Sub Main()-Routine aus, können von mehreren Stellen aus dem Sourcecode aufgerufen werden und mit bzw. ohne Parameterübergabe erstellt werden. Der wesentliche Unterschied ist, dass Subroutinen verwendet werden, um bestimmte Aktionen auszuführen. Ein Rückgabewert wird nicht erwartet. Funktionen führen ebenfalls bestimmte Aktionen aus, es wird jedoch ein Rückgabewert erwartet. Dieser Rückgabewert ist

76

Funktionen und Subroutinen

für eine Funktion nicht unbedingt erforderlich ist, dennoch gehört ein Rückgabewert zu den Charakteristika einer Funktion: 1 2 3

4 5

Dim Ergebnis As Integer Ergebnis = AddiereAB( 12, 6) Function AddiereAB (ByVal A As Integer,_ ByVal B As Integer) AS Integer AddiereAB = A + B End Function

Dies ist eine normale Funktion. Der Name der Funktion ist AddiereAB. Der Rückgabewert der Funktion ist vom Datentyp Integer. Als Parameter für die Funktion sind die beiden Integer-Werte A und B festgelegt. Die Aufgabe der Funktion ist leicht zu erkennen: Sie addiert zwei Zahlen. Das Ergebnis der Addition wird der Funktion als Rückgabewert zugewiesen. Indem wir dem Funktionsnamen einen Wert zuweisen (AddiereAB =), legen wir den Rückgabewert fest. Hier sehen Sie ein weiteres Beispiel: 1 2 3 4 5

Dim Ergebnis As Integer Ergebnis = ZufallsZahl( ) Function ZufallsZahl () AS Integer ZufallsZahl = int(Rnd() *9) End Function

Nun erkennen Sie, dass eine Funktion nicht unbedingt Parameter benötigt. Sie übernimmt eine bestimmte Aufgabe aus dem Sourcecode und liefert ein prägnantes Ergebnis zurück. Richtig sinnvoll werden Funktionen, wenn die Aufgaben wesentlich komplexer sind. Bei einzeiligen Aufgaben, wie in unseren Beispielen, machen sie wenig Sinn. 10.2.1 Return Es ist nicht immer sinnvoll, eine Funktion komplett zu durchlaufen. Manchmal möchte man die Funktion vorzeitig verlassen oder ein Fehler zwingt uns dazu. Um dennoch einen Rückgabewert zu bestimmen, gibt es die Return-Anweisung. 1 2 3 4 5 6

Function WieIstDerPreis(ByVal Preis As Double) As String Select Case Preis Case is > 1000 Return “Absolut überteuert” Case is > 500 Return “Geht so“

Funktionen 7 8 9 10

77

Case Else Return “Einmaliger Preis“ End Case End Function

Nachdem die Return-Anweisung ausgeführt wurde, wird die Funktion verlassen. Der restliche Sourcecode der Funktion wird nicht weiter ausgeführt. 10.2.2 Optionale Parameter Ein optionaler Parameter wird mit dem Schlüsselwort Optional gekennzeichnet. Diese Kennzeichnung verhindert eine Fehlermeldung, falls beim Funktionsaufruf der entsprechende Parameter nicht mit angegeben wird. Ein optionaler Parameter muss mit einem Standardwert (Defaultwert) angegeben werden. Wird der optionale Parameter ausgelassen, tritt der definierte Standardwert in Erscheinung. 1 2 3 4

5 6

7 8 9 10 11 12 13 14 15 16 17 18

Module Module1 Dim Ergebnis As Boolean Sub Main() Ergebnis = Adresse_ ("Mustermann", "Klaus", , "männlich") Console.ReadLine() End Sub Function Adresse( _ ByVal Nachname As String, _ ByVal Vorname As String, _ Optional ByVal Alter As String = "unbekannt", _ Optional ByVal Geschlecht As String = "unbekannt") Console.WriteLine("Vorname : " & Vorname) Console.WriteLine("Nachname : " & Nachname) Console.WriteLine("Alter : " & Alter) Console.WriteLine("Geschlecht: " & Geschlecht) Adresse = True End Function End Module

Die Ausführung dieses Codes führt zu der folgenden Bildschirmausgabe: Vorname Nachname Alter Geschlecht

: : : :

Klaus Mustermann unbekannt männlich

78

Funktionen und Subroutinen

In Zeile 4 wird die Funktion Adresse aufgerufen. Diese Funktion besitzt die optionalen Parameter Alter und Geschlecht. Das Alter ist uns unbekannt und der Parameter bleibt leer. Indem wir den Parameter nicht füllen, wird der Standardwert des Parameters (in unserem Fall unbekannt) verwendet. Dem Parameter Geschlecht übergeben wir den Wert männlich. Dieser wird auch bei der Auswertung des Parameters (Zeile 15) verwendet. Standardwerte sind eine sinnvolle Ergänzung eines optionalen Parameters. Ohne einen Standardwert erhöht sich die Fehleranfälligkeit einer Funktion. Als Beispiel können wir uns eine komplexe mathematische Funktion vorstellen. Sollte diese Funktion mit optionalen Parametern (ohne Standardwerte) arbeiten, so steigt das Risiko von ungültigen Rechenoperationen (z.B. Division durch null).

10.3 Rekursives Programmieren Wenn sich Funktionen oder Prozeduren selbst aufrufen, spricht man von rekursivem Programmieren. In der Regel finden diese Selbstaufrufe so lange statt, bis eine Bedingung erfüllt ist. Erst wenn die Bedingung oder auch mehrere erfüllt wurde, wird die Routine verlassen. Letztendlich werden Sie früher oder später auf programmtechnische Hürden treffen, die nur rekursiv gelöst werden können. Natürlich bringt eine Funktion, welche sich selbst aufruft, auch Gefahren mit sich. Wenn die Bedingungen, die zum Verlassen der Funktion führen, nicht definiert sind, haben wir eine klassische Endlosschleife, wie im nachfolgenden Negativbeispiel. 1 2 3 4 5

Sub SucheZahl() Dim Zähler As Integer If Zähler > 10 Then Exit Sub SucheZahl() End Sub

In Zeile 3 sehen Sie die Bedingung, die für das Verlassen der Routine verantwortlich ist. Da die Variable Zähler nie größer 10 sein wird, kann die Bedingung zum Verlassen der Routine nie erfüllt werden. Durch den Selbstaufruf der Prozedur in Zeile 4 die Prozedur selber aufruft, ergibt sich eine Endlosschleife. Ein beliebtes Beispiel für rekursive Programmierung ist die Berechnung der Fakultät von Zahl x. Hier sehen Sie die Fakultäten der ersten 5 Zahlen:

Rekursives Programmieren 0 1 2 3 4 5

= = = = = =

79

1 1 2 6 24 120

Die Fakultät einer Zahl n ist das Produkt von 1 bis n. Die Fakultät von 4 ist also 1*2*3*4 und das ist 24. Natürlich können wir diese Aufgabe mit einer For-Next-Schleife lösen, das würde jedoch nicht der Definition einer Fakultät entsprechen: n! = n * (n –1)!

n! wird n Fakultät gesprochen. Die Definition lautet: Die Fakultät zu einer Zahl ist das Produkt der natürlichen positiven Zahlen von 1 bis n. Dabei gilt: 0! = 1; 1! = 1. Hier sehen Sie die benötigte Funktion: 1 2 3 4 5 6 7 8 9 10

Function Fakultät(ByVal Zahl As Long) As Double Select Case Zahl Case 0 Fakultät = 1 Case 1 Fakultät = 1 Case 2 To 170 Fakultät = Zahl * Fakultät(Zahl - 1) End Select End Function

Wir haben Zahl auf 170 begrenzt, da die Fakultät einer Zahl größer 170 von VB.NET nicht dargestellt werden kann. VB.NET würde das Ergebnis als unendlich interpretieren. Die Fakultät von 170 ist 7,25741561530799E+306.

11 Klassen

Objektorientiertes Programmieren ist ein modernes Schlagwort. Woher stammen die Objekte, welche zu einer objektorientierten Programmierung gehören? Hierzu müssen wir uns mit den Klassen beschäftigen. Klassen bilden eine Art Baukasten für Objekte. Von einer Klasse werden Objekte abgeleitet, die auch Instanzen einer Klasse genannt werden. Klassen beinhalten die Informationen, die benötigt werden, um ein Objekt zu erzeugen, also einen Speicherbereich zu belegen. So ist es möglich, dass von einer Klasse mehrere Objekte instanziert (erzeugt) werden. Das ist immer dann hilfreich, wenn wir Dinge mit gleichen Eigenschaften verwalten wollen.

11.1 Was ist eine Klasse? Eine Klasse ist ein Element, welches ein Assembly erweitert. Diese Erweiterung wird von der CLR (Common Language Runtime) als neuer Typ erkannt und als solcher behandelt. Eine Klasse wird somit als Datentyp betrachtet. Dennoch bestehen wesentliche Unterschiede zu einem normalen Datentyp. Klassen zeichnen sich durch folgende Merkmale aus: • Klassen können Eigenschaften enthalten. • Klassen können Funktionen enthalten. • Klassen können Strukturen enthalten. Im Programmlisting beginnt eine Klasse mit dem Class-Befehl und endet mit dem End-Class-Befehl. Innerhalb des Sourcecodes dürfen beliebig viele dieser Abschnitte enthalten sein. 1 2 3

Class MeineKlasse … End Class

82

Klassen

Das ist alles. Mit diesen beiden Zeilen erstellen Sie eine neue Klasse. Das Thema wird noch etwas komplizierter. Schließlich wollen wir Eigenschaften, Funktionen und Strukturen integrieren. Zuvor haben wir behauptet, dass ein Objekt von einer Klasse abgeleitet wird. Es wird eine neue Instanz gebildet. Dies geschieht mit dem Schlüsselwort New, wie im folgendem Beispiel: Dim MeineVariable1 As New MeineKlasse Dim MeineVariable2 As New MeineKlasse

Wenn wir die beiden Instanzen MeineVariable1 und MeineVariable2 genauer betrachten, stellen wir fest, dass sie identisch sind. Nun wird ersichtlich, welche starke Bedeutung den Klassen zukommt. Instanzen mit identischen Eigenschaften sind eine echte Hilfe in der täglichen Programmierung. Insbesondere, wenn die Klassen in separate Files ausgegliedert werden, können diese Files in neue Projekte importiert werden und stehen dort sofort im vollen Umfang zur Verfügung. Zurzeit ist unsere Klasse noch völlig sinnlos. Es fehlt der Inhalt. Die Inhalte einer Klasse werden auch Mitglieder genannt und setzen sich wie folgt zusammen: • • • • •

Felder (Variablen oder Konstanten) Eigenschaften Funktionen Events Enumerationen

11.2 Nothing Frisch deklarierte Variablen vom Typ einer Klasse sind am Anfang vom Typ Nothing. Das bedeutet, dass der Variablen noch keine Referenz zugewiesen wurde. Natürlich können wir einer Variablen den Wert auch direkt zuweisen: MeineVariable1 = Nothing

Solch eine Zuweisung würde eine eventuell bestehende Referenz löschen. Über den Is-Operator können wir hinterfragen, ob eine Variable den Wert Nothing aufweist:

Felder

83

If MeineVariable1 Is Nothing then

Diese Abfrage ist von einiger Bedeutung. Falls Sie auf eine Variable mit dem Wert Nothing zugreifen, wird das von VB.NET mit einer Ausnahme quittiert. Bevor wir den Spezialwert Nothing abschließen, möchten wir noch zwei Punkte klären. • Nothing ist nicht gleich null (0) Viele Einsteiger verwechseln den Ausdruck Nothing mit dem Wert 0. Das ist nicht richtig. Nothing drückt eine fehlende Referenz aus. Null (0) oder „“ (leere Zeichenkette) bei einem String, stellen an sich bereits einen Wert dar. Einer Variablen, der wir den Wert Null zuweisen können, besitzt auch eine Referenz, einen Datentypen. • Nothing ist nicht gleich löschen Oftmals wird angenommen, wenn wir eine Variable auf Nothing setzten, wird die Variable aus dem Arbeitsspeicher entfernt. Das ist nicht der Fall. Die Common Language Runtime allein entscheidet darüber, wann der Arbeitsspeicher bereinigt wird. Der Zeitpunkt wird allein von der CLR festgelegt.

11.3 Felder Wir erweitern unsere Klasse um zwei Variablen: 4 5 6 7

Class MeineKlasse Dim PrivateVariable As String Public ÖffentlicheVariable As String End Class

Wenn wir nun auf die Mitglieder der Klasse zugreifen wollen, werden wir feststellen, dass lediglich die Variable ÖffentlicheVariable angezeigt wird. Das liegt daran, weil eine Deklaration mit der Dim-Methode automatisch den Sichtbarkeitsbereich Private vergibt. PrivateVariablen sind außerhalb der Klasse nicht sichtbar. Die Alternative zu einer privaten Deklaration ist eine öffentliche Deklaration mit der Public-

84

Klassen

Methode. Mit Public deklarierte Variablen sind von überall sichtbar und können auch von überall und von jedermann verändert werden. 1 2 3 4 5 6

Sub Main() Dim MeineVariable1 As New MeineKlasse MeineVariable1.ÖffentlicheVariable = "Test" Console.WriteLine(MeineVariable1.ÖffentlicheVariable)

Console.ReadLine() End Sub

In Zeile 3 sehen Sie, wie wir auf das Mitglied ÖffentlicheVariable der Klasse MeineKlasse zugreifen können. Um keinen Zweifel an dem Sichtbarkeitsbereich der Deklarationen Private bzw. Public zu lassen, folgt die eindeutige Definition. Private. Eine als Private deklarierte Variable ist nur innerhalb der Klasse oder des Moduls sichtbar. Somit kann auch nicht von außen auf sie zugegriffen werden. Public. Eine als Public deklarierte Variable ist von überall sichtbar. Es existiert keine Einschränkung bezüglich eines Zugriffs von innen oder von außen. Neben den beiden vorgestellten Möglichkeiten, eine Variable zu deklarieren, existieren noch weitere Varianten. Die Unterscheidung zwischen Privat und Public ist bei der Deklaration von Variablen in einer Klasse aber die gebräuchlichste.

11.4 Subroutinen und Funktionen Eine Klasse kann auch Subroutinen und Funktionen enthalten. Im Sinne der objektorientierten Programmierung ist eine Subroutine bzw. Funktion auch gleichzeitig eine Methode. Die Implementierung von Subroutinen in eine Klasse ist eine leichte Aufgabe, wie im folgendem Beispiel zu sehen ist: 1 2 3 4

5

Module Module1 Class MeineKlasse Dim PrivateVariable As String Public ÖffentlicheVariable As String Sub WriteEinleitung()

Subroutinen und Funktionen 6

7

85

Console.WriteLine("Das ist die Einleitung zu _ unserem kleinen Klassenbeispiel!") End Sub

8

End Class

9

Sub Main() Dim MeineVariable1 As New MeineKlasse MeineVariable1.ÖffentlicheVariable = "Test" MeineVariable1.WriteEinleitung() Console.WriteLine(MeineVariable1.ÖffentlicheVariable) Console.ReadLine() End Sub

10 11 12 13 14 15

16

End Module

In Zeile 5 bis Zeile 7 sehen Sie die Subroutine (Methode) WriteEinleitung. Die Aufgabe dieser Methode ist es, ein paar einleitende Worte auf den Bildschirm zu schreiben. Jede Instanz der Klasse besitzt diese Methode. Hierdurch wird dem Programmierer erspart, den Text immer und immer wieder neu zu schreiben. In Zeile 12 finden Sie den Aufruf der Methode. Die Instanz unserer Klasse heißt MeineVariable1. Diese nutzen wir für den Aufruf der Methode WriteEinleitung. Hier sehen Sie das Ergebnis: Das ist die Einleitung zu unserem kleinen _ Klassenbeispiel! Test

Natürlich dürfen wir einer Methode auch Parameter übergeben. Auch optionale Parameter sind erlaubt. Diese benötigen jedoch einen Defaultwert. Hier finden Sie die Methode WriteBegrüssung: 1

2 3 4

Sub WriteBegrüssung(ByVal Name As String, _ Optional ByVal Alter As String = "unbekannt") Console.WriteLine("Hallo " & Name) Console.WriteLine("Das Alter ist: " & Alter) End Sub

Wenn wir für Name „Klaus Mustermann“ einsetzten und den zweiten optionalen Parameter Alter leer lassen, dann erhalten wir folgende Bildschirmausgabe: Hallo Klaus Mustermann Das Alter ist: unbekannt

86

Klassen

11.5 Eigenschaften: Property Um einen wichtigen Vorteil einer Property zu erkennen, können wir uns einen Nachteil eines Feldes (einer Variablen) anschauen. Wenn wir einer Variablen einen Wert zuweisen, haben wir keine Möglichkeit, diese Zuweisung zu verhindern. Dies kann zu fatalen Fehlern führen, wenn wir einer Variablen einen Wert zuweisen, welcher ursprünglich im Programm nicht vorgesehen war. Dies kann auch durch die Zuweisung eines Wertes durch einen autonomen Prozess geschehen. Bei der Auswertung von Benutzereingaben können die skurrilsten Fehler auftreten, ein Zwischenergebnis kann von einem völlig losgelösten Modul berechnet werden Fehlerursachen gibt es viele. Kommen wir zurück zu unseren Properties. Der Gedanke liegt nahe, vor der Zuweisung von Werten die Werte zu prüfen oder nach der Zuweisung das ein oder andere zu erledigen. Hier sehen Sie ein Property-Beispiel: 1 2 3 4 5 6 7 8

Property Name() As String Get … End Get Set(ByVal Value As String) … End Set End Property

Der Aufbau einer Property ist einfach strukturiert. Nach dem Schlüsselwort Property folgt der Name der Property. In unserem Beispiel ist der Property-Name gleich Name. Die Property muss deklariert werden. Wir verwenden den Datentyp String zur Deklaration. Innerhalb der Poperty finden wir einen Get- sowie Set-Block. Der Get-Block wird verwendet, wenn der Wert der Property abgefragt wird. Der Set-Block ist für die Zuweisung eines Wertes vorgesehen. Hierbei übernimmt die private Variable Value eine temporäre Aufgabe. Nachdem wir den Aufbau einer Property kennen, füllen wir den Getund den Set-Block mit Inhalt. Zuvor ist aber noch eine Frage zu klären. Wir haben erkannt, dass eine Property Daten aufnehmen soll. Aber wo werden diese Daten gespeichert? Innerhalb der Property ist dies nicht möglich. Also muss die Speicherung außerhalb erfolgen. Dazu müssen wir eine Variable außerhalb der Property deklarieren. Diese Variable sollte wegen der Typensicherheit vom gleichen Datentyp sein wie die Property.

Eigenschaften: Property

87

Wir betrachten nun eine komplette Property-Deklarierung: 1 2 3 4 5 6 7 8 9

Dim pName As String Property Name() As String Get Return pName End Get Set(ByVal Value As String) pName = Value End Set End Property

Außerhalb der Property haben wir die Variable pName deklariert. Sie ist Empfänger und Speicher für die Property-Werte. Im Get-Block liefern wir den Wert von pName. Im Set-Block weisen wir pName einen Wert zu. Wir können in den Get- und in den Set-Block Sourcecode schreiben und so sicherstellen, dass keine ungültigen oder unsinnigen Werte in Umlauf gebracht werden: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Dim pName As String Property Name() As String Get Return pName End Get Set(ByVal Value As String) Select Case Value Case "" Console.WriteLine("Ungültiger Property-Wert") Exit Property Case Else pName = Value End Select End Set End Property

In Zeile 7 bis Zeile 13 nehmen wir eine Auswertung des übergebenen Wertes vor. Wird ein leerer String übergeben, folgt eine Fehlermeldung, ansonsten wird der String akzeptiert und in pName gespeichert. 11.5.1 Parameter in Properties Es ist möglich, einer Property einen Index zur Seite zu Stellen. Dies ist mitunter eine hilfreiche Erweiterung und wird in vielen Bereichen des .NET-Frameworks genutzt.

88

Klassen 1 2 3 4 5 6 7 8 9

10 11

12 13 14 15 16

Class MeineKlasse Dim pFarbe(2) As String Property Farbe(ByVal index As Integer) As String Get Return pFarbe(index) End Get Set(ByVal Value As String) pFarbe(index) = Value End Set End Property End Class Sub Main() Dim MeineVariable1 As New MeineVariable1.Farbe(0) = MeineVariable1.Farbe(1) = MeineVariable1.Farbe(2) =

MeineKlasse "Rot" "Grün" "Blau"

17 18 19 20

Console.WriteLine(MeineVariable1.Farbe(0)) Console.WriteLine(MeineVariable1.Farbe(1)) Console.WriteLine(MeineVariable1.Farbe(2))

21 22 23

Console.ReadLine() End Sub

In diesem Beispiel haben wir ein kleines Array deklariert. pFarbe() soll drei unterschiedliche Farbnamen aufnehmen. Die Farbnamen werden per Property erfasst. Wenn wir eine Farbe zuweisen wollen, geben wir die Position im Array an und übergeben anschließend den Namen der Farbe. Siehe hierzu die Zeilen 14 - 16. Um eine Farbe abzufragen, müssen wir lediglich noch die Position im Array benennen (Zeile 18 - 20). Auch zu diesem Beispiel sehen wir uns die Bildschirmausgabe an. Rot Grün Blau

11.5.2 Eingeschränkte Properties Es ist nicht immer notwendig, dass eine Property eine Lese- und Schreibeigenschaft besitzt. Wir können eine Property auch einschränken. Zu diesem Zweck gibt es die Schlüsselwörter ReadOnly und WriteOnly. ReadOnly. Eine Property, die als ReadOnly deklariert wurde, kann nur einen Wert wiedergeben.

Enumerationen in Klassen

1 2 3 4 5

89

ReadOnly Property Datum() As Date Get Return System.DateTime.Now End Get End Property

WriteOnly. Dahingegen können als WriteOnly deklarierten Properties nur Werte zugewiesen werden. 1 2 3 4 5 6

Dim pErlaubnis As Boolean WriteOnly Property Erlaubnis() As Boolean Set(ByVal Value As Boolean) pErlaubnis = Value End Set End Property

11.6 Enumerationen in Klassen Das Thema der Konstantenliste (Enumerationen) ist schnell erklärt. Eine Enumeration in einer Klasse unterscheidet sich nicht von einer Enumeration in einem Modul. Zu erwähnen ist lediglich der Sichtbarkeitsbereich. Eine normal angelegte Auflistung ist außerhalb der Klasse sichtbar. 1 2 3 4 5 6 7

8 9 10 11 12

Enum Farben Rot = 1 Grün = 2 Blau = 4 Weiß = 8 Schwarz = 16 End Enum Sub Main() Dim MeineVariable1 As New MeineKlasse Console.WriteLine(MeineVariable1.Farben.Grün) Console.ReadLine() End Sub

Soll die Enumeration lediglich intern eingesetzt werden, müssen wir das Schlüsselwort Private verwenden. 1 2 3 4 5

Private Enum Farben Rot = 1 Grün = 2 Blau = 4 Weiß = 8

90

Klassen 6 7

Schwarz = 16 End Enum

Mit dem Schlüsselwort Private ausgelegte Enumerationen können wir außerhalb der Klasse nicht nutzen. Beachten Sie, dass das Schlüsselwort Shared für eine Enumeration ungültig ist.

11.7 Events In Klassen lassen sich beliebige Ereignisse deklarieren. Diese können dann aufgerufen oder ausgelöst werden. Zur Erzeugung eines Events benötigen wir lediglich eine Zeile. Diese muss jedoch mit dem Schlüsselwort Event verbunden sein. Ein Ereignis wird in allen Klassen ausgelöst, in denen die Klasse instanzirt wurde, in der das Ereignis eingebunden ist. Zur Demonstration haben wir einen kleinen Auktionsassistenten programmiert. Dieser soll verhindern, dass Sie zu viel bieten. Alles was über und höher 100 € liegt, wird als „zu hoch“ bewertet. Unser Auktionsassistent ist eine Klasse. 1 2 3 4 5 6 7 8

9 10 11 12 13 14

Module Module1 Class AuktionsAssistent Event ZuTeuer(ByVal Preis As Double) Public Sub Bieten(ByVal Preis As Double) Select Case Preis Case Is 0 Then intAlter = Value Else MsgBox("Das Alter ist falsch angegeben!") End If End Set End Property End Class

Der Rest der Klasse (Zeile 11 - 77) beherbergt die notwendigen Properties. Bis Zeile 54 handelt es sich um ganz normale Properties. Aber in den Zeilen 56 - 63 legen wir die Eigenschaft für die Anrede fest. Als Datentyp

Ein umfassendes Beispiel

95

wählen wir die Enumeration aus Zeile 6. Nur so haben wir später eine komfortable Dateneingabe. In den Zeilen 65 - 76 definieren wir die Property für das Alter. Hier nehmen wir einen Kausalitätstest vor. 129 Jahre geben wir als maximales Alter an. Sollten Sie einen größeren Wert zuweisen, erhalten Sie eine Fehlermeldung. 11.8.2 Klasse mit Daten füllen Nach der Festlegung der einzelnen Eigenschaften der Klasse füllen wir diese jetzt mit Daten. 78 79 80 81 82 83 84 85 86 87 88

Sub Main() Dim Adresse As New Adresse Dim tmpAnrede As String With Adresse .Alter = 38 .Anrede = Adresse.enumAnrede.Herr .Name = "Mustermann" .Vorname = "Hans" .Straße = "Musterstraße 123" .PLZ = "12345" .Ort = "Musterhausen"

Die Klasse ist schnell mit Daten gefüllt. Wir richten unser Augenmerk auf die Zeile 83. Hier zeigt sich der Vorteil der Enumeration. Komfortabel dürfen wir die Anrede per Pulldown-Menü auswählen. Wir haben uns für die Anrede Herr entschieden. Beachten Sie, dass Sie im Sourcecode den Text Herr sehen, sich dahinter jedoch der Wert 2 verbirgt. So ist es in der Enumeration (Zeile 8) festgelegt. 11.8.3 Daten aus der Klasse lesen Nachdem wir die Klasse mit Daten gefüllt haben können wir jetzt mit der Auswertung der Daten beginnen. 89 90 91 92 93 94 95 96

Select Case .Anrede Case .Anrede.Frau tmpAnrede = "Frau" Case .Anrede.Herr tmpAnrede = "Herr" Case .Anrede.Dr tmpAnrede = "Dr." End Select

96

Klassen

Im vorausgehenden Abschnitt haben wir darauf hingewiesen, dass wir die Werte der Enumeration interpretieren müssen. Beim Auslesen der Anrede erhalten wir den Wert 2. Jetzt müssen wir wissen, was der Wert bedeutet. Die Auswertung erfolgt mittels Select-Case-Anweisung. 97 98 99 100 101

102 103 104 105 106 107

Console.WriteLine("Anrede : " & tmpAnrede) Console.WriteLine("Name : " & .Name) Console.WriteLine("Vorname : " & .Vorname) Console.WriteLine("Straße : " & .Straße) Console.WriteLine("PLZ : " & .PLZ & _ " Ort : " & .Ort) Console.WriteLine("") Console.WriteLine("Press Enter to exit.") End With Console.ReadLine() End Sub End Module

Am Ende der Routine werden nun die Daten nur noch auf der Console dargestellt.

11.9 Shared-Mitglieder Über das Schlüsselwort Shared wird ein Mitglied einer Klasse als freigegeben deklariert. Auf dieses Mitglied kann zugegriffen werden, ohne dass die Klasse an sich instanziert wurde. Das Besondere ist, dass dieses Mitglied jeder Instanz der Klasse zur Verfügung steht. 1 2 3 4

5 6

7

8

9 10 11

Class MeineKlasse Public ÖffentlicheVariable As String Public Shared SharedVariable As String End Class Sub Main() Dim MeineVariable1 As New MeineKlasse MeineVariable1.ÖffentlicheVariable = _ „Öffentliche Variable“ MeineKlasse.SharedVariable = „SharedVariable“ ConsoleWriteLine(MeineVariable1.ÖffentlicheVariable) ConsoleWriteLine(MeineVariable1.SharedVariable) End Sub

Vererbung

97

Betrachten wir zunächst die Klasse in den Zeilen 1 – 4. Bei genauerer Betrachtung sehen wir in Zeile 3 das Schlüsselwort Shared. Welche Auswirkungen dieses Schlüsselwort hat, merken wir in Zeile 8. MeineKlasse.SharedVariable = „SharedVariable“

Hier weisen wir dem Mitglied SharedVariable der Klasse MeineKlasse einen Wert zu. Bei dieser Zuweisung greifen wir direkt auf die Klasse zu, ohne den Umweg über eine Instanz. Das können wir in Zeile 7 erkennen. MeineVariable1.ÖffentlicheVariable = _ „Öffentliche Variable“

In Zeile 10 wollen den Inhalt des Klassenmitglieds SharedVariable auf den Bildschirm ausgeben. Sie erinnern sich, dass wir diesem Mitglied durch einen direkten Zugriff einen Wert zugewiesen haben. Nun wollen wir den Wert über den Umweg einer Instanz (MeineVariable1) abfragen. Die Instanz hat den Wert von der direkten Zuweisung übernommen, da Shared-Mitglieder in allen Instanzen verfügbar sind.

11.10

Vererbung

Vererbung ist eine Grundlage für echte objektorientierte Programmierung. Sie mag Ihnen überflüssig vorkommen, denn auch mit den vorherigen Versionen von Visual Basic wurden gute Programme ohne Vererbung erstellt. Die großen Möglichkeiten, die durch Vererbung erzielt werden, können wir mit Hilfe eines Beispiels am besten erkennen. Wir werden zwei kleine Klassen erstellen. Beide Klassen beinhalten Properties. Die Properties der ersten Klasse werden der zweiten Klasse vererbt. Das bedeutet, dass die Properties der ersten Klasse der zweiten zur Verfügung stehen. 1 2 3

4 5 6 7 8

Module Module1 Class Position Dim dblPositionX, dblPositionY, _ dblPositionZ As Double Property PositionX() As Double Get Return dblPositionX End Get Set(ByVal Value As Double)

98

Klassen 9

10 11

12 13 14 15 16 17 18 19

20 21 22 23 24 25 26 27 28

dblPositionX = Value End Set End Property Property PositionY() As Double Get Return dblPositionY End Get Set(ByVal Value As Double) dblPositionY = Value End Set End Property Property PositionZ() As Double Get Return dblPositionZ End Get Set(ByVal Value As Double) dblPositionZ = Value End Set End Property End Class

Unsere erste Klasse heißt Position. Das ist eine einfache Klasse, deren Aufgabe es ist, Koordinaten zu speichern. Hierbei ist es nicht von Bedeutung, ob diese Koordinaten die Position eines Spielers, Autos oder einer Sonde in der Umlaufbahn angeben. Es wäre nicht sinnvoll, in den Klassen Spieler, Auto und Sonde die Koordinaten-Properties mitzuschleifen. Erstellen Sie eine einzige Klasse und übertragen Sie ihre Eigenschaften auf andere Klassen. Das ist im Prinzip das Geheimnis der Vererbung. 29 30

31

32 33 34 35 36 37 38 39 40

Class Spieler Inherits Position Dim intLebensenergie As Integer Property Lebensernergie() As Integer Get Return intLebensenergie End Get Set(ByVal Value As Integer) intLebensenergie = Value End Set End Property End Class

Diese Übertragung setzen wir jetzt ein. In Zeile 30 sehen Sie die Inherits-Anweisung. Inherits bewirkt, dass eine Klasse Attibute, Felder, Eigenschaften, Methoden und Ereignisse von einer anderen Klasse erbt.

Vererbung

99

Nachdem die Klasse Spieler die Properties der Klasse Position geerbt hat, stehen der Klasse Spieler folgende Properties zur Verfügung: • • • •

PositionX PositionY PositionZ Lebensenergie 41 42 43 44 45 46

--> --> --> -->

geerbt geerbt geerbt eigene Property

Sub Main() Dim Spieler1 As New Spieler Spieler1.PositionX = 123.23 Spieler1.PositionY = 0 Spieler1.PositionZ = 12.334567 Spieler1.Lebensernergie = 72

Wenn wir die Klasse mit Daten füllen, bemerken wir keinen Unterschied zwischen den Properties, welche geerbt oder direkt in der aufgerufenen Klasse deklariert wurden.

53

Console.WriteLine("Daten von Spieler1:") Console.WriteLine("PositionX: " & Spieler1.PositionX) Console.WriteLine("PositionY: " & Spieler1.PositionY) Console.WriteLine("PositionZ: " & Spieler1.PositionZ) Console.WriteLine("Lebensenergie: " & _ Spieler1.Lebensernergie & " %") Console.ReadLine() End Sub

54

End Module

47 48 49 50 51

52

Auch beim Auslesen der Daten können wir keinen Unterschied feststellen. Die Bildschirmausgabe hat folgendes Aussehen: Daten von Spieler1: PositionX: 123,23 PositionY: 0 PositionZ: 12,334567 Lebensernergie: 72%

11.10.1 Overrides Bei Vererbung sprechen wir von einer Kindklasse und einer Elternklasse. Die Kindklasse erbt die Fähigkeiten der Elternklasse. Haben beide Klassen eine Methode mit gleichem Namen, muss eine Methode die Vorherrschaft übernehmen. Die Methode in der Elternklasse wird also durch das Schlüs-

100

Klassen

selwort Overridable zum Überschreiben freigegeben. Die Kindklasse wird durch das Schlüsselwort Overrides gekennzeichnet und erhält so die Information, dass sie die Methode in der Elternklasse überschreiben kann. 1 2

Module Module1 Class Elternklasse

3 4 5 6

Public Overridable Sub Identify() Console.WriteLine("Das ist die Elternklasse") End Sub

7 8

End Class

In Zeile 4 beginnt die Subroutine Identify(). Diese ist mit dem Overridabel-Flag gekennzeichnet. Die Klasse weiß, dass die Methode überschrieben werden darf. 9 10

Class Kindklasse Inherits Elternklasse

11 12 13 14

Public Overrides Sub Identify() Console.WriteLine("Das ist die Kindklasse") End Sub

15 16

End Class

In Zeile 12 finden wir die Methode Identify(). Es existiert jedoch eine Methode mit gleichem Namen in der geerbten Elternklasse. Um einen Konflikt zu vermeiden, erlauben wir der Kinderklasse das Überschreiben mit dem Schlüsselwort Overrides. 17

Sub Main()

18 19 20 21

Dim meineKlasse As New Kindklasse meineKlasse.Identify() Console.ReadLine()

22 23

End Sub

24 25

End Module

In Zeile 20 rufen wir die Subroutine Identify() auf. Diese Methode soll die Klasse identifizieren. Das Ergebnis erkennen Sie an der Ausgabe des Programms: Das ist die Kindklasse

Vererbung

101

11.10.2 MyBase Mit MyBase können Sie auf Mitglieder der Basisklasse zugreifen. Die Basisklasse ist in unserem vorherigen Beispiel die Elternklasse. In der Elternklasse haben wir eine Methode mit dem Namen Identify. Der gleiche Name existiert in der Kindklasse. Wir haben außerdem festgelegt, dass die Methode Identify der Elternklasse durch die Methode Identify der Kindklasse überschrieben werden soll. Eigentlich ist die Methode in der Elternklasse damit verloren. Durch MyBase können Sie die Methode Overridable Sub Identify aus der Elternklasse erhalten. 1 2 3 4 5 6

Module Module1 Class Elternklasse Public Overridable Sub Identify() Console.WriteLine("Das ist die Elternklasse") End Sub End Class

7 8 9 10 11 12

Class Kinderklasse Inherits Elternklasse Public Overrides Sub Identify() Console.WriteLine("Das ist die Kindklasse") End Sub

13 14 15 16 17

Public Sub WerSindMeineEltern() MyBase.Identify() End Sub End Class

In Zeile 14 bilden wir eine neue Subroutine mit dem Namen WerSindMeineEltern(). Diese Methode greift auf die Methode Identify der Elternklasse zu. 18 19 20 21 22 23 24

Sub Main() Dim meineKlasse As New Kindklasse meineKlasse.Identify() meineKlasse.WerSindMeineEltern() Console.ReadLine() End Sub End Module

In Zeile 21 rufen wir die Subroutine WerSindMeineEltern() auf und erhalten den Sourcecode aus der Elternklasse (Zeile 4).

102

Klassen

11.10.3 MustOverride und MustInherit Wir haben erfahren, dass wir mit Override Methoden überscheiben können und mit Inherit von einer Klasse erben können. Wir kommen nun zu den Schlüsselwörtern MustOverride und MustInherit. MustOverride gibt an, dass jedes Kind der Klasse seine eigenen Methoden mitbringen muss. Hiermit wird ein Überschreiben der Methoden der Elternklasse erzwungen. Mit MustInherit wird festgelegt, dass eine Klasse erben muss. Sie kann nicht allein verwendet werden.

12 Namespaces

Aufgaben von Namespace sind die Organisation, die Suche und das Schaffen von Strukturen. Die Klassenbibliotheken von .NET sind in Namespaces unterteilt. Ein ungeordneter Karton mit Fotos würde von Namespaces organisiert. Es würden Themen und Zeitspannen definiert und die Fotos dementsprechend geordnet. Im Kontext von Namespaces finden wir sinnverwandte Klassen. Einer der wichtigsten Namespaces heißt System. Für Visual Basic-Umsteiger ist der Namespace Microsoft. VisualBasic von Interesse. In diesem Namespace finden Sie Funktionen früherer Visual Basic-Versionen. Mit Hilfe des Objektbrowsers von Visual Studio erhalten Sie einen Überblick über die eingebundenen Namespaces und Klassen. Über den Menüeintrag Ansicht/Objektbrowser oder der Taste F2 öffnen Sie den Objektbrowser.

Abb. 22. Objektbrowser von Visual Studio.NET

104

Namespaces

Namespaces übernehmen folgende Aufgaben: • Sie erfassen Klassen in thematisch strukturierten Zusammenhängen. • Es wird eine eindeutige Hierarchie und Namensgebung gewährleistet. • Klassen dürfen den gleichen Namen besitzen, solange sie sich in unterschiedlichen Namespaces befinden.

12.1 Namespaces ansprechen Wir wissen, dass durch Namespaces Klassen zusammengefasst werden. Diese enthalten Funktionen, Strukturen oder Subroutinen. Um den Inhalt von Namespaces zu nutzen, müssen wir den vollständigen Pfad angeben. Nehmen wir an, dass wir den Wert von Pi (Mathematischer Wert: 3.1415926) benötigen. Hierzu gibt es in der Klasse Math die Konstante Pi, die wir nutzen wollen. • Falscher Zugriff auf PI: Dim Zahl As Double Zahl = PI

Wir wissen, dass es in der Klasse Math die Konstante PI gibt, aber woher weiß es unser Programm? • Richtiger Zugriff auf PI: Dim Zahl As Double Zahl = System.Math.PI

Indem wir den gesamten Pfad angeben, weiß Visual Studio.NET, wo nach der Konstante zu suchen ist. Hierdurch ermöglichen wir den direkten Zugriff auf die Konstante. 12.1.1 Imports Sie haben sich sicher die Klassen im Objektexplorer einmal angeschaut. Ihnen wird bestimmt auch die manchmal sehr lange Schreibweise einiger Klassen aufgefallen sein. Es wäre lästig, jedes Mal den gesamten Pfad einer Funktion angeben zu müssen, auch der Sourcecode würde unleserlich und schwer verständlich. Zur Lösung dieses Problems gibt es den Im-

Namespaces ansprechen

105

ports-Befehl. Mit seiner Hilfe wird ein Namespace in einem Programm bekannt gemacht. So bekommen wir einen direkten Zugriff auf die enthaltenen Klassen und Konstanten. Hierzu wollen wir uns auch ein Beispiel ansehen: 1

Imports System.Math

2

Module Module1

3 4 5 6 7 8 9 10 11

12

Sub Main() Dim Zahl As Double Zahl = System.Math.PI Zahl = PI Console.WriteLine("Der Wert von PI!") Console.WriteLine(" ") Console.WriteLine("Zahl: " & Zahl) Console.ReadLine() End Sub End Module

Das Ergebnis sieht wie folgt aus. Der Wert von PI! Zahl: 3,14159265358979

In Zeile 1 sehen Sie die Imports-Anweisung. Mit dieser Anweisung wird dem Programm der Kontext von System.Math bekannt gemacht. Hierdurch ist ein schneller Zugriff auf die Konstante PI möglich. In den Zeilen 5 und 6 weisen wir der Variablen Zahl den Wert der Konstante PI zu. Unser Augenmerk sollten wir besonders auf die Zeile 6 richten: Zahl = PI

Eine Seite zuvor war diese Zuweisung falsch. Nur indem wir den Kontext der Klasse Math publizieren, können wir diese kurze Schreibweise verwenden.

13 Assemblies

Unter einem Assembly versteht man alle Komponenten, die zu einer Anwendung gehören. Dies ist auch der Grund, weshalb man bei .NET nicht mehr so stark von Programmen spricht, sondern vielmehr von Assemblies. Wenn wir die kleinste Einheit eines Assemblies betrachten, besteht sie lediglich aus einer Exe- oder einer Dll-Datei. In diesem Fall können wir ein Assembly am treffendsten mit einem Programm im herkömmlichen Sinne vergleichen. Werden die Programme größer, gehört zu einem Assembly nicht nur die Exe-Datei, sondern alle notwendigen Komponenten. Das sind Klassenbibliotheken, Bilder, Webressourcen, Sounddateien usw. Wir können diese Dateien in einen Ordner packen und das Assembly ist fertig gestellt. Zwei wichtige Merkmale müssen aber noch erwähnt werden: • Assemblies sind pfadunabhängig. • Assemblies haben eine Versionsnummer. Insbesondere die Versionsnummer ist für die Zuordnung der CLR (Common Language Runtime) von Bedeutung, da Assemblies, anders als bei früheren VisualBasic-Versionen, selbsterklärend sind. Das bedeutet, sie sind auch unabhängiger von der Windows-Registrierung oder von SystemDLLs. In jedem Assembly ist ein Modul enthalten, welches ein allumfassendes Inhaltsverzeichnis enthält. Dieses wird Manifest genannt. Indem ein Assembly selbsterklärend ist, soll eine gewisse Kompatibilität oder auch Plattformunabhängigkeit gewährleistet werden. Folgender Gedanke steckt dahinter: Wenn sich das Assembly selbst erklärt, benötigen wir nur das passende Framework, um die Kompatibilität zu gewährleisten. Von welcher Plattform das Framework bereitgestellt wird, ist nebensächlich, wir können also von Plattformunabhängigkeit sprechen.

108

Assemblies

13.1 Arbeitsweise von Assemblies

Abb. 23. Assemblies

Aus dem Sourcecode erzeugt der Compiler das Assembly. Das Manifest enthält die Beschreibung des Assemblies. Es ermöglicht der CLR (Common Language Runtime) das Auffinden und Laden von Klassen, Erzeugen und Verwalten von Instanzen, systemeigenen Code zu erzeugen und Sicherheit und Laufzeitkontextgrenzen zu definieren.

13.2 Shared Assembly Neben den privaten Assemblies kennt das .Net-Framework noch Shared Assemblies. Shared Assemblies werden global verwendet und liegen im globalen Assembly Cache (GAC). Dieser systemweite Speicherbereich unterliegt strengen Sicherheitsmerkmalen. So ist eine Versionsprüfung durch die CLF für ein Shared Assembly Pflicht. Außerdem wird ein Strong Name vorausgesetzt. Ein Strong Name für ein Assembly unterliegt der Puplic-Key-Verschlüsselung und verhindert eine nicht autorisierte Manipulation. Anders sieht das bei den privaten Assemblies aus. Sie werden lokal gespeichert. Damit ist das Anwendungsverzeichnis oder ein Unterverzeichnis gemeint. Das Assembly an sich wird über einen einfachen Namen identifiziert. Ein Strong Name ist nicht notwendig.

14 Fehlerbehandlung

Dass ein Fehler, eine Ausnahme, auftritt und das Programm abstürzt, wird mit zunehmender Komplexität eines Programms oft nicht zu verhindern sein. Wir müssen deshalb einen Weg finden, mit diesem Fall vernünftig umzugehen. Nicht jeder Fehler muss zu einem Absturz führen und von vielen internen Fehlern muss der Anwender gar nichts mitbekommen. Eine vernünftige, strukturierte Ausnahmebehandlung ist ein Muss für jedes komplexe Programm und ist schnell und strukturiert in ein Programm zu implementieren.

14.1 Try-Catch-Finally-Anweisung Die Try-Catch-Finally-Anweisung ist eine Technik, mit der sich Visual Baisc 6-Umsteiger nicht so recht anfreunden wollen. Dabei ist das ein hervorragendes Mittel, sich einem Fehler entgegenzustellen. Sie haben gemerkt, dass wir die Begriffe Fehler und Ausnahme völlig synonym verwenden. Dies ist leicht zu erklären, denn in der .NET-Umgebung verzichtet man auf das unschöne Wort Fehler und verwendet stattdessen den Begriff Ausnahme. Wie funktioniert die strukturierte Ausnahmebehandlung mit der TryCatch-Finally-Anweisung? Try [ tryStatements ] [Catch[ exception [As type] ] [ When expression ] [ catchStatements ] ] [Exit Try ] ... [Finally [ finallyStatements ] ] End Try

110

Fehlerbehandlung

Try leitet die Überwachung eines Sourcecode-Blocks ein. Hierbei sind die tryStatements der zu überwachende Block, enthält die Anweisungen, in denen ein Fehler auftreten kann. Der Catch-Block (bzw. die Catch-Blöcke) wird immer dann ausgeführt, wenn es in dem Try-Block zu einer Ausnahme kommt. Die CatchBlöcke werden der Reihe nach abgearbeitet und der jeweils zur Ausnahme passende wird ausgeführt. Welcher Catch-Block zutreffend ist, wird durch die exception festgelegt. Wenn eine Catch- Block mit einer When-Klausel anfängt, wird dieser nur ausgeführt, wenn der Wert von expression = True ist. Eine When-Klausel ist nur dann gültig, wenn der Typ der Ausnahme geprüft wurde. Exit Try ist eine Abzweigung aus einem Catch-Block. Die Ausführung wird mit dem Finally-Block fortgeführt. Dies geschieht natürlich nur, wenn der Finally-Block vorhanden ist. Sonst wird mit der Ausführung des normalen Sourcecodes fortgefahren. End Try schließt die Ausnahmebehandlung. Variablen, welche in einem Try-Block als private deklariert wurden, sind in den Catch-Blöcken nicht verfügbar. Falls die Variablen blockübergreifend eingesetzt werden sollen, müssen sie entweder als Public oder außerhalb der Try-Catch-Finally-Anweisung deklariert werden. 14.1.1 Ausnahmebehandlung (Beispiel) Für unser Beispiel haben wir eine arithmetische Operation gewählt, die mit Sicherheit einen Fehler verursacht. „Division durch null“ ist eine beliebte Fehlerquelle im Sourcecode. 1 2 3 4 5 6 7 8 9 10

Module Module1 Sub Main() Try Dim intZahl1, intZahl2 As Integer intZahl1 = 0 intZahl2 = 12 / intZahl1 Console.WriteLine(intZahl2) Console.ReadLine() Catch ex As Exception MsgBox(ex.Message)

OnError-GoTo-Befehl 11 12 13

111

End Try End Sub End Module

Wir möchten in diesem Beispiel eine Zahl dividieren und das Ergebnis auf dem Bildschirm ausgeben. Nachdem die Division durch null zu einer Ausnahme geführt hat, tritt der Catch-Block in Aktion. Es wird per MessageBox eine Meldung ausgegeben. An dieser Stelle möchten wir Sachverhalt klarstellen: In Zeile 6 wird eine arithmetische Operation durchgeführt. Diese Operation findet statt, Unabhängig davon, ob wir eine Ausnahmebehandlung darum herum gestrickt haben oder nicht. Mit der Try-Catch-Finally-Anweisung können wir nicht verhindern, dass ein Fehler passiert, aber wir können auf den Fehler reagieren. Entfernen Sie einmal die Try-Catch-FinallyAnweisung aus unserem Beispiel und lassen Sie die Division durch null übrig. Sie werden erkennen, wie hilfreich eine Ausnahmebehandlung sein kann.

14.2 OnError-GoTo-Befehl Die folgenden Ausführungen sind für Visual Basic 6-Umsteiger gedacht: Der OnError- GoTo-Befehl ist in VB.NET erhalten geblieben. In der Visual Baisc.NET-Hilfe wird diese Variante jedoch als unstrukturiert bezeichnet, weil sie sich auf das Ausnahmehandling der Common Language Runtime verlässt. Lösen Sie sich von dieser alten Technik, die TryCatch-Finally-Anweisung wird die Ausnahmebehandlung Ihrer Projekte verbessern.

15 Was ist DirectX

Ende 1995 wurde DirectX von Microsoft eingeführt. Zur damaligen Zeit war es faktisch nicht möglich, anspruchsvolle Spiele in einer WindowUmgebung zu spielen. MS-DOS-Anwendungen dominierten den Spielebereich. Andererseits bot Windows einige Vorteile, welche unter MS-DOS verloren gingen. Die größte Schwäche von Windows war es, nicht direkt auf die Hardware zugreifen zu können. DirectX ist ein Application Programming Interface (API) um auf die Multimediahardware eines Systems beschleunigt, direkt und einheitlich zugreifen zu können. Blicken wir noch etwas in die Vergangenheit, denn hier liegen die Wurzeln von DirectX. 1995 fand ein Wandel statt. Die PCs wurden immer schneller und die Grafikkarten immer leistungsfähiger. Es war nunmehr möglich, multimediale Anwendungen zu entwickeln. Hinzu kam ein neues Betriebssystem. Die Multitasking-Fähigkeit sowie die zentrale Hardwareverwaltung machten dieses Betriebssystem dem bisher dominierenden MSDOS weit überlegen. Insbesondere die zentrale Hardwareverwaltung ebnete den Weg für DirectX. Musste ein Programm unter MS-DOS noch selber für die Unterstützung verschiedenster Hardware sorgen, so wurde das unter Windows 95 von zentraler Stelle organisiert. Nachdem die Hardwareverwaltung von Windows übernommen wurde, ist es fast schon selbstverständlich, dass das Betriebssystem auch das Recht zum direkten Hardwarezugriff besitzt.

15.1 Die Säulen von DirectX DirectX ist in verschiede Bereiche unterteilt. Jeder Bereich ist einem Fachgebiet gewidmet und könnte als Säule betrachtet werden, die das Gesamtbauwerk DirectX trägt. Wir werden nicht alle Bereiche durchleuchten. Einige Bereiche sind für sehr spezielle Aufgaben gedacht, die letztendlich nicht in ein Einsteigerbuch gehören. Schwerpunkt unserer Betrachtungen wird die Grafikschnittstelle DirectX Graphics sein. Dieses Thema weckt das größte Interesse und ist absolut notwendig, wenn man sich mit der

114

Was ist DirectX

Spieleprogrammierung beschäftigt. Nachfolgend werden neben DirectX Graphics noch weitere Bereiche von DirectX, die von Interesse sind, kurz erläutert. DirectX Graphics. Unter DirectX Graphics verstehen wir die Kombination von Direct Draw und Direct3D (D3D). Direct Draw ist in der aktuellen DirectX-Version nicht mehr als eigenständiger Punkt enthalten, vielmehr ist es in DirectX Graphics eingeflossen. Natürlich wir mit DirectX Graphics die Grafikprogrammierung fokussiert. Ebenfalls enthalten sind die Direct3D-Erweiterungen (D3DX). DirectInput. Das DirectInput Objekt erlaubt uns auf alle möglichen Eingabegeräte zuzugreifen und auf deren Eingaben zu reagieren, dazu gehören die Maus-, die Tastatur- und die Joystickeingabe. Bei der Arbeit mit einem Joystick oder ähnlichen Eingabegeräten kommen zusätzlich noch die Vorzüge der Force-Feedback-Technologie hinzu. Außer der generellen Kommunikationsmöglichkeit mit den Geräten bietet DirectInput einen Geschwindigkeitsvorteil gegenüber der normalen Windows-Eingabeverarbeitung. Zusätzlich bietet DirectInput noch mit der ActionMappingTechnik die Möglichkeit, unabhängig von der Eingabequelle eine Funktion auszuführen. DirectPlay. DirectPlay ist eine weitgehend unabhängige Programmierschnittstelle, die Netzwerkoptionen auf Transportprotokollebene zur Verfügung stellt. Dabei ist sie unabhängig vom Protokoll der Netzwerkverbindung des Systems. Die Hauptaufgabe von DirectPlay ist die Kommunikation zwischen Programmen bzw. Spielen über das Netzwerk. Dazu stellt die Schnittstelle zahlreiche Objekte und Funktionen zur Verfügung. DirectSound. Mit DirectSound haben wie die Audiodaten fest im Griff. Sounds miteinander zu mischen stellt kein Problem dar. Wir haben die Möglichkeit, Audiodaten in verschiedenen Formaten zu laden und abzuspielen. Dabei ist es kein Problem, mehrere Sounds parallel wiederzugeben und mit Hilfe von Effekten zu verändern. DirectSound bietet weiterhin Funktionen zur Aufnahme von Sounds von Mikrofonen oder anderen Aufnahmequellen. Ein weiteres Feature von DirectSound ist die dreidimensionale Wiedergabe von Soundobjekten in einer 3D-Umgebung mit Hilfen der 3D-Sound-Funktionen. DirectSound ist dabei einen unabhängige Schnittstelle im DirectX-Framework und kann auch außerhalb der DirectX Graphics Programmierung eingesetzt werden.

Die Einsatzgebiete für DirectX

115

DirectMusic. Mit dem DirectMusic-Producer können Sie Stücke komponieren und anschließend über DirectMusic abspielen. Generell bietet DirectMusic die gleiche Funktionalität wie die DirectSound-Schnittstellen, zusätzlich stellt DirectMusic aber noch umfassende Möglichkeiten und Hilfen bei der Produzierung von Musikstücken und deren anschließender Weiterverarbeitung bereit. Da wir für die Spieleprogrammierung diese Möglichkeiten aber nicht benötigen werden wir auf diese Option im weiteren Verlauf des Buches nicht näher eingehen. DirectShow. Diese Komponente kümmert sich um eine qualitativ hochwertige multimediale Aufnahme und Wiedergabe. Sie unterstützt die meisten gängigen Stream-Formate und bietet Möglichkeiten zur Aufnahme von Audio-Video-Streams von verschiedenen Hardwarekomponenten. Dabei erlaubt diese Schnittstelle zwischen den verschiedenen Formaten zu konvertieren und diese zu bearbeiten. DirectShow ist die Schnittstelle, die bei der Progammierung von DVD-Playern und Video-Schnittsystemen zum Einsatz kommt. Aus diesem Grund werden wir dieses Thema nicht näher erörtern, da diese Techniken erst bei fortgeschrittenen Spielprojekten zum Einsatz kommen. DirectSetup. Last but not least ist noch das DirectSetup-Objekt zu nennen. Mit Hilfe dieser API wird eine leichte Installation von DirectXKomponenten ermöglicht. Das Objekt überprüft die aktuellen WindowsEinstellungen und installiert je nach bedarf die nötigen Treiber und Komponenten, um die optimale Funktion von DirectX sicherzustellen.

15.2 Die Einsatzgebiete für DirectX Die Einsatzgebiete von DirectX sind vielfältig. Wann Sie DirectX einsetzen sollen oder wann Sie auf einen Einsatz besser verzichten, hängt vom Charakter Ihrer Applikation ab. Die meisten kaufmännischen Programme benötigen kein DirectX. In vielen Fällen wäre auch davon abzuraten. Warum sollten Sie eine Datenbankanwendung mit Multimediakomponenten ausstatten. Zusätzlicher Sourcecode schafft automatisch einen höheren Pflegeaufwand. Sie werden mehr Zeit zur Entwicklung benötigen und Sie werden eine längere Testphase brauchen. Andererseits könnten Sie Ihrer Anwendung einen gewissen Pep verpassen. Das gewisse Etwas, welches Ihr Programm aus der Masse der Datenbankanwendungen heraushebt. Vielleicht wäre ja eine dreidimensionale Menüführung für eine Datenbankanwendung genau das Richtige.

116

Was ist DirectX

Letztendlich müssen Sie entscheiden, welchen Charakter Ihr Programm haben soll. DirectX gibt Ihnen den notwendigen Spielraum, um diese Entscheidung treffen zu können.

16 DirectX-Grundlagen

16.1 Das Koordinatensystem DirectX verwendet das kartesische Koordinatensystem. Hierbei unterscheidet man das linkshändige und das rechtshändige Koordinatensystem.

Abb. 24. Kartesisches Koordinatensystem (linkshändig und rechtshändig)

Anhand der Abbildung können Sie erkennen, wie die Koordinatensysteme zu ihren Namen gekommen sind. Die Ausrichtung des Daumens beschreibt die Ausrichtung der Z-Achse. DirectX verwendet das linkshändige Koordinatensystem. Es ist aber auch möglich, eine DirectX-Anwendung auf das rechtshändige Koordinatensystem zu übertragen. Wir kennen jedoch keinen schlüssigen Grund, weshalb Sie das tun sollten. Falls Sie das dennoch möchten, sollten Sie Folgendes beachten: Eine Welt in DirectX wird aus Polygonen konstruiert. Polygone bedeutet eigentlich Vieleck. Im 3D-Bereich ist damit in der Regel ein Dreieck gemeint. Wenn wir also im weiteren Verlauf des Buches von Polygonen reden, meinen wir Dreiecke. Ein Polygon besteht also in unserm Fall aus drei Eckpunkten. Bei dem linkshändigen Koordinatensystem würden die Eckpunkte, betrachtet von der Rückseite, im Uhrzeigersinn angeordnet. Eckpunkte werden Vertices (Einzahl: Vertex) genannt. Somit würden die

118

DirectX-Grundlagen

Vertices V0, V1, V2 ein Polygon ergeben. Wenn Sie zum rechtshändigen Koordinatensystem wechseln, müssen Sie die Anordnung auf die Reihenfolge V0, V2, V1 umstellen.

Abb. 25. Polygon

Von vorne betrachtet, würden diese dann wieder im Uhrzeigersinn verlaufen, aus der Rückansicht (wie beim linkshändigen Koordinatensystem) würden sie gegen den Uhrzeigersinn laufen. Um die nächste Anpassung zu verstehen, müssen Sie wissen, dass Matrizen das Verhalten einer 3D-Welt bestimmen. Hierzu gibt es die D3DMatrix-Struktur. Diese ist wie folgt aufgebaut: D3DMatrix-Struktur. rc11 rc21 rc31 rc41

rc12 rc22 rc32 rc42

rc13 rc23 rc33 rc43

rc14 rc24 rc34 rc44

World-, View-, und Projektionsmatrix sind die Matrizen, welche zur Darstellung der 3D-Welt verwendet werden. Wenn Sie nun das rechtshändige Koordinatensystem verwenden, müssen Sie die Vorzeichen der Matrixmitglieder rc31, rc32, rc33 und rc34 aus der Viewmatrix tauschen. Entsprechend können Sie die einzelnen Mitgliedsdaten mit –1 multiplizieren. An dieser Stelle weisen wir darauf hin, dass alle vorgestellten Techniken und Beispiele auf dem linkshändigen Koordinatensystem beruhen. Wir werden das rechtshändige Koordinatensystem nicht unterstützen. Dies ist aber auch nicht notwendig. Die bevorzugte Ausrichtung ist das linkshändi-

Primitives

119

ge Koordinatensystem und diese Auffassung hat sich mittlerweile flächendeckend durchgesetzt.

16.2 Primitives Eine 3D-Welt wird aus Polygonen gebaut. Die Polygone bestehen aus Vertices. Primitives sind eine Sammlung von Vertices. Dies lässt den Umkehrschluss zu, dass Primitives eine Sammlung von Polygonen sind. Das ist im Grundsatz richtig, dennoch kennt DirectX eine noch einfachere Variante der Primitives. Eine so genannte PointList (Punktliste) ist eine Sammlung von Punkten aus dem 3D-Koordinatensystem. Wie wir am Anfang bereits definiert haben, sind Primitives eine Sammlung von Vertices. Obwohl PointLists lediglich eine Randbedeutung zukommt, werden sie immer wieder eingesetzt. Einen weitaus höheren Stellenwert haben komplexerer Primitives. Diese bestehen aus Polygonen. Polygone bilden die Basis aller 3D-Objekte. Es ist mitunter kaum vorstellbar, dass alle Objekte, Spielfiguren, Autos, Häuser, Bäume eine Ansammlung von Dreiecken sind. Dennoch kennt DirectX keine andere Form. Hierzu haben wir einen Screenshoot erstellt.

Abb. 26. Auto auf Landstraße (solid / Wireframe)

120

DirectX-Grundlagen

Als Wireframe wird die Darstellung einer Szene als Drahtgitter bezeichnet. Demgegenüber steht die ausgefüllte (Solid) Darstellung. Im fertigen Programm macht Wireframe meistens keinen Sinn. Zur Zeit der Programmentwicklung ist diese Darstellung immer dann Hilfreich, wenn Sie den fehlerfreien Aufbau eines Objektes prüfen möchten. Anhand des Screenshoots können Sie erkennen, dass selbst komplexeste Konstruktionen immer auf Basis von Dreiecken erstellt werden. Dies trifft auch auf eine Kugel zu.

Abb. 27. Gittermodell einer Kugel

Wie Sie sehen, ist selbst der Inbegriff einer Rundung nicht vor der Darstellung als Dreiecksmodell verschont. Warum ist ein Dreieck für die Computergrafik von so hoher Bedeutung? Könnte es nicht viel besser ein Viereck sein? Es gibt einen entscheidenden Punkt, welcher für ein Dreieck spricht. Dreiecke sind immer eben. Sie können keine Krümmung aufweisen oder Knick haben. Und gerade weil ein Dreieck immer flach ist, können viele mathematische Funktionen erst funktionieren. Später im Buch werden wir uns mit der Lichtberechnung beschäftigen. Spätestens dann erkennen Sie die Bedeutung von Normalvektoren und flachen Flächen. Weitere Gründe, welche für Dreiecke sprechen sind: • • • • •

Dreiecke sind die einfachste Art von Polygone. Dreiecke sind immer konvex und kreuzungsfrei. Dreiecke sind planar. Dreiecke werden von Hardwarebeschleunigern unterstützt. Komplexe Objekte können näherungsweise in Dreiecke zerlegt werden. Dies gelingt besser mit Dreiecken als z.B. mit Vierecken.

Primitives

121

16.2.1 Primitives rendern Wir wissen, dass ein Polygon durch Vertices beschrieben wird. Bisher haben wir gesagt, dass drei Vertices zur Darstellung des kleinsten Polygons (Dreieck) benötigt werden. Grundsätzlich ist das richtig, dennoch kennt DirectX verschiedene Methoden, um Vertexdaten zu verarbeiten. Aus Vertexdaten müssen nicht immer Dreiecke entstehen. Es ist auch möglich, einzelne Punkte oder Linien zu rendern. Das Zeichnen in einer 3D-Welt nennt man rendern. Das Rendern wird durch die DrawPrimitives()Methode eingeleitet. Diese werden wir noch genauer kennen lernen. Hier wollen wir uns zunächst mit den möglichen Formaten der Vertexdaten beschäftigen. Eine Liste mit Vertexdaten nennt man Vertexbuffer. Der Inhalt eines Vertexbuffers kann auf unterschiedliche Arten interpretiert werden: • • • • • •

point list line list line strip triangle list triangle strip triangle van

Um die verschiedenen Möglichkeiten zu demonstrieren, benötigen wir einen Vertexbuffer. Unglücklicherweise ist ein Vertexbuffer nicht so einfach darzustellen. Deshalb betrachten wir den Inhalt eines Vertexbuffers also die Vertices. Ein Vertex beinhaltet in erster Linie ein Koordinatentripel. Hiermit wird eine eindeutige Position in der 3D-Welt definiert. Des Weiteren kann ein Vertex Informationen über Farbe oder Texturkoordinaten aufnehmen. Für unsere jetzige Aufgabe ist es ausreichend, wenn wir uns auf das Koordinatentripel konzentrieren. Um ein Koordinatentripel erfassen zu können, müssen wir ein VertexArray entsprechend deklarieren: Dim VArray(5) As Direct3D.CustomVertex.PositionOnly

Durch das Flag PositionOnly signalisieren wir DirectX, dass unser Vertex-Array lediglich Positionsdaten aufnehmen soll. Und so füllen wir das Vertex-Array: VArray(0).X VArray(1).X VArray(2).X VArray(3).X VArray(4).X

= = = = =

1: 2: 3: 4: 5:

VArray(0).Y VArray(1).Y VArray(2).Y VArray(3).Y VArray(4).Y

= = = = =

1: 5: 1: 5: 1:

VArray(0).Z VArray(1).Z VArray(2).Z VArray(3).Z VArray(4).Z

= = = = =

0 0 0 0 0

122

DirectX-Grundlagen VArray(5).X = 6: VArray(5).Y = 5: VArray(5).Z = 0

Es ist Ihnen bestimmt aufgefallen, dass die Z-Koordinate immer den Wert null hat. Das bedeutet für uns, dass wir zur Darstellung des Vertex-Arrays die Z-Koordinate ignorieren können. Wenn Sie sich nun ein Millimeterpapier zur Hand nehmen, und in der Senkrechten die Y-Achse und in der Waagerechten die X-Achse einzeichnen, haben Sie die Möglichkeit, die Punkte einzuzeichnen. Point List. Eine PointList (Punktliste) ist eine Sammlung von Vertices. Jedes Vertex enthält ein Koordinatentripel. Eine point list wird nur selten eingesetzt. Bestenfalls ist solch eine Technik für Effekte einsetzbar. Um ein sichtbaren Effekt zu erzielen, müssen sehr viele Vertices definiert werden. Einen einzelnen Punkt im 3D-Raum würde man übersehen.

Abb. 28. PointList

Line List. Wie wir bereits aus dem Namen ableiten können, ist eine LineList (Linienliste) eine Liste von Linien. Anders als bei einer PointList werden zur Darstellung immer zwei Vertices benötigt. Daraus können wir folgern, dass das Vertex-Array immer ein vielfaches von zwei groß sein muss. Zur Darstellung hätte es auch keinen Sinn, eine ungrade Anzahl an Vertices zu definieren. Letztendlich würde ein Vertex unbeachtet bleiben und das kann nicht sinnvoll sein. Interessant ist, dass Sie einer Linie eine Textur zuweisen können. Hierdurch ergeben sich einige Einsatzgebiete. Denken Sie z.B. an Regen. Dieser wird nicht als Tropfen dargestellt, sondern als Linie. Die Linie suggeriert eine gewisse Geschwindigkeit.

Primitives

123

Abb. 29. Line List

Line Strip. Bei einer LineStrip (verbundene Linienliste) werden die Linien miteinander verbunden. Aus den ehemals drei Linien (v0-v1, v2-v3, v4-v5) entsteht eine Ziehharmonika mit insgesamt fünf Linien.

Abb. 30. Line Strip

Triangle List. Die TriangleList (Dreiecksliste) sollte Ihnen bisher am vertrautesten sein. Wir benötigen drei Vertices für ein Dreieck. Somit sollte die Anzahl der Vertices ein Vielfaches von drei sein. Eine andere Anzahl wäre wiederum unsinnig. Wenn wir eine Textur über die Polygone spannen, dann ist diese auf der gesamten Fläche der jeweiligen Polygone sichtbar. Für die Zwischenräumen gilt dies natürlich nicht. Diese Technik ist besonders beliebt. Was wohl auch daran liegt, dass die einzelnen Polygone völlig unabhängig voneinander sind. Mit unabhängig meinen wir, dass sie nicht miteinander verbunden sind. Hierdurch erhält

124

DirectX-Grundlagen

man eine relativ große Fläche, welche zur Konstruktion anderer Objekt genutzt werden kann.

Abb. 31. Triangle List

Triangle Strip. Mit TriangleStrip (verbundene Dreiecksliste) erzielen Sie mit wenig Aufwand die größten Flächen. Zusätzlich ist dies die schnellste Rendertechnik. Wenn wir TriangleStrip und TriangleList miteinander vergleichen, erkennen wir, dass mit der gleichen Anzahl an Vertices unterschiedlich viel Dreiecke entstehen. Die Funktionsweise von TriangleStrip ist einfach erklärt. Hierzu betrachten wir, wie ein einzelnes Dreieck gerendert wird: Dreieck Nr. 1 =V0, V1, V2 Dreieck Nr. 2 = V1, V2, V3 Dreieck Nr. 3 = V2, V3, V4 Dreieck Nr. 4 = V3, V4, V5 Diese Technik erklärt natürlich die hohe Effizienz.

Abb. 32. Triangle Strip

Primitives

125

Triangle Fan. TriangelFan (Dreiecksfächer) ist ebenfalls eine schnelle und platzsparende Technik. Ähnlich dem TriangleStrip teilen sich die Dreiecke einzelne Vertices. So verwenden alle Dreiecke den Mittelpunkt, welcher durch Vertex 0 beschrieben wird. Es ist unschwer zu erkennen, dass die Stärke dieser Technik bei Kreisen oder Rundungen liegt. Auch für Spezialeffekte wie einen Scheinwerferkegel lässt sich die Technik nutzen.

Abb. 33. Triangle Fan

16.2.2 Vorder- und Rückseite Wir haben besprochen, dass DirectX das linkshändige Koordinatensystem verwendet. Stellen Sie sich vor, wir würden ein Dreieck genau auf der ZAchse zeichnen. Hierfür könnten wir folgende Vertices verwenden: Vertex 0 V0.X = 0 V0.Y = 0 V0.Z = 0

Vertex 1 V1.X = 0 V1.Y = 1 V1.Z = 0

Vertex 2 V2.X = 1 V2.Y = 0 V2.Z = 0

126

DirectX-Grundlagen

Wenn wir das Polygon mit einem reellen Gegenstand vergleichen, dann würden wir sagen, der Gegenstand hat eine Vorderseite und eine Rückseite. Wir können den Gegenstand von vorne und von hinten betrachten. Das kreierte Direct3D-Polygon besitzt ebenfalls eine Vorder- und eine Rückseite. Leider können wir es von der Rückseite nicht sehen. Da wir das linkshändige Koordinatensystem verwenden, sind nur Polygone sichtbar, welche im Uhrzeigersinn erstellt wurden. In einigen Fällen ist das sehr hilfreich. Insbesondere, wenn Sie später auf besonders realistische Lichteffekte wert legen. Oftmals wird dieser Umstand aber als Hindernis empfunden. Um diesem Hindernis entgegenzuwirken, kennt DirectX das geeignete Mittel: D3DDevice.RenderState.CullMode = Direct3D.Cull.None

Über den CullMode können Sie festlegen, welche Polygone sichtbar sein sollen. Wenn Sie keine Auswahl treffen (None) dann sind alle Dreiecke sichtbar. Egal ob sie im Uhrzeigersinn oder gegen den Uhrzeigersinn erstellt wurden. D3DDevice.RenderState.CullMode = Direct3D.Cull _. Clockwise

Stellen Sie den CullMode auf Clockwise, dann sehen Sie nur Polygone, welche im Uhrzeigersinn erstellt wurden. D3DDevice.RenderState.CullMode = Direct3D.Cull _. CounterClockwise

Wenn Sie den CounterClockwise verwenden, dürfen Sie sich nicht wundern, wenn nur Polygone sichtbar sind, welche gegen den Uhrzeigersinn erstellt wurden.

17 Mein erstes DirectX-Programm

Nun ist es langsam Zeit, dass Sie Ihr erstes DirectX-Programm erstellen. Es gleicht einem Sprung ins kalte Wasser, da Ihnen noch Grundlagen fehlen. Aber dieses Vorhaben ist nicht zu komplex, um es nicht angehen zu können. Wir werden ein Direct3D-Device erstellen. Dieses ist die Grundlage jeder Direct3D-Applikation und somit von enormer Wichtigkeit. Leider ist das Beispiel nicht allzu spektakulär, aber es ist ein gutes Beispiel für fundierte Grundlagenforschung. In diesem Kapitel wollen wir uns die folgenden Punkte einmal näher ansehen: Wir werden Ein Visual Studio .NET-Projekt erstellen, unser erstes Direct3D-Device erzeugen und zum Schluss eine Szene rendern.

17.1 Ein Visual Studio .NET-Projekt erstellen Starten Sie Visual Studio .NET und erstellen Sie ein neues Projekt. Nachdem Sie auf die Schaltfläche „Neues Projekt“ geklickt haben, erscheint folgender Dialog:

Abb. 34. Neues Projekt konfigurieren

128

Mein erstes DirectX-Programm

Bitte wählen Sie als Vorlage eine „Windows-Anwendung“ aus und vergeben Sie den Projektnamen „Mein erstes Directx-Programm“. Als Ergebnis erhalten wir eine leere Form. Die Form wird von uns nicht bearbeitet und dient lediglich als Ausgabehandle unserer DirectX-Grafik. Man könnte die Form als Schnittstellen zwischen Sourcecode und Monitor betrachten. Um mit VB.NET eine DirectX-Anwendung zu erstellen, muss die DirectX-API integriert werden. Diese wird in Form von Verweisen verwaltet.

Abb. 35. Verwaltung von Verweisen

Um einen zusätzlichen Verweis zu integrieren, führen Sie einen Rechtsklick auf das Ordnersymbol „Verweise“ aus und wählen dann den Eintrag „Verweise hinzufügen…“.

Abb. 36. Verweise hinzufügen

In dem Dialogfeld wählen Sie die beiden Einträge Microsoft.DirectX und Microsoft.DirectX.Direct3D. Diese

Direct3D-Device erzeugen

129

Verweise benötigen wir für unser erstes DirectX-Projekt. Damit haben wir die verwaltenden Aufgaben erledigt und können uns mit dem Sourcecode beschäftigen.

17.2 Direct3D-Device erzeugen Um ein Direct3D-Device zu erzeugen, sind zwei Voraussetzungen notwendig. Zum einen benötigen wir eine Ausgabeplattform für die Grafik. Dies wird in unserem ersten Beispiel eine normale Windows-Form sein (diese haben wir bereits erstellt und heißt Form1.vb). Zum anderen müssen wir beschreiben können, welche Eigenschaften unser Direct3D-Device besitzen soll. Hierzu nutzen wir die D3DPRESENT_PARAMETERSStruktur. Diese recht umfangreiche Struktur werden wir im Laufe des Buches detailliert besprechen. Zum jetzigen Zeitpunkt beschränken wir uns auf ein paar wenige Elemente. Zuvor sehen Sie hier einmal die gesamte Struktur: Public Structur D3DPRESENT_PARAMETERS AutoDepthStencilFormat As DepthFormat BackBufferCount As Integer BackBufferFormat As Format BackBufferHeight As Integer BackBufferWidth As Integer DeviceWindow As Control DeviceWindowHandle As IntPtr EnableAutoDepthStencil As Boolean FullScreenRefreshRateInHz As Integer MultiSample As MultiSampleType MultiSampleQuality As Integer PresentationInterval As PresentInterval PresentFlag As PresentFlag SwapEffect As SwapEffect Windowed As Boolean End Structure

Für unser erstes Beispiel, benötigen wir lediglich zwei Mitglieder der Struktur: SwapEffect Windowed

Das D3DPRESENT_PARAMETERS-Mitglied SwapEffect ist vom Datentyp SwapEffect. Dieser besitzt drei Konstanten und beschreibt,

130


wie eine gerenderte Szene auf den Bildschirm gebracht werden soll. Genau betrachtet, wird beschrieben, wie die Szene auf das Ausgabehandle (in unserem Fall Form1.vb) gebracht wird: Copy. Die Copy-Methode arbeitet nur mit einem Backbuffer (auf dem Monitor nicht sichtbarer Buffer). Hier wird der gesamte Backbuffer in den Frontbuffer (auf dem Monitor sichtbarer Buffer) kopiert. Diese Methode ist für eine Fullscreen-Anwendung bestens geeignet. Flip. Flip wird verwendet, wenn mit mehreren Backbuffern gearbeitet wird. Hier werden die einzelnen Backbuffer der Reihe nach durchgeschaltet. Wird die Flip-Methode gewählt und es ist nur ein Backbuffer vorhanden, wird automatisch ein weiterer Backbuffer erstellt. Discard. Dies ist die empfohlene Methode im Debug-Runtime-Mode. Sie ist für Fehler schwer zugänglich und somit sehr solide. In unserem Beispiel entscheiden wir uns für die Discard-Methode. Zum einen verwenden wir nur einen Backbuffer, somit ist die Flip-Methode ungeeignet, und zum anderen haben wir eine Fensteranwendung und die Copy-Methode wird nicht benötigt. Das zweite Element der D3DPRESENT_PARAMETERS-Struktur ist Windowed. Diese Konstante ist vom Datentyp Boolean und legt fest, ob es sich um eine Fullscreen-Anwendung oder um eine fensterbasierte Anwendung handelt. Wir wollen eine fensterbasierte Anwendung erstellen und weisen der Konstante den Wert True zu. Nun ist es Zeit, das Direct3D-Device zu erstellen. Hierzu verwenden wir eine kleine Funktion, welche uns bei Erfolg ein True liefert. 1

2 3 4 5

6

7 8 9 10 11

Public Function CreateDirect3DDevice _ (ByVal Handle As Form) As Boolean Try Dim presentParams As New Direct3D.PresentParameters() presentParams.Windowed = True presentParams.SwapEffect = _ Direct3D.SwapEffect.Discard Direct3dDevice = New Direct3D.Device _ (0,Direct3D.DeviceType.Hardware, Handle, _ Direct3D.CreateFlags.HardwareVertexProcessing, _ presentParams) Return True Catch e As DirectX9.DirectXException Return False End Try End Function

Rendern

131

In Zeile 6 sehen wir den eigentlichen Aufruf zum Erstellen des Direct3DDevices. Das Direct3D-Device ist erstellt und einsatzbereit. Wozu benötigen wir überhaupt das Device? Die Antwort ist recht einfach: Wir können das Direct3D-Device nutzen, um komplexe 3D-Welten auf dem Bildschirm darzustellen (rendern). Aber bevor wir darangehen, komplexe Welten zu generieren, müssen wir uns mit dem Rendern befassen.

17.3 Rendern Eine vernünftige Renderroutine für umfassende Tätigkeiten ist eine anspruchsvolle Aufgabe. Im Laufe des Buches werden Sie erfahren, wie Sie sich dieser Aufgabe am besten nähern. In unserem ersten Beispiel reicht es uns bereits, eine leere Szene darzustellen. Mit einer leeren Szene meinen wir eine Direct3D-Welt ohne Objekte. Also absolut leer! Lediglich den Hintergrund werden wir blau einfärben. Dies soll als Beweis dienen, Sie erkennen zu lassen, dass hier wirklich gerendert wird und wir nicht irgendeinen faulen Zauber vorführen. Hier die Render()-Routine: 1 2

3 4 5 6

Private Sub Render() Direct3dDevice.Clear(Direct3D.ClearFlags.Target, _ System.Drawing.Color.Blue, 1.0F, 0) Direct3dDevice.BeginScene() Direct3dDevice.EndScene() Direct3dDevice.Present() End Sub

Hoffentlich haben Sie nicht mehr erwartet. Das Rendern einer leeren Welt ist nun mal nicht kompliziert und verschlingt somit auch nur wenig Sourcecode. Dennoch ist die Renderstruktur immer vom gleichen Aufbau. Es beginnt mit dem Löschen der alten Szene. Dies geschieht mit der Direct3dDevice.Clear()-Methode. Nach dem Löschen der alten Szene wird mit der Direct3dDevice.BeginScene()-Methode eine neue Szene geöffnet. Normalerweise würden wir nun die einzelnen Objekte der 3D-Welt rendern, in unserem Beispiel verzichten wir darauf. Anschließend schließen wir mit der Direct3dDevice.EndScene()Methode die Szene wieder. Die gesamte Szene ist fertig berechnet, aber wir können Sie auf dem Bildschirm nicht sehen. Dies liegt daran, dass alle Berechnungen ausschließlich im Speicher (Ram) des Systems oder der Grafikkarte vorgenommen werden. Um die Daten auf dem Bildschirm sichtbar zu machen, nutzen wir die Direct3dDevice.Present()Methode.

132


Mit der Direct3dDevice.Clear()-Methode löschen wir die aktuelle Szene. Die vier Parameter flags, color, zdepth und stencil sind nicht leicht zu erklären. Insbesondere die beiden letzten Parameter beziehen sich auf einen Sachverhalt, welcher erst mit wachsender Programmiererfahrung verständlicher wird. Dennoch schauen wir und die Parameter im Detail an: •

•

•

•

flags AS Direct3D.ClearFlags Dieser Parameter bestimmt, welche Oberfläche gelöscht werden soll. Für uns den Betrachter gibt es nur die Bildschirmausgabe. Wir unterscheiden nicht zwischen unterschiedlichen Oberflächen. DirectX hingegen kennt drei Oberflächen. Genauer gesagt unterscheidet DirectX drei Speicherbereiche. Target, Stencil und ZBuffer sind die Arbeitsbereiche von DirectX. In diesem Buch werden wir uns mit dem Löschen einer Szene beschäftigen. Hierzu werden wir die Werte Target und ZBuffer verwenden. Mit Target löschen wir das Renderdevice. Das können Sie mit dem Speicher der Grafikkarte vergleichen. Mit dem ZBuffer werden wir uns zu einem späteren Zeitpunkt beschäftigen. An dieser Stelle wollen wir lediglich erwähnen, dass mit dem ZBuffer eine Tiefenwirkunk erzeugt wird, welche eine Szene erst richtig realistisch wirken lässt. color Der Parameter color ist leicht erklärt. Dieser Parameter ist vom Datentyp System.Drawing.Color und definiert die Farbe, welche zum Löschen verwendet wird. zdepth Dies ist ein Tiefenwert, welcher das Löschen des ZBuffers reguliert. Mit einem Wert von 1.0 wird der gesamte Tiefenspeicher (ZBuffer) gelöscht. stencil Mit diesem Parameter kann eine so genannte Stencil-Maske erzeugt werden. Der Wertebereich liegt zwischen 0 und 2n-1, wobei n die Bittiefe des Stencilbuffers ist.

Sie sollten der Direct3dDevice.Clear()-Methode nicht zuviel Aufmerksamkeit schenken. Für uns von Wichtigkeit ist lediglich die Deklaration der Farbe und ob der ZBuffer mit gelöscht werden soll oder nicht. In den ersten Beispielen arbeiten wir ohne ZBuffer. Dies wird sich später ändern und dann informieren wir Sie auch über die notwendigen Änderungen an der Clear()-Methode.

Rendern

133

Hier sehen Sie nochmals den Vorgang im Überblick: Schritt 1. Löschen der alten Szene. Direct3dDevice.Clear()

Schritt 2. Öffnen der neuen Szene. Direct3dDevice.BeginScene()

Schritt 3. Rendern der einzelnen Objekte. (dieser Schritt wir in unserem Beispiel noch nicht berücksichtigt). Objekt 1 Objekt 2 … Objekt n

Schritt 4. Schließen der neuen Szene. Direct3dDevice.EndScene()

Schritt 5. Die Szene auf dem Monitor darstellen. Direct3dDevice.Present()

18 Mein erstes Objekt im 3D-Raum

Im vorangegangenen Kapitel zeigten wir Ihnen, wie Sie ein Direct3DDevice erstellen können. Sie haben auch die Basisfunktionen des Renderns kennen gelernt. Das Ergebnis der Arbeit war ein blaues Fenster. Dieses Ergebnis ist sicherlich etwas nüchtern und deshalb wollen wir das Beispiel ein bisschen aufpeppen. Unser Ziel ist es, ein Polygon (Dreieck) darzustellen. Vielleicht werden Sie sagen: „Ein Dreieck, ja toll!“ Denken Sie bitte daran, dass das Dreieck die Basis aller Objekte ist. Wenn wir ein Dreieck darstellen können, können wir auch tausend Dreiecke darstellen. Tausend Dreiecke bedeuten: Autos, Flugzeuge, Spielfiguren, Häuser etc. Aber zu diesem Thema kommen wir später.

Abb. 37. Bildschirmausgabe „Mein erstes Objekt im 3D-Raum“

Leider stellt uns auch dieses Beispiel vor das Problem, Themen anzusprechen, die wir erst später erläutern werden. Dennoch sind wir der Meinung, dass dieses Beispiel hilfreich ist. Auch wenn Sie noch nicht alles verstehen, können Sie sich mit der Syntax, dem Programmaufbau und den DirectX-Elementen vertraut machen. Folgen wir einfach dem Motto „Learning by Doing“.

136

Mein erstes Objekt im 3D-Raum

Zur Realisierung dieses Beispiels müssen wir die folgenden Schritte durchführen: Als Erstes werden wir einen Vertexbuffer erstellen, diesen danach mit Objektdaten füllen und anschließend rendern.

18.1 Vertexbuffer erstellen Einen Vertexbuffer können Sie sich als Auffangbehälter für Vertices vorstellen. Ein Polygon wird aus Vertices konstruiert. In unserem Fall besitzt ein Polygon drei Vertices. Sie sind die Eckpunkte des Dreiecks. Natürlich ist diese Betrachtungsweise eines Vertexbuffers sehr oberflächlich und entspricht nicht der DirectX-Deklaration, hilft Ihnen aber vielleicht dabei, sich unter einem Vertexbuffer etwas vorzustellen. Um den Vertexbuffer zu erstellen, müssen wir ihn zuerst deklarieren: Dim vbBuffer_Dreieck As _Direct3D.VertexBuffer = Nothing

Nach der Deklaration kommt das Erzeugen des Buffers. Aber zuvor müssen wir das Direct3D-Device erzeugen: 1

2

3

4

5 6

Public Sub OnCreateDevice(ByVal sender As Object, _ ByVal e As EventArgs) Dim dev As Direct3D.Device = CType(sender, _ Direct3D.Device) vbBuffer_Dreieck = New Direct3D.VertexBuffer _ (GetType(Direct3D.CustomVertex. _ TransformedColored), 3, dev, 0, _ Direct3D.CustomVertex.TransformedColored.Format, _ Direct3D.Pool.Default) AddHandler vbBuffer_Dreieck.Created, AddressOf Me.OnCreateVertexBuffer Me.OnCreateVertexBuffer(vbBuffer_Dreieck, Nothing) End Sub

Wenn Sie sich den gesamten Sourcecode (auf der CD, hier sehen Sie lediglich einen Ausschnitt) anschauen, werden Sie erkennen, dass wir der Subroutine OnCreateDevice ein bereits erstelltes Direct3D-Device übergeben. Um es in der Subroutine nutzen zu können, deklarieren wir in der Zeile 2 eine Hilfsvariable und weisen dieser das Device zu. Somit wird in der Variablen dev unser Direct3D-Device gespeichert. Diese benötigen wir in Zeile 3. Hier wird der Vertexbuffer erstellt. Die Parameter sind schnell benannt.

Vertexbuffer mit Objektdaten füllen

137

Parameter 1. Hier wird der Vertexbuffer-Typ verlangt. In unserem Beispiel verwenden wir einen Vertexbuffer, welcher farblich indizierte Vertices aufnehmen kann. GetType(Direct3D.CustomVertex.TransformedColored)

Parameter 2. Anzahl der Vertices. Wir möchten ein Polygon (Dreieck) darstellen. Ein Dreieck besteht aus drei Vertices. Somit ist der Wert dieses Parameters gleich 3. Parameter 3. Dieser Parameter benötigt ein gültiges Direct3D-Device. Sie erinnern sich, dieses wird temporär in der Variablen dev gespeichert. Parameter 4. Hier wird die Verwendungsart festgelegt. Wir merken uns einfach den Wert null. Parameter 5. DirectX ist immer auf exakte Angaben angewiesen. Kleinste Abweichungen von einem erwarteten Format haben fatale Folgen. Hier wird das Vertexformat übergeben. Parameter 6. Dies ist der letzte Parameter. Er bestimmt welcher Speicher für den Buffer reserviert werden soll. Mit dem Default Wert legen wir den Speicher in den bevorzugten Speicher des Direct3dDevices. Bitte lassen Sie sich von den zahlreichen Parametern nicht irritieren. Auf den ersten Blick haben sie eine abschreckende Wirkung. Dies vergeht mit etwas Übung und gehört zum Leidensweg eines Programmierers. Der Vertexbuffer ist fertig. Leider ist er noch vollkommen leer. Unser nächster Schritt besteht darin, den Vertexbuffer mit Inhalt (Vertexdaten) zu füllen.

18.2 Vertexbuffer mit Objektdaten füllen Zum Füllen des Vertexbuffers gibt es eine eigene Subroutine: 1

2

3

Public Sub OnCreateVertexBuffer(ByVal sender As Object, _ ByVal e As EventArgs) Dim vb As Direct3D.VertexBuffer = CType(sender, _ Direct3D.VertexBuffer) Dim verts As Direct3D.CustomVertex. _ TransformedColored() = CType(vb.Lock(0, 0), _ Direct3D.CustomVertex.TransformedColored())

138 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Mein erstes Objekt im 3D-Raum

verts(0).X = 150 verts(0).Y = 50 verts(0).Z = 0.5F verts(0).Rhw = 1 verts(0).Color = System.Drawing.Color.Aqua.ToArgb() verts(1).X = 250 verts(1).Y = 250 verts(1).Z = 0.5F verts(1).Rhw = 1 verts(1).Color = System.Drawing.Color.Brown.ToArgb() verts(2).X = 50 verts(2).Y = 250 verts(2).Z = 0.5F verts(2).Rhw = 1 verts(2).Color = System.Drawing.Color.LightPink.ToArgb() vb.Unlock() End Sub

Auch in dieser Subroutine verwenden wir eine Hilfsvariable vb. In ihr speichern wir den Vertexbuffer, welcher durch den SenderParameter der Subroutine übergeben wurde. Anschließend deklarieren wir das Array verts vom Datentyp Direct3D.CustomVertex. TransformedColored() und weisen diesem Array unseren Vertexbuffer zu. Da wir hierbei die Lock-Methode verwenden, hat das Füllen des Arrays verts direkte Auswirkungen auf unseren eigentlichen Vertexbuffer. Nach dem Aufruf der Unlock-Methode ist unser Vertexbuffer fertig. Durch den direkten Zugriff mit Hilfe der Lock- bzw UnlockMethode haben wir eine sehr schnelle Technik, um einen Vertexbuffer zu füllen. Um den Vertexbuffer leichter zu verstehen, ignorieren wir den Parameter Rhw. Diesen setzen wir durchgehend auf den Wert 1. Die Parameter X, Y und Z bestimmen einen Punkt im 3D-Raum. Für ein Dreieck benötigen wir drei Punkte. Diese werden miteinander verbunden und das Dreieck ist fertig. Der Color-Parameter legt eine Farbe fest, welche an diesem Punkt im 3D-Raum dominieren soll. Wenn wir unterschiedliche Farben an den Ecken des Polygons definieren, mischen sich die Farben, je näher sie sich aufeinander zu bewegen. Jetzt, wenn das Dreieck fertig im Speicher liegt, müssen wir es noch auf dem Bildschirm darstellen. Dies geschieht beim Rendern.

Vertexbuffer rendern

139

18.3 Vertexbuffer rendern Die Vorgehensweise beim Rendern kennen Sie bereits. Zur besseren Erinnerung haben wir den Prozess in Abbildung 38 visualisiert:

Abb. 38. Eine einfache Renderschleife

Zum Rendern benötigen wir folgenden Sourcecode: 1 2

3

Private Sub Render() Direct3dDevice.Clear(Direct3D.ClearFlags.Target, _ System.Drawing.Color.Blue, 1.0F, 0) Direct3dDevice.BeginScene()

4 5 6

7

Direct3dDevice.SetStreamSource(0, vbBuffer_Dreieck, 0) Direct3dDevice.VertexFormat = _ Direct3D.CustomVertex.TransformedColored.Format Direct3dDevice.DrawPrimitives(Direct3D .PrimitiveType.TriangleList, 0, 1)

8 9 10 11

Direct3dDevice.EndScene() Direct3dDevice.Present() End Sub

In den Zeilen 5–7 wird das Dreieck gerendert.

19 World-, View- und Projektionsmatrix

Haben Sie sich schon gefragt, wie ein 3D-Objekt auf dem Monitor dargestellt werden kann? Wir sprechen hier von der Transformation eines dreidimensionalen Objektes auf eine zweidimensionale Fläche. Die Basis unserer Berechnungen ist das kartesische Koordinatensystem. Aufbauend auf dem kartesischen Koordinatensystem sind die World-, View- und Projektionsmatrix für die Transformation verantwortlich.

19.1 Worldmatrix Wenn wir ein Objekt in eine 3D-Welt implementieren wollen, müssen wir dieses Objekt zuvor erstellen. Die bisherige Methode besteht darin, die Objektkoordinaten direkt so anzugeben, dass diese mit dem endgültigen Standort des Objekts übereinstimmen. Wir rendern ein Objekt sofort an Ort und Stelle. Es ist auch möglich, ein Objekt in einem eigenen Editor zu erstellen. Dieses Verfahren ist sogar wahrscheinlich, denn komplexerer Objekte müssen mit externen Programmen erstellt werden. Hierdurch entsteht ein Problem: Wenn wir ein Objekt in einem Editor erstellen, könnte es um den Achsenursprung (X=0, Y=0, Z=0) erstellt werden. In unserem Programm möchten wir das Objekt aber an einer ganz anderen Stelle platzieren. Jetzt treffen einerseits das Koordinatensystem unserer 3D-Welt und andererseits das eigene Koordinatensystem des Objektes aufeinander. Die Worldmatrix übernimmt die Aufgabe, für die reibungslose Integration zu sorgen. In diesem Zusammenhang sprechen wir davon, dass jedes Objekt einem autonomen Koordinatensystem unterliegt. Autonome Objekte in einer gemeinsamen Szene, die auch noch in eine zweidimensionale Form transformiert werden müssen - das ist die Stärke der Worldmatrix.

142

World-, View- und Projektionsmatrix

Abb. 39. Worldmatrix mit drei integrierten Objekten

19.2 Viewmatrix Die Worldmatrix ordnet alle einzelnen Objekte in eine gemeinsame Matrix ein. Hierdurch haben alle Objekte einen festen Platz gefunden. Dennoch könnten wir hieraus noch kein zweidimensionales Bild erzeugen. Was uns fehlt, sind Informationen über den Betrachter (Kamera). Von welcher Seite wird die Szene betrachtet, aus welcher Höhe schauen wir auf die Szene und wie groß ist unser Blickwinkel. Diese Informationen fließen über die Viewmatrix ein. Anhand der Viewmatrix kann DirectX eine View Plane erstellen.

Abb. 40. View Plane

Projektionsmatrix

143

Die View Plane liegt zwischen der Front Plane und der Back Plane. Sie beschreibt den für den Zuschauer sichtbaren Bereich. Der Ursprung ist die Kameraposition oder das Auge des Betrachters. Je nachdem, wie die Kamera positioniert ist, sehen wir ein Objekt von der Seite oder von vorn. Natürlich wird auch berücksichtigt, ob ein Objekt durch ein anderes verdeckt wird. Sollte dies der Fall sein, wird es der Betrachter nicht zu sehen bekommen. Die Sichtweite wird durch die Back Plane begrenzt. Dies ist eine sinnvolle Sache. Schließlich müssen sehr weit entfernte Objekte nicht gerendert werden. Wir würden sie nur noch als kleine Punkte am Horizont wahrnehmen. Wozu benötigen wir aber die Front Plane? Zum einen ist die Front Plane für mathematische Berechnungen erforderlich. Zum anderen ist der bewusste Einsatz manchmal recht hilfreich. Hierzu stellen wir uns einen Panzerfahrer vor. Der Panzerfahrer schaut aus seiner kleinen Luke auf die Straße. Die Luke liegt aber nicht direkt an der Spitze des Panzers, also würden wir kontinuierlich den gesamten Vorbau des Panzers im Bild haben. Manchmal ist das ein gewollter Effekt, aber falls Sie das nicht wünschen, können Sie die Front Plane etwas verschieben und so das Problem lösen.

19.3 Projektionsmatrix Wir haben bereits die View Plane kennen gelernt. Bei genauer Betrachtung, stellen wir fest, dass die Front Plane kleiner ist als die Back Plane. Wenn wir aber die gesamte View Plane auf dem Monitor darstellen wollen, haben wir mit erheblichen Verzerrungen zu kämpfen. Wir benötigen ein Mittel, welches den Verzerrungen entgegenwirkt. Diese Aufgabe wird von der Projektionsmatrix übernommen. Hierzu sollten Sie Folgendes versuchen: Spielen Sie mit den Parametern der Projektionsmatrix. Hier lassen sich verblüffende Effekt erzielen. Der ursprüngliche Sinn, die Verzerrungen zu entschärfen, kann aber auch bewusst eingesetzt werden. Wollen Sie ein Auto überdeutlich, d.h. extrem beschleunigen, können wir die Welt etwas länger ziehen. Dies verstärkt den Geschwindigkeitsrausch. Natürlich sollte die Welt nach der Beschleunigung wieder normalisiert werden.

20 Device Enumeration

Um mit Direct3D arbeiten zu können, müssen wir zuerst Direct3D initialisieren. Dies haben wir in unseren ersten Programmen bereits erfolgreich getan. Wir können dennoch nicht absolut sicher sein, dass diese ersten Programme auch auf Ihrem System funktionieren, da wir gewisse Fähigkeiten Ihrer Grafikkarte vorausgesetzt haben. Deshalb müssen wir einen Weg finden, die Grafikkartenfähigkeiten zu ermitteln.

20.1 DXSettings Das wird ein wirklich schwieriger Abschnitt. Die benötigten Techniken sind nicht leicht zu verstehen und setzen ein gewisses Maß an Erfahrung voraus. Aber das Ergebnis wird sich lohnen. Wir werden mit Ihnen eine Schnittstelle entwickeln, die uns eine lange Zeit begleiten wird und sich jeder Herausforderung stellen kann. An dieser Stelle müssen wir auf etwas hinweisen. Wir werden zum einen erläutern, wie wir die Werte ermitteln, zum anderen, wie Sie das Tool einsetzen können. Es ist nicht unbedingt notwendig, zu wissen, wie die Werte ermittelt werden. Wenn Sie das Tool einsetzen können, dann haben wir das Ziel bereits erreicht. Wenn Sie später etwas mehr Erfahrung gesammelt haben, werden Sie völlig autonom auf das Thema zurückkommen. Das Erkunden der Hardware wird einen DirectX-Programmierer kontinuierlich begleiten. Hier können leicht Fehler gemacht werden, welche hinterher zu unerklärlichen Abstürzen führen.

146

Device Enumeration

Abb. 41. Screenshoot DXSettings

An dem Screenshoot erkennen Sie, was wir alles ermitteln müssen. Das fängt damit an, dass wir abfragen, wie viele Grafikkarten eingebaut sind, und endet mit Detailfragen. Um all diese Informationen zu bekommen, müssen wir eine bestimmte Reihenfolge einhalten. Außerdem stehen die einzelnen Ergebnisse untereinander in Verbindung. Das bedeutet, wenn wir einen Wert ändern, dann ändern sich verschiedene andere Werte auch. Am besten erstellen wir eine ToDo-Liste in der richtigen Reihenfolge. Diese Liste können wir dann bequem abarbeiten und verlieren nicht den Überblick. Folgende Informationen über die Hardware müssen wir der Reihe nach sammeln: • • • • • • •

Display-Adapter Hardwarebeschleunigung Videomodus Backbuffer-Format Z-Stencilbuffer-Format Multisample-Typ Vertex-Processing

DXSettings

147

Bevor wir damit anfangen, die Informationen zu ermitteln, möchten wir Ihnen eine wichtige Struktur vorstellen. 1 2 3 4 5 6

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Public Structure CurrentSettings Public DisplayAdapter As DisplayAdapterInformation Public DeviceType As DeviceTypesInformation Public VideoMode As VideoModeInformation Public BackBufferFormat As BackBufferFormatInformation Public DepthStencilBufferFormat As_ DepthStencilBufferFormatInformation Public MultiSampleType As MultiSampleTypeInformation Public VertexProcessing As VertexProcessingInformation Public PresentInterval As PresentIntervalInformation Public SelectedAdapterID As Integer Public SelectedDeviceID As Integer Public SelectedVideoModeID As Integer Public SelectedBackBufferFormatID As Integer Public SelectedDepthStencilBufferFormatID As Integer Public SelectedMultiSampleTypeID As Integer Public SelectedVertexProcessingID As Integer Public SelectedPresentIntervalID As Integer Public AusgabeHandle As System.Windows.Forms.Control Public WindowsEnable As Boolean Public Windows_Resize_and_Replace As Boolean Public WindowsInformationen As WindowsInformationen Public AllowToCreateD3DDevice As Boolean Public Automatic As Boolean Public AdvanceGUI As AdvanceGUI End Structure

In dieser Struktur CurrentSettings erfassen wir alle Hardwareinformationen. Außerdem werden hier ein paar Steuerparameter gespeichert. Steuerparameter sind z.B. die Variable Automatic (in Zeile 23). Nimmt diese Variable den Wert True an, dann wird das Device automatisch konfiguriert und der Benutzer muss keine Eingaben machen. Ein weiterer Steuerparameter ist AdvanceGUI. Diese Variable erlaubt das Einblenden eines weiteren Informationsfeldes rechts neben der eigentlichen GUI (Graphic User Interface). Wenn Sie in einem eigenen Programm bestimmte Informationen über die Grafikhardware benötigen, können Sie auch auf diese Struktur zurückgreifen. Hier stehen zu jedem Zeitpunkt die aktuellen Werte. Das funktioniert natürlich nur dann, wenn Sie auch mit unserem Tool arbeiten.

148

Device Enumeration

20.1.1 Display-Adapter Erforderliche Informationen zum Ermitteln des Display-Adapters: • keine Unter einem Adapter versteht Microsoft eine Grafikkarte. Herauszufinden, wie viele Adapter in einem System verbaut sind, ist unsere erste Aufgabe. Wenn wir die Adapter auflisten, erhalten wir auch bestimmte Detailinformationen über jeden einzelnen Adapter. Private EnumDisplayAdapters() As _ DisplayAdapterInformation

Unser Ziel ist es, Informationen über die eingebauten Grafikkarten zu ermitteln. Um diese Informationen speichern zu können, deklarieren wir ein leeres Array vom Datentyp DisplayAdapterInformation. Wir dürfen dem Array noch keine Dimension zuweisen, weil wir die genaue Anzahl der Grafikkarten noch nicht kennen. Grundsätzlich könnten bis zu 9 Grafikkarten eingebaut sein. Das wäre aber wohl die Ausnahme. Dennoch gibt es viele Grafikkarten mit zwei VGA-Ausgängen. Hierbei würde man von einem primären und sekundären Adapter sprechen. Beide Adapter werden aber unabhängig voneinander betrachtet. Deshalb würden wir beim Auslesen der Grafikkarten auch zwei Grafikkarten erkennen. 1 2 3 4 5 6

7

8

9

10

Function GetDisplayAdapter() As Array Dim i Dim FirstSelect As Integer = 0 For i = 0 To Direct3D.Manager.Adapters.Count - 1 ReDim Preserve EnumDisplayAdapters(i) EnumDisplayAdapters(i).Description = _ Direct3D.Manager.Adapters(i).Information.Description EnumDisplayAdapters(i).DeviceID = _ Direct3D.Manager.Adapters(i).Information.DeviceId EnumDisplayAdapters(i).DeviceName = _ Direct3D.Manager.Adapters(i).Information.DeviceName If i = IPresetSettings.SelectedAdapterID Then _ FirstSelect = i Next i

11 12 13

14

15

ICurrentSettings.SelectedAdapterID = FirstSelect ICurrentSettings.DisplayAdapter.DeviceID = _ EnumDisplayAdapters(FirstSelect).DeviceID ICurrentSettings.DisplayAdapter.Description = _ EnumDisplayAdapters(FirstSelect).Description ICurrentSettings.DisplayAdapter.DeviceName = _ EnumDisplayAdapters(FirstSelect).DeviceName

DXSettings 16

GetDisplayAdapter = EnumDisplayAdapters

17

End Function

149

In Zeile 5 stellen wir über die Methode Direct3D.Manager .Adapters.Count die Anzahl der verbauten Grafikkarten fest. In den Zeilen 6 - 10 ermitteln wir die gewünschten Informationen. In den Zeilen 12 - 15 übertragen wir die Informationen in unsere ICurrentSettings-Struktur. Wie wir bereits erwähnten, werden in dieser Struktur immer die aktuellen Informationen zusammengeführt. Wir haben also eine zentrale Struktur mit allen Infos. 20.1.2 Hardwarebeschleunigung (DeviceTyp) Erforderliche Informationen zur Ermittlung der Hardwarebeschleunigung: • Adapter-ID Ein Hauptziel unserer Bemühungen ist es, die optimale Grafikkarte zu ermitteln, die uns auch eine 3D-Hardwareunterstützung bieten würde. Moderne Grafikkarten können das natürlich auch, aber selbstverständlich ist das nicht. Deshalb ist es wichtig, dass wir feststellen, ob der gewählte Adapter Hardwarebeschleunigung bietet oder nicht, um gegebenenfalls einen anderen Adapter zu wählen. Ob die begehrte Hardwareunterstützung geboten wird, können wir leider nicht direkt abfragen. Deshalb arbeiten wir mit einem kalkulierten Fehler. Wenn wir die DeviceCaps abfragen, geben wir den DeviceType vor. Sollte hierbei ein Fehler auftreten, wissen wir, dass der gewählte Adapter diesen DeviceType nicht unterstützt. Wir unterscheiden drei DeviceTypen: • Hardware • Software • Referenz Die Typen Hardware und Software erklären sich durch ihre Namen. Der Typ Referenz ist ein Testtyp und unterstützt quasi die gesamte Palette von DirectX. Folglich treten kaum Fehler auf. Der Nachteil ist, dass dieser Typ extrem langsam und für den realen Einsatz somit nicht geeignet ist. Private EnumDeviceTypes() As DeviceTypesInformation

150

Device Enumeration

Die unterstützten Device-Typen werden in dem Array EnumDeviceTypes() gespeichert. Dieser ist vom Datentyp DeviceTypes Information und wird ohne Dimension deklariert. 1 2 3 4 5 6 7 8

9 10 11 12

13 14

15 16

17 18 19 20 21 22 23

24 25

Function GetDeviceTypes() As Array Dim Caps As Direct3D.Caps Dim i Dim Counter As Integer = 0 For i = 1 To 3 Dim dummy As Direct3D.DeviceType = i Try Caps = _ DirectX.Direct3D.Manager.GetDeviceCaps _ (ICurrentSettings.SelectedAdapterID, dummy) ReDim Preserve EnumDeviceTypes(Counter) Select Case i Case 1 'Hardware EnumDeviceTypes(Counter).Description = _ Direct3D.DeviceType.Hardware Case 2 'Reference EnumDeviceTypes(Counter).Description = _ Direct3D.DeviceType.Reference Case 3 'Software EnumDeviceTypes(Counter).Description = _ Direct3D.DeviceType.Software End Select Counter += 1 Catch End Try Next i ICurrentSettings.SelectedDeviceID = 0 ICurrentSettings.DeviceType.Description = _ EnumDeviceTypes(0).Description Return EnumDeviceTypes End Function

Bitte beachten Sie Zeile 8. Hier wollen wir die DeviceCaps abfragen. Damit wir an die Informationen kommen, müssen wir die ID der gewählten Grafikkarte (Adapters) angeben. Diese ist in der Variable ICurrentSettings.SelectedAdapterID gespeichert. 20.1.3 Videomodus Erforderliche Informationen zur Ermittlung der unterstützten Videomodus: • Adapter-ID • Device-Typ

DXSettings

151

Programme können im Fenster- oder im Vollbildmodus ausgeführt werden. Der Fenstermodus ist unkompliziert, denn letztendlich befindet sich DirectX bereits in einer lauffähigen Umgebung. Unter einer lauffähigen Umgebung verstehen wir die aktuelle Windows-Umgebung, in der sich das Programm befindet, wenn es gestartet wird. Was passiert aber, wenn wir in den Vollbildmodus wechseln möchten. Dann können wir nicht auf aktuelle Einstellungen zurückgreifen. Um zu wissen, welchen Modus (Bildschirmauflösung und Farbtiefe) wir verwenden können, müssen wir zuerst ermitteln, welche Modi von dem gewählten Adapter unterstützt werden. 1 2 3 4 5 6 7

8

9 10 11 12 13 14 15 16 17 18

19 20

21 22

23 24 25 26 27 28 29

Private EnumVideoMode() As VideoModeInformation Function GetVideoMode() As Array Dim DummyArray Dim FirstSelect As Integer = 0 Dim SecondSelect As Integer = 0 Dim ThirdSelect As Integer = 0 DummyArray = _ Direct3D.Manager.Adapters (ICurrentSettings.SelectedAdapterID). _ SupportedDisplayModes ICurrentSettings.DisplayAdapter.DeviceID = _ ICurrentSettings.SelectedAdapterID Dim f As Direct3D.DisplayMode Dim PresetSelect As Integer = 0 Dim Counter As Integer = 0 For Each f In DummyArray ReDim Preserve EnumVideoMode(Counter) EnumVideoMode(Counter).Width = f.Width EnumVideoMode(Counter).Height = f.Height EnumVideoMode(Counter).Format = f.Format EnumVideoMode(Counter).RefreshRate = f.RefreshRate If f.Width = IPresetSettings.VideoMode.Width And _ f.Height = IPresetSettings.VideoMode.Height Then FirstSelect = Counter If f.Format = _ IPresetSettings.VideoMode.Format Then SecondSelect = Counter If f.RefreshRate >= _ IPresetSettings.VideoMode.RefreshRate And _ ThirdSelect = 0 Then ThirdSelect = Counter End If End If End If Counter += 1 Next If ThirdSelect 0 Then

152 30 31 32

33 34

35

36

37

38 39 40

Device Enumeration

ICurrentSettings.SelectedVideoModeID = ThirdSelect Else If SecondSelect 0 Then ICurrentSettings.SelectedVideoModeID = _ SecondSelect Else _ ICurrentSettings.SelectedVideoModeID = FirstSelect End If ICurrentSettings.VideoMode.Format = _ EnumVideoMode(ICurrentSettings.SelectedVideoModeID). _ Format ICurrentSettings.VideoMode.Width = _ EnumVideoMode(ICurrentSettings.SelectedVideoModeID). _ Width ICurrentSettings.VideoMode.Height = _ EnumVideoMode(ICurrentSettings.SelectedVideoModeID). _ Height ICurrentSettings.VideoMode.RefreshRate = _ EnumVideoMode(ICurrentSettings.SelectedVideoModeID). _ RefreshRate ICurrentSettings.SelectedVideoModeID = 0 Return EnumVideoMode End Function

In den Zeilen 12 – 28 werden die Videomodi ermittelt. Diese werden ordentlich in dem Array enumVideoMode() gespeichert. Beachten Sie, dass wir in den Zeilen 29 - 38 die gewonnenen Erkenntnisse in die ICurrentSetting-Struktur eintragen. Sie erinnern sich, dass diese Struktur immer die aktuellen Parameter beinhalten soll. Dementsprechend muss sie auch kontinuierlich aktualisiert werden. 20.1.4 Backbuffer-Format Zum Ermitteln des Backbuffer-Formats benötigen wir folgende Informationen: • Adapter-ID • Device-Typ • Videomodus Das BackBufferFormat gehört zu den Präsentationsparametern. Die Präsentationsparameter werden in der PresentParameters-Struktur gespeichert. Sie werden beim Erstellen des Direct3D-Device benötigt und beschreiben die Fähigkeiten des Devices.

DXSettings

153

Was ist der Backbuffer? Wir wissen, dass eine Szene gerendert wird. Dies geschieht Objekt für Objekt, immer schön der Reihe nach. Wenn die Objekte der Reihe nach gerendert werden, müssten wir das doch sehen. Vielleicht ist das Renderen aber so schnell, dass wir es einfach nicht mitbekommen. Die Lösung sieht anders aus: Es wird nicht direkt auf den Bildschirm gerendert, also nicht in den Videospeicher, welcher zur Darstellung auf dem Bildschirm verwendet wird, sondern es wird in einen separaten Speicherbereich gerendert. Erst nachdem die Szene komplett gerendert wurde, wird sie in einem Schwung in den Videospeicher zur Bildschirmausgabe kopiert. Damit das alles reibungslos funktioniert, muss das Format des Backbuffers bekannt sein. Hierzu ermitteln wir das BackBufferFormat. Private EnumBackBufferFormat() As _ BackBufferFormatInformation

Die ermittelten Backbuffer-Formate speichern wir in dem Array EnumBackBufferFormat. Dieses wird ohne Dimension und vom Datentyp BackBufferFormatInformation angelegt. 1 2

3 4 5 6 7

8

9

10 11

12

13 14 15 16

Function GetBackBufferFormats() As Array Dim backBufferFormatArray() As Direct3D.Format = _ {Direct3D.Format.A8R8G8B8, _ Direct3D.Format.X8R8G8B8, Direct3D.Format.A2R10G10B10, _ Direct3D.Format.R5G6B5, _ Direct3D.Format.A1R5G5B5, Direct3D.Format.X1R5G5B5} Dim backBufferFormat As Direct3D.Format Dim FirstSelect As Integer = 0 Dim Counter As Integer = 0 For Each backBufferFormat In backBufferFormatArray If Direct3D.Manager.CheckDeviceType _ (ICurrentSettings.SelectedAdapterID, _ ICurrentSettings.DeviceType.Description, ICurrentSettings.VideoMode.Format, _ backBufferFormat, _ ICurrentSettings.WindowsEnable) Then ReDim Preserve EnumBackBufferFormat(Counter) EnumBackBufferFormat(Counter).Description = _ backBufferFormat If backBufferFormat = _ IPresetSettings.BackBufferFormat.Description _ Then FirstSelect = Counter Counter += 1 End If Next ICurrentSettings.BackBufferFormat.Description = _ EnumBackBufferFormat(FirstSelect).Description

154 17 18

Device Enumeration

Return EnumBackBufferFormat End Function

Es ist nicht möglich, die unterstützten Formate abzufragen. Es ist nur möglich, zu prüfen, ob ein bestimmtes Format unterstützt wird. In Zeile 2 füllen wir das Array backBufferFormatArray() mit Formaten, welche wir überprüfen möchten. Die eigentliche Prüfung finden wir in Zeile 7. Mit der Methode Direct3D.Manager.CheckDeviceType können wir prüfen, ob das Format von dem gewählten Adapter unterstützt wird. Nicht nur der Adapter muss passen, sondern auch der Videomodus und der DeviceTyp. 20.1.5 Z-Stencilbuffer-Format (Depth-Stencilbuffer-Format) Erforderliche Informationen zur Ermittlung des Z-Stencilbuffer-Formats: • • • •

Adapter-ID Device-Typ Videomodus Backbuffer-Format

Um das DepthStencilBufferFormat zu ermitteln, müssen wir noch etwas tiefer in die Trickkiste greifen. Neben der bekannten Direct3D.Manager.CheckDeviceFormat()-Methode kommt noch die Direct3D.Manager.CheckDepthStencilMatch()-Methode zum Einsatz. Private EnumDepthStencilBufferFormat() As _ DepthStencilBufferFormatInformation

Diese Formate werden in dem Array EnumDepthStencilBufferFormat() gespeichert. Dieses ist ohne Dimension und vom Datentyp DepthStencilBufferFormatInformation deklariert. 1 2

3

Function GetDepthStencilBufferFormat() As Array Dim depthStencilFormatArray As Direct3D.DepthFormat() _ = {Direct3D.DepthFormat.D24S8, _ Direct3D.DepthFormat.D15S1, _ Direct3D.DepthFormat.D24X8, Direct3D.DepthFormat.D16, _ Direct3D.DepthFormat.D24X4S4, _ Direct3D.DepthFormat.D32, _ Direct3D.DepthFormat.D16Lockable} Dim FirstSelect As Integer = 0

DXSettings 4 5 6 7 8

9

10

11

12

13 14 15 16 17

18 19

155

Dim depthStencilFmt As Direct3D.Format Dim a Dim Counter As Integer = 0 For Each depthStencilFmt In depthStencilFormatArray If Direct3D.Manager.CheckDeviceFormat _ (ICurrentSettings.SelectedAdapterID, _ ICurrentSettings.DeviceType.Description, _ ICurrentSettings.VideoMode.Format, _ Direct3D.Usage.DepthStencil, _ Direct3D.ResourceType.Surface, depthStencilFmt) Then If Direct3D.Manager.CheckDepthStencilMatch _ (ICurrentSettings.SelectedAdapterID, _ ICurrentSettings.DeviceType.Description, _ ICurrentSettings.VideoMode.Format, _ ICurrentSettings.BackBufferFormat.Description, _ depthStencilFmt) Then ReDim Preserve _ EnumDepthStencilBufferFormat(Counter) EnumDepthStencilBufferFormat _ (Counter).Description = depthStencilFmt If depthStencilFmt = _ IPresetSettings.DepthStencilBufferFormat. _ Description Then FirstSelect = Counter Counter += 1 End If End If Next ICurrentSettings.DepthStencilBufferFormat.Description _ = EnumDepthStencilBufferFormat(FirstSelect).Description Return EnumDepthStencilBufferFormat End Function

20.1.6 Multisample-Typ Zur Ermittlung des Mulitsample-Typs benötigen wir folgende Voraussetzungen: • • • • •

Adapter-ID Device-Typ Videomodus Backbuffer-Format Z-Stencilbuffer-Format

Multisampling ist auch unter den Begriffen Anti-Aliasing oder Kantenglättung bekannt. Oftmals wirken Szenen sehr „pixelig“. Dies liegt vor allem daran, dass der Rasterizer die Vektorkoordinaten in Bildschirmpunkte umrechnen muss. Hierbei entscheiden marginale Unterschiede, ob ein Punkt

156

Device Enumeration

auf die Koordinate 67 oder auf die Koordinate 68 gezeichnet wird. Wenn wir nun die Punkte, die nicht genau die Mitte eines Pixels treffen, auf die umliegenden Pixel verteilen, würde eine Kante nicht mehr so stufig aussehen. Dann wäre es auch nicht mehr von Bedeutung, ob der Punkt auf Koordinate 67 oder 68 gezeichnet wird. Nicht alle Grafikkarten können gleichermaßen gut eine Glättung umsetzten. Wie gut die ausgewählte Grafikkarte das kann, müssen wir erst in Erfahrung bringen. Hierzu nutzen wir die Direct3D.Manager. CheckDeviceMultiSampleType()-Methode. Private EnumMultiSampleType() As _ MultiSampleTypeInformation

Die möglichen Multisample-Typen werden in dem Array EnumMultiSampleType() gespeichert. Dieses wird ohne Dimension und vom Datentyp MultiSampleTypeInformation deklariert. 1 2

3 4 5 6 7 8 9

Function GetMultiSampleType() As Array Dim msTypeArray As Direct3D.MultiSampleType() = _ {Direct3D.MultiSampleType.None, _ Direct3D.MultiSampleType.NonMaskable, _ Direct3D.MultiSampleType.TwoSamples, _ Direct3D.MultiSampleType.ThreeSamples, _ Direct3D.MultiSampleType.FourSamples, _ Direct3D.MultiSampleType.FiveSamples, _ Direct3D.MultiSampleType.SixSamples, _ Direct3D.MultiSampleType.SevenSamples, _ Direct3D.MultiSampleType.EightSamples, _ Direct3D.MultiSampleType.NineSamples, _ Direct3D.MultiSampleType.TenSamples, _ Direct3D.MultiSampleType.ElevenSamples, _ Direct3D.MultiSampleType.TwelveSamples, _ Direct3D.MultiSampleType.ThirteenSamples, _ Direct3D.MultiSampleType.FourteenSamples, _ Direct3D.MultiSampleType.FifteenSamples, _ Direct3D.MultiSampleType.SixteenSamples} Dim Counter As Integer = 0 Dim FirstSelect As Integer = 0 Dim msType As Direct3D.MultiSampleType For Each msType In msTypeArray Dim result As Integer Dim qualityLevels As Integer = 0 If Direct3D.Manager.CheckDeviceMultiSampleType _ (ICurrentSettings.SelectedAdapterID, _ ICurrentSettings.DeviceType.Description, _ ICurrentSettings.BackBufferFormat.Description, _

DXSettings

157

10

ICurrentSettings.WindowsEnable, msType, result, _ qualityLevels) Then ReDim Preserve EnumMultiSampleType(Counter) EnumMultiSampleType(Counter).Description = msType If msType = _ IPresetSettings.MultiSampleType.Description Then _ FirstSelect = Counter Counter += 1 End If Next msType ICurrentSettings.MultiSampleType.Description = _ EnumMultiSampleType(FirstSelect).Description Return EnumMultiSampleType End Function

11 12

13 14 15 16

17 18

Leider können wir die Multisampel-Typen nicht direkt abfragen. Wir müssen jeden einzelnen Typ auf seine Gültigkeit prüfen. Hierzu haben wir uns ein Array (Zeile 2) mit allen uns bekannten Typen erstellt. In Zeile 9 prüfen wir, ob der Typ von den gewählten Einstellungen unterstützt wird. Ist das der Fall, wird der Typ in das EnumMultiSampleType()-Array aufgenommen. 20.1.7 Vertex-Processing Erforderliche Informationen zur Ermittlung der Vertex-ProcessingMöglichkeiten des Systems: • • • •

Adapter-ID Device-Typ Videomodus Backbuffer-Format

Grundsätzlich muss eine 3D-Welt umgewandelt (transformiert) werden. Auch die Lichtberechnungen müssen durchgeführt werden. Diese Aufgaben lassen sich per Software oder per Hardware lösen. Die Berechnungen nennt man Transform and Lighting (TnL). Hier stehen vier mögliche Varianten zur Auswahl: • Das Device ist ein reines (pures) TnL-Device • Das Device ist ein Hardware mit gemischtes TnL-Device • Das Device ist ein Software-TnL-Device Private EnumVertexProcessing() As _ VertexProcessingInformation

158

Device Enumeration

Die ermittelten Werte werden in dem Array EnumVertexProcessing gespeichert. Dieses ist ohne Dimension und vom Datentyp VertexProcessingInformation deklariert. 1 2 3 4 5

6 7

8 9 10

11

12 13

14

15 16 17 18 19

20 21 22

23

24 25 26

Function GetVertexProcessing() As Array Dim FirstSelect As Integer = 0 Dim d3dCaps As Direct3D.Caps Dim VertexProcess As Direct3D.CreateFlags Dim VertexProcessingArray() As Direct3D.CreateFlags _ = {Direct3D.CreateFlags.SoftwareVertexProcessing, _ Direct3D.CreateFlags.HardwareVertexProcessing, _ Direct3D.CreateFlags.PureDevice} Try d3dCaps = Direct3D.Manager.GetDeviceCaps _ (ICurrentSettings.SelectedAdapterID, _ ICurrentSettings.DeviceType.Description) Dim Counter As Integer = 0 For Each VertexProcess In VertexProcessingArray If d3dCaps.DeviceCaps. _ SupportsHardwareTransformAndLight Then If ConfirmDevice(d3dCaps, VertexProcess, _ ICurrentSettings.VideoMode.Format, _ ICurrentSettings.BackBufferFormat. _ Description) Then ReDim Preserve EnumVertexProcessing(Counter) EnumVertexProcessing(Counter).Description _ = VertexProcess If VertexProcess = IPresetSettings. _ VertexProcessing.Description Then _ FirstSelect = Counter Counter += 1 End If End If Next ICurrentSettings.VertexProcessing.Description = _ EnumVertexProcessing(FirstSelect).Description Catch ReDim Preserve EnumVertexProcessing(0) EnumVertexProcessing(0).Description = _ Direct3D.CreateFlags.SoftwareVertexProcessing ICurrentSettings.VertexProcessing.Description = _ Direct3D.CreateFlags.SoftwareVertexProcessing End Try Return EnumVertexProcessing End Function

In Zeile 10 wird die Prüfung von Transform and Lighting durchgeführt. Wird der abgefragte Typ unterstützt, dann wird dieser dem Array EnumVertexProcessing hinzugefügt.

DXSettings im praktischen Einsatz

159

20.2 DXSettings im praktischen Einsatz Im vorangegangenen Unterkapitel haben wir erläutert, wie Sie die Detailinformationen der Grafikkarte ermitteln. Es ist uns bewusst, dass dieser Teil nicht zur leichten Lektüre gehört. Die vorgestellten Methoden benötigen viele Parameter und die meisten Methoden stehen zudem in einem logischen Zusammenhang. Hier steht nicht zur Debatte, ob Sie sich mit dem Thema beschäftigen wollen, vielmehr sollten wir hinterfragen, wann Sie sich mit dem Thema auseinander setzen. Wir haben dieses Thema relativ früh in das Buch integriert, weil die nachfolgenden Beispielprogramme auf dieser Schnittstelle basieren. Diese Schnittstelle ist ein Garant, um möglichst unterschiedliche Hardware fehlerfrei zu unterstützen. Dennoch halten wir es für legitim, wenn wir uns hier mit der Anwendung der Schnittstelle beschäftigen. Hierbei steht die Praxis im Vordergrund und die technischen Fragen treten zurück. Es ist nicht unbedingt notwendig, die Funktionsweise der Schnittstelle vollkommen zu durchblicken. Es reicht für den Anfang, wenn wir die Schnittstelle einsetzen können. Was war unser Gedanke, als wir die Schnittstelle entwickelten? Zum einen wollten wir eine Schnittstelle, die Fehlerfreiheit gewährleistet. Wir wollten aber auch eine Schnittstelle, die wir konfigurieren können und beider wir Voreinstellungen vornehmen oder Zusatzinformationen einblenden können. Ebenfalls war es wichtig, einen automatischen Ablauf zu integrieren. Hieraus ergeben sich zwei Hauptbestandteile: GUI. Die GUI erlaubt uns eine individuelle Konfiguration der aktuellen Grafikkarte. So ist gewährleistet, dass wir die optimalen Einstellungen finden und keine Ressourcen vergeuden. Preset-Struktur. Die Preset-Struktur erlaubt uns Voreinstellungen vorzunehmen. Hierdurch bleibt es dem Anwender erspart, bei jedem Neustart die Einstellungen wiederum neu angeben zu müssen. Ebenfalls können wir das allgemeine Verhalten der GUI bestimmen, z.B. wird bei einem automatischen Ablauf wird die GUI nicht mehr eingeblendet und der Anwender bemerkt die Schnittstelle nicht.

160

Device Enumeration

Abb. 42. Ablaufplan DXSettings

Über die Presets geben wir unsere Wunschliste an. Diese Einstellungen sind individuell auf das jeweilige Programm abgestimmt. Sollten die Presets Einstellungen beinhalten, welche nicht verfügbar sind, weil z.B. die Grafikkarte diese Fähigkeit nicht besitzt, dann werden die Einstellungen von der GUI übernommen. Letztendlich können wir über die GUI die Einstellungen immer ändern. Praktisch an der GUI ist, dass alle Einstellmöglichkeiten, welche angeboten werden, den tatsächlichen Fähigkeiten der Grafikkarte entsprechen. 20.2.1 Preset-Struktur Über die Preset-Struktur können wir das Verhalten des DXSettings-Tools steuern. Hierzu verschaffen wir uns zunächst einen Überblick. 1 2 3 4 5

Public Structure CurrentSettings Public DisplayAdapter As DisplayAdapterInformation Public DeviceType As DeviceTypesInformation Public VideoMode As VideoModeInformation Public BackBufferFormat As BackBufferFormatInformation

DXSettings im praktischen Einsatz 6

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

161

Public DepthStencilBufferFormat As _ DepthStencilBufferFormatInformation Public MultiSampleType As MultiSampleTypeInformation Public VertexProcessing As VertexProcessingInformation Public PresentInterval As PresentIntervalInformation Public SelectedAdapterID As Integer Public SelectedDeviceID As Integer Public SelectedVideoModeID As Integer Public SelectedBackBufferFormatID As Integer Public SelectedDepthStencilBufferFormatID As Integer Public SelectedMultiSampleTypeID As Integer Public SelectedVertexProcessingID As Integer Public SelectedPresentIntervalID As Integer Public AusgabeHandle As System.Windows.Forms.Control Public WindowsEnable As Boolean Public Windows_Resize_and_Replace As Boolean Public WindowsInformationen As WindowsInformationen Public AllowToCreateD3DDevice As Boolean Public Automatic As Boolean Public AdvanceGUI As AdvanceGUI End Structure

Lassen Sie sich bitte nicht davon irritieren, dass die Struktur den Namen CurrentSettings trägt. Wenn wir die Struktur in ein Projekt integrieren, deklarieren wir eine Variable (namens Preset) mit dem Datentyp CurrentSettings. Somit haben wir unsere Presets-Struktur geschaffen. In den Zeilen 2 - 9 finden Sie die Einträge, welche zum Erstellen des Direct3D-Devices notwendig sind. In den Zeilen 10 - 17 finden Sie IDEinträge. Diese IDs sind einzigartig und garantieren eine Unverwechselbarkeit der ausgewählten Elemente. In den Zeilen 18 - 24 finden wir Einträge, welche das allgemeine Verhalten steuern. Dies wollen wir uns etwas genauer ansehen: Zeile 18. Hier wird das Ausgabehandle angegeben. Das kann eine Windows-Form oder eine Picturebox sein. Zeile 19. Wenn Sie WindowsEnable auf True setzen, dann startet Ihr Programm im Fenstermodus. Anderenfalls wird im Vollbildmodus gestartet. Zeile 20. Im Fenstermodus können Sie die aktuelle Position und Größe des Ausgabehandles verändern. Um dies zu ermöglichen, muss der Parameter Windows_Resize_and_Replace den Wert True annehmen. Zeile 21. Wenn Sie die Position und Größe des Ausgabehandles verändern wollen, dann können Sie hier die Werte einstellen.

162

Device Enumeration

Zeile 22. AllowToCreateD3DDevice ermöglicht das Erstellen des Direct3D-Devices. Sollte dieser Parameter den Wert False haben, dann wird das Tool das Device nicht erstellen. Zeile 23. Wenn Automatic den Wert True hat, dann wird das Direct3D-Device automatisch erstellt. Der Benutzer bekommt von den Aktionen nichts mit. Zeile 24. AdvanceGUI erlaubt das Einblenden eines zusätzlichen Informationsfeldes. Diese wird rechts neben der eigentlichen GUI eingeblendet. 20.2.2 DXSettings initialisieren Was müssen wir tun, um DXSettings in ein neuen Projekt (Programm) einzubinden? Zunächst müssen wir die benötigten Module in das neue Projekt einbinden. Dies erfolgt im Projekt-Explorer mit einem Klick der rechten Maustaste auf „Hinzufügen/Vorhandenes Element hinzufügen“. Anschließend wählen Sie diese beiden Dateien: • DXSettings.vb • frm_Settings.vb Beide Dateien finden Sie auf der beiliegenden CD in dem Ordner DXSettings. Nachdem die Dateien eingebunden wurden, müssen wir das Tool noch konfigurieren. Zur Demonstration haben wir die Einstellungen aus einem aktuellen Projekt aus der Buch-CD genommen. 1 2

Dim frm As New frm_Settings Dim Preset As CurrentSettings

Zuerst müssen wir neue Instanzen bilden. In den Zeilen 1 und 2 bilden wir jeweils eine Instanz von frm_Settings und deklarieren die Variable Preset mit dem Datentypen CurrentSettings.

8

Preset.WindowsInformationen.Width = 600 Preset.WindowsInformationen.Height = 600 Preset.WindowsInformationen.Top = 250 Preset.WindowsInformationen.Left = -1000 Preset.WindowsEnable = True Preset.Windows_Resize_and_Replace = True

9

Preset.VideoMode.Width = 1024

3 4 5 6 7

DXSettings im praktischen Einsatz 10 11 12

13

14

15

16

17

18 19

20 21 22

23 24

25

163

Preset.VideoMode.Height = 768 Preset.VideoMode.RefreshRate = 200 Preset.VideoMode.Format = Microsoft.DirectX.Direct3D.Format.X8R8G8B8 Preset.BackBufferFormat.Description = Microsoft.DirectX.Direct3D.Format.X8R8G8B8 Preset.DepthStencilBufferFormat.Description = Direct3D.DepthFormat.D24X8 Preset.MultiSampleType.Description = Direct3D.MultiSampleType.None Preset.VertexProcessing.Description = Direct3D.CreateFlags.PureDevice Preset.PresentInterval.Description = Direct3D.PresentInterval.Immediate Preset.AdvanceGUI.Enable = True Preset.AdvanceGUI.Picture = Application.StartupPath + "\..\DXSettingsScreenShot.bmp" ReDim Preserve Preset.AdvanceGUI.Text(4) Preset.AdvanceGUI.Text(0) = "DXSettings" Preset.AdvanceGUI.Text(1) = "Diese Applikation hilft Ihnen beim Erstellen eines Direct3D-Devices." Preset.AdvanceGUI.Text(2) = "" Preset.AdvanceGUI.Text(3) = "Presets, automatische Konfiguration und Advance-Mode sind " Preset.AdvanceGUI.Text(4) = "besondere Highlights dieser Applikation"

26

Preset.Automatic = False

27

Preset.SelectedAdapterID = 1 'secondary Adapter

In den Zeilen 3–27 konfigurieren wir das Tool. Dies haben wir in dem vorhergehenden Abschnitt bereits besprochen. 28

frm.DX.SetPreset = Preset

Mit der Anweisung in Zeile 28 übermitteln wir dem Tool, welche PresetStruktur verwendet werden soll. Grundsätzlich könnten wir uns unterschiedliche Strukturen anlegen und je nach Bedarf die passende auswählen. 29

frm.DX.SetAusgabeHandle = Me

Indem wir dem Ausgabehandle den Wert Me zuweisen, wird die aktuelle Windwos Form zum Handle gemacht.

164 30 31 32 33 34 35 36

Device Enumeration

If frm.DX.CurrentSettings.Automatic = True Then frm.DX.EnumAllDirect3D = True D3D = frm.DX.CreateDirect3DDevice() Else frm.ShowDialog(Me) D3D = frm.DX.CreateDirect3DDevice() End If

Je nachdem, ob wir einen automatischen Ablauf benötigen oder nicht, erstellen wir das Device entweder mit Einblenden der GUI oder ohne. Automatic = True bedeutet, die GUI wird nicht eingeblendet.

21 Matrizen

Sie haben bereits einige Matrizen kennen gelernt. Denken Sie an die World-, View- und Projektionsmatrix. Nun wollen wir uns mit dem mathematischen Hintergrund beschäftigen. Hierbei wird es nicht notwendig sein, ein mathematisches Studium absolviert zu haben. Vielmehr geht es uns um den praktischen Einsatz. Wie kann ich ein Objekt skalieren, bewegen oder drehen? Kann ich auch die gesamte 3D-Welt drehen?

21.1 Was ist eine Matrix Eine Matrix ist eine Tabelle ähnlicher Anordnung von Zahlen. Die Zeilen werden durch die Variable m und die Spalten durch die Variable n festgelegt.

ª M 1,1 « M 2,1 « « M 3,1 « « ... «¬ Mm ,1

M 1, 2 M 2, 2 M 3, 2 ... Mm, 2

M 1,3 M 2,3 M 3, 3 ... Mm,3

... ... ... ... ...

M 1, n º M 2, n »» M 3, n » = M » ... » Mm, n »¼

Wenn wir ein bestimmtes Feld aus der mxn-Matrix ansprechen möchten, identifizieren wir diese Stelle durch die tiefer gestellten Zahlen. M3,4 bedeutet: dritte Zeile, vierte Spalte der Matrix M. Das Komma in der Schreibweise können wir auch weglassen. Diese verkürzte Schreibweise ist bei Matrizen, deren Zeilen- und Spaltenzahl kleiner zehn ist, vollkommen legitim. Wir werden uns unter DirectX lediglich mit 4x4-Matrizen beschäftigen.

166

Matrizen

21.1.1 Einheitsmatrix Die Einheitsmatrix wird auch neutrale Matrix oder Identitätsmatrix genannt. Wenn eine Matrix mit der Einheitsmatrix multipliziert wird, wird sie nicht verändert. Unter DirectX sieht die Einheitsmatrix wie folgt aus:

ª1 «0 « «0 « ¬0

0 0 0º 1 0 0»» 0 1 0» » 0 0 1¼

Eine Einheitsmatrix ist immer quadratisch. Sie besitzt die gleiche Anzahl von Zeilen und Spalten. 21.1.2 Addition Die Addition von Matrizen ist denkbar einfach. Unter der Voraussetzung, dass die Matrizen von gleicher Größe sind, werden die einzelnen Elemente miteinander addiert.

ª0 0 «0 0 « «0 0 « ¬6 12

0 0 0 5

0 º ª0 0»» ««0 + 0 » «0 » « 0¼ ¬1

0 0 0 2

0 0 0 9

0º ª0 0 0 0»» ««0 0 0 = 0» «0 0 0 » « 0¼ ¬7 14 14

0º 0»» 0» » 0¼

21.1.3 Subtraktion Bei der Subtraktion zweier Matrizen werden die einzelnen Elemente beider Matrizen voneinander subtrahiert.

ª0 «0 « «0 « ¬6

0 0 0 12

0 0 0 5

0 º ª0 0 »» ««0 − 0 » «0 » « 0 ¼ ¬1

0 0 0 2

0 0 0 9

0º ª 0»» «« = 0» « » « 0¼ ¬

0 0 0 5

0 0 0 10

0 0 0 −4

0 0 0 0

º » » » » ¼

Was ist eine Matrix

167

21.1.4 Multiplikation Wir wollen Matrix A mit Matrix B multiplizieren. Das Ergebnis wird Matrix C. A x B = C

Matrizen können nur miteinander multipliziert werden, wenn Matrix A die gleiche Anzahl Spalten hat wie Matrix B Zeilen. Daraus ergibt sich, dass Matrix C so viele Zeilen hat wie die Anzahl der Spalten von Matrix A und so viele Spalten wie Matrix B Zeilen. Ganz wichtig zu erwähnen ist, dass das Kommutativgesetz bei Matrizen ungültig ist. In der Mathematik bezeichnet man ein Verknüpfung als kommutativ, wenn man ihre beiden Argumente vertauschen darf. A x B

ist ungleich

B x A

Hier ein richtiges Beispiel:

ª2 6º ª1 2 5 º « » ª33 49º «3 4 2» * «3 4» = «28 48» ¼ «5 7 » ¬ ¬ ¼ ¬ ¼ 1 * 2 + 2 * 3 + 5 * 5 = 331 * 6 + 2 * 4 + 5 * 7 = 49 3 * 2 + 4 * 3 + 2 * 5 = 283 * 6 + 4 * 4 + 2 * 7 = 48

Zwei Matrizen A und B werden miteinander multipliziert, indem jeweils die Zeilenelemente der ersten Matrix mit den entsprechenden Spaltenelementen der zweiten Matrix multipliziert und anschließend addiert werden. 21.1.5 Division Die Division erfolgt bei Matrizen durch die Multiplikation mit dem Kehrwert. Wenn wir eine Zahl mit dem eigenen Kehrwert multiplizieren, erhalten wir den Wert 1. Auf Matrizen übertragen, bedeutet das, dass eine Matrix multipliziert mit dem eigenen Kehrwert die Einheitsmatrix ergibt.

168

Matrizen

ª1 11 56 6 º ª1 «3 1 1 34» « « » * Kehrwert = «0 «2 0 2 1 » «0 « » « ¬7 2 3 4 ¼ ¬0

0 1 0 0

0 0 1 0

0º 0»» 0» » 1¼

Bei Matrizen spricht man nicht von Kehrwert, sondern von invertierter Matrix. Eine invertierte Matrix wird durch ein hochgestelltes –1 dargestellt. Die invertierte Matrix oder auch Inverse von Matrix A wäre dann -1 A . -1

21.1.6 Berechnen der invertierten Matrix M

Die Matrix M wird durch geeignete Zeilenumformung in die Einheitsmatrix überführt. Alle Umformungen werden parallel mit der Einheitsmatrix -1 durchgeführt. Daraus ergibt sich als Ergebnis die invertierte Matrix M . Hierzu betrachten wir ein Beispiel: Matrix M

Einheitsmatrix

ª3 5 1 º «2 4 5» « » «¬1 2 2»¼

ª1 0 0º «0 1 0 » « » «¬0 0 1»¼

Schritt 1: Vertausche Zeile 1 und Zeile 3

ª1 2 2º «2 4 5» « » «¬3 5 1 »¼

ª0 0 1 º «0 1 0 » « » «¬1 0 0»¼

Schritt 2: Subtrahiere das Doppelte der 1. Zeile von der 2. Zeile

ª1 2 2º «0 0 1 » « » «¬3 5 1 »¼

ª0 0 1 º «0 1 − 2 » « » «¬1 0 0 »¼

Schritt 3: Subtrahiere das Dreifache der 1. Zeile von der 3. Zeile

2º ª1 2 «0 0 1 »» « «¬0 − 1 − 5»¼

ª0 0 1 º «0 1 − 2 » « » «¬1 0 − 3»¼

Transformation

169

Schritt 4: Vertausche Zeile 2 mit Zeile 3. Anschließend multipliziere die zweite Zeile mit –1.

ª1 2 2 º «0 1 5 » « » «¬0 0 1 »¼

ª0 0 1 º «− 1 0 3 » « » «¬ 0 1 − 2»¼

Schritt 5: Subtrahiere das Doppelte der 2. Zeile von der 1. Zeile

ª1 0 − 8º «0 1 5 » « » «¬0 0 1 »¼

ª 2 0 − 5º «− 1 0 3 » « » «¬ 0 1 − 2»¼

Schritt 6: Subtrahiere das Fünffache der 3. Zeile von der 2. Zeile

ª1 0 − 8º «0 1 0 » « » «¬0 0 1 »¼

0 − 5º ª2 «− 1 − 5 13 » « » «¬ 0 1 − 2»¼

Schritt 7: Addiere das Achtfache der 3. Zeile zur 1. Zeile

ª1 0 0 º «0 1 0 » « » «¬0 0 1»¼

8 − 21º ª2 «− 1 − 5 13 » « » «¬ 0 1 − 2 »¼

Einheitsmatrix

invertierte Matrix M-1

21.2 Transformation Wenn wir ein Objekt (dreidimensionales Modell) in der 3D-Welt bewegen, skalieren oder drehen wollen, sprechen wir von einer Transformation. Dies ist eine komplexe Aufgabe, die durch relative Koordinaten der Objekte zusätzlich erschwert wird. Ein Modell, dessen Spitze auf den Koordinaten X = 10, Y = 0 und Z = 0 liegt, würde bei einer Positionierung in der 3D-Welt neue Koordinaten bekommen. Nehmen wir an, wir weisen dem Objekt folgende Position zu: X = 5, Y = 5, Z = 5. Die absoluten Koordinaten für das Modell würden sich wie folgt ändern: relative Koordinaten des Modells + Position = absolute Koordinaten Vektor (10, 0, 0) + Vektor( 5, 5, 5) = Vektor(15, 5, 5) Für die folgenden Berechnungen ist es wichtig, dass wir uns an die DirectX-Matrixform erinnern. DirectX arbeitet mit einer 4x4-Matrix. Anhand

170

Matrizen

dieser Matrix können wir Objekte verschieben, vergrößern und verkleinern oder drehen. 21.2.1 Bewegt sich die Welt oder bewegt sich das Objekt? Wir werden Ihnen einige Techniken präsentieren, mit denen Sie Objekte in der 3D-Welt bewegen, skalieren oder rotieren lassen können. Hierbei stellt sich die Frage: Verändern wir wirklich das Objekt oder verändern wir die Welt? Die Antwort können wir vorwegnehmen: Wir verändern die Welt. Das einzelne Objekt bleibt dabei unberührt. Am besten verdeutlichen wir das an einem Beispiel: Wir haben ein Dreieck erstellt. Dieses wird genau an den Koordinaten (0, 0, 0) gerendert. Nun möchten wir das Dreieck etwas nach links verschieben. Hierzu stehen uns zwei Wege offen: • Wir verändern die Vertexdaten und erstellen einen neuen Vertexbuffer. • Wir verschieben die 3D-Welt (über die Worldmatrix) und rendern das Dreieck mit den ursprünglichen Vertexdaten. Wir werden mit unseren Beispielen den zweiten, schnelleren Weg beschreiten. Wenn wir an ein komplexes Objekt denken, z.B. einen Sternenzerstörer mit mehreren tausend Vertices, dann müssen wir jedes Vertex neu berechnen. Gehen wir aber nach der zweiten Technik vor, berechnen wir nur einmal die Worldmatrix neu und können das Objekt sofort wieder rendern. 21.2.2 Translation (Bewegung, Positionsveränderung)

ª1 0 0 «0 1 0 « «0 0 1 « ¬TX TY TZ

0º 0»» 0» » 1¼

Wenn wir ein Objekt in der 3D-Welt bewegen wollen, bewegen wir nicht das Objekt, sondern die 3D-Welt. Wir könnten natürlich auch das Objekt bewegen, dies wäre jedoch mit einem hohen Rechenaufwand verbunden. Wir müssten jeden Vertex des Objektes neu berechnen. Bei sehr komplexen Objekten ist das mit einem spürbaren Performance-Verlust verbunden. Bedenken Sie, dass wir diese Neuberechnung nicht einmal, sondern pro

Transformation

171

Render-Zyklus vornehmen müssten. Bei 30 Frames pro Sekunde wären 30 Neuberechnungen pro Sekunde notwendig. Wir werden also die 3D-Welt verschieben. Hierzu sind folgende Schritte notwendig: • Verschieben der 3D-Welt • Rendern des Objektes • Wiederherstellen der 3D-Welt Wie verschieben wir die 3D-Welt? Hierzu werden wir die Worldmatrix transformieren. Bei unserem Vorhaben werden wir von DirectX unterstützt und wir können die Matrix.Translate()-Methode nutzen. Diese Methode benötigt nur den Parameter v. Dieser bestimmt die neue Position. 1 2 3 4

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.Translate(ByVal v As Vector3) D3DDevice.Transform.World = wMatrix

Falls Sie die angebotene Methode von DirectX nicht nutzen wollen, dürfen Sie die Matrix auch manuell manipulieren. 1 2 3 4 5 6

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.41 = neue_Position_X wMatrix.42 = neue_Position_Y wMatrix.43 = neue_Position_Z D3DDevice.Transform.World = wMatrix

Welche Methode Sie verwenden möchten, bleibt Ihnen überlassen. Es ist nicht immer sinnvoll, die vorgegebenen Methoden von DirectX zu wählen. Manchmal kommt man durch eine direkte Manipulation schneller und eleganter zum Ziel. 21.2.3 Skalieren (Größenänderung)

ª ScaleX « 0 « « 0 « ¬ 0

0

0

ScaleY 0

0 ScaleZ

0

0

0º 0»» 0» » 1¼

172

Matrizen

Größenänderungen sind immer wieder notwendig. Im Laufe der Zeit wird eine kleine Objektbibliothek entstehen. Die meisten Objekte sind auf ein bestimmtes Programm zugeschnitten. Leider arbeiten nicht alle Programme mit gleichen Größeneinheiten. Letztendlich werden Sie die Objektgröße immer wieder anpassen müssen. Das ist aber nicht weiter schlimm. Die Technik, die wir benötigen, ist schnell erläutert. DirectX bietet mit Scale() eine Methode an, welche uns unterstützen wird. Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.Scale(ByVal v As Vector3) D3DDevice.Transform.World = wMatrix

1 2 3 4

Wir übergeben den Vektor v. Bekanntlich beinhaltet ein von uns verwendeter Vektor drei Mitglieder. Diese drei Mitglieder bestimmen den Skalierungsfaktor für die einzelnen Achsen. v.X = Skalierungsfaktor X v.Y = Skalierungsfaktor Y v.Z = Skalierungsfaktor Z

Wenn wir nun folgenden Vektor übergeben (1, 2, 1), dann wird unser Objekt genau doppelt so hoch werden. Sie dürfen die Matrix auch manuell beeinflussen. Hierzu nehmen Sie direkten Einfluss auf die Worldmatrix. 1 2 3 4 5 6

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.11 = wMatrix.11 * Skalierungsfaktor_X wMatrix.22 = wMatrix.22 * Skalierungsfaktor_Y wMatrix.33 = wMatrix.33 * Skalierungsfaktor_Z D3DDevice.Transform.World = wMatrix

21.2.4 Rotation (Drehung) • Rotation X-Achse

0 0 0º ª1 «0 cos sin 0» « » «0 − sin cos 0» « » 0 0 1¼ ¬0

Transformation

173

• Rotation Y-Achse

ªcos « 0 « « sin « ¬ 0

0 − sin 1 0 0 cos 0 0

0º 0»» 0» » 1¼

• Rotation Z-Achse

ª cos sin 0 0º «− sin cos 0 0» « » « 0 0 1 0» « » 0 0 1¼ ¬ 0 Ein dreidimensionales Objekt besitzt drei Achsen. Über diese drei Achsen kann sich das Objekt drehen. Für jede dieser Rotationsmöglichkeiten stellt DirectX uns eine bestimmte Methode zur Verfügung. DirectX.Matrix.RotateX (ByVal angle As Single) DirectX.Matrix.RotateY (ByVal angle As Single) DirectX.Matrix.RotateZ (ByVal angle As Single)

Eigentlich sind diese Methoden selbsterklärend. Dennoch gibt es eine Besonderheit, die wir berücksichtigen müssen. Der übergebene Parameter angel muss in Radiant angegeben werden. Zur Umrechnung gibt es die DegreeToRadian()-Methode. • Rotation X-Achse 3

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.RotateX(DirectX.Direct3D.Geometry.

4

D3DDevice.Transform.World = wMatrix

1 2

DegreeToRadian(Winkel_X))

• Rotation Y-Achse 3

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.RotateY(DirectX.Direct3D.Geometry.

4


1 2

DegreeToRadian(Winkel_Y))

174

Matrizen

• Rotation Z-Achse 3

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.RotateZ(DirectX.Direct3D.Geometry.

4


1 2

DegreeToRadian(Winkel_Z))

Sie dürfen die Matrix auch direkt beeinflussen. Dies demonstrieren wir anhand einer Drehung entlang der X-Achse. 1 2 3 4 5 6 7

Dim wMatrix As DirectX.Matrix wMatrix = D3DDevice.Transform.World wMatrix.22 = wMatrix.22 * math.cos(Winkel_X) wMatrix.23 = wMatrix.23 * math.sin(Winkel_X) wMatrix.32 = wMatrix.32 * (math.sin(Winkel_X)) * -1 wMatrix.33 = wMatrix.33 * math.cos(Winkel_X) D3DDevice.Transform.World = wMatrix

21.2.5 Grad vs Radiant Wenn wir von der Maßeinheit eines Winkels sprechen, meinen wir Grad. Ein Grad entspricht einem 360stel Kreis. Die Maßeinheit Radiant gibt das Verhältnis von Kreisbogen zu Radius an und wird als Bogenmaß bezeichnet. Ein Halbkreis entspricht hierbei PI (3.14159) und 2*PI repräsentieren einen Kreis.

Abb. 43. Grad vs Radiant

Transformation

175

21.2.6 Beispielprogramm für Matrizen Wir haben Ihnen die Basistransformationen des Verschiebens, Skalierens und Rotierens erläutert. Nun ist es an der Zeit, diese Techniken in ein Beispiel zu fassen. Unser Beispiel wird sich hauptsächlich mit der Rotation und der Skalierung beschäftigen. Aber auch die Positionierung werden wir nicht vernachlässigen.

Abb. 44. Screenshoot „Rotate and Scale“

Zur Realisierung des Programms müssen wir folgende Schritte durchführen: • • • • •

Struktur für die Dreiecke anlegen Initialisierung Vertexbuffer erstellen Rendern Transformation

Struktur für die Dreiecke anlegen Wir haben zwei Objekte (Dreiecke). Beide Objekte werden über eine GUI (Graphics User Interface) gesteuert. Eingaben, welche über die GUI erfolgen, werden in eine eigens angelegte Struktur gespeichert. 1 2 3 4

Structure Triangle Dim V1 As DirectX.Vector3 Dim V2 As DirectX.Vector3 Dim V3 As DirectX.Vector3

176 5 6 7 8 9 10 11

Matrizen

Dim Position As DirectX.Vector3 Dim Scale As DirectX.Vector3 Dim RotateX As Single Dim RotateY As Single Dim RotateZ As Single Dim VertexBuffer As Direct3D.VertexBuffer End Structure

Dir Struktur Triangle soll alle notwendigen Informationen aufnehmen, die wir zum Rendern der Dreiecke benötigen. Hierzu gehören drei Vektoren. Diese nehmen die drei Eckpunkte des Dreiecks auf. Außerdem möchten wir Informationen über die Position, Skalierung und den Rotationswinkel speichern. Abschließend soll noch der entsprechende Vertexbuffer erfasst werden. 12

Public geoTriangle(1) As Triangle

Damit wir die Struktur nutzen können, müssen wir eine Variable vom Datentyp Triangle deklarieren. In unserem Fall verwenden wir ein kleines Array. Das Array erhält die Dimension eins und kann somit zwei Dreiecke verwalten. Initialisierung Zur Initialisierung haben wir die Subroutine init()erstellt. 1 2 3 4 5 6 7 8 9 10

11 12

13 14 15

Private Sub init() Dim i As Integer For i = 0 To 1 geoTriangle(i).V1 = New DirectX.Vector3(-1, -1, 0) geoTriangle(i).V2 = New DirectX.Vector3(1, -1, 0) geoTriangle(i).V3 = New DirectX.Vector3(0, 1, 0) geoTriangle(i).Scale = New DirectX.Vector3(1, 1, 1) Select Case i Case 0 geoTriangle(i).Position = _ New DirectX.Vector3(-1, 0, 0) Case 1 geoTriangle(i).Position = _ New DirectX.Vector3(1, 0, 0) End Select Next End Sub

Wir wollen zwei Dreiecke verwenden. Also lassen wir eine For-NextSchleife von 0 bis 1 laufen. Beide Dreiecke sollen in der Grundform exakt gleich sein. Deshalb weisen wir in den Zeilen 4 - 6 beiden Dreiecken die

Transformation

177

gleichen Vertexdaten zu. Ebenfalls sollen beide Dreiecke gleich groß sein. Somit erhalten beide Dreiecke in Zeile 7 die gleichen Skalierungsfaktoren: ScaleX, ScaleY und ScaleZ gleich 1, also Originalgröße. Bei der Positionierung in den Zeilen 8 - 13 wollen wir die Dreiecke unterscheiden. Das erste und das zweite Dreieck sollen unterschiedlich positioniert werden. Vertexbuffer erstellen Der Vertexbuffer ist schnell erstellt. Das liegt natürlich auch daran, dass wir lediglich zwei Dreiecke mit insgesamt sechs Vertices verwenden. Dennoch benötigen wir für jedes Dreieck einen eigenen Vertexbuffer. Würden wir beide Dreiecke in einen Vertexbuffer stecken, könnten wir die Dreiecke nicht mehr unterschiedlich beeinflussen. 1 2

3

4

Private Function CreateTriangle(ByVal Index As Integer) Dim iVertexBuffer As Direct3D.VertexBuffer = _ New Direct3D.VertexBuffer _ (GeType(Direct3D.CustomVertex.PositionColored), 3, _ D3D, Direct3D.Usage.WriteOnly, _ Direct3D.CustomVertex.PositionColored.Format, _ Direct3D.Pool.Default) Dim vb As Direct3D.VertexBuffer = CType(iVertexBuffer, _ Direct3D.VertexBuffer) Dim verts As Direct3D.CustomVertex.PositionColored() = _ CType(vb.Lock(0, 0),_ Direct3D.CustomVertex.PositionColored())

5 6 7 8 9

verts(0).X = geoTriangle(Index).V1.X verts(0).Y = geoTriangle(Index).V1.Y verts(0).Z = geoTriangle(Index).V1.Z verts(0).Color = _ System.Drawing.Color.DarkGoldenrod.ToArgb()

10 11 12 13 14

verts(1).X = geoTriangle(Index).V2.X verts(1).Y = geoTriangle(Index).V2.Y verts(1).Z = geoTriangle(Index).V2.Z verts(1).Color = _ System.Drawing.Color.MediumOrchid.ToArgb()

15 16 17 18 19

20 21 22

verts(2).X = geoTriangle(Index).V3.X verts(2).Y = geoTriangle(Index).V3.Y verts(2).Z = geoTriangle(Index).V3.Z verts(2).Color = System.Drawing.Color.Cornsilk.ToArgb() vb.Unlock() Return iVertexBuffer End Function

178

Matrizen

Als Vertexformat haben wir Direct3D.CustomVertex.PositionColored gewählt. Hierdurch müssen wir lediglich die Koordinaten des Vertex sowie einen Farbwert angeben. Beachten Sie, dass wir die Informationen für die Vertices (Zeilen 6 - 18) aus der Triangle-Struktur lesen. Der Farbwert stammt allerdings nicht aus der Struktur. Wenn Sie wollen, können Sie das Beispiel so umbauen, dass auch der Farbwert in der Struktur gespeichert wird.

Rendern Wir haben folgendes Problem: Wir haben einen fertigen Vertexbuffer. Diesen könnten wir augenblicklich rendern und das Ergebnis unmittelbar auf dem Bildschirm bewundern. Andererseits möchten wir die Dreiecke (bzw. die 3D-Welt) noch skalieren und drehen. Daraus folgt, bevor wir rendern dürfen, müssen wir die Worldmatrix transformieren. 1 2 3 4 5 6

Public Sub Render() Dim i As Integer For i = 0 To 1 Try Dim WorldMatrix As DirectX.Matrix WorldMatrix = D3D.Transform.World

7

Transformation(i)

8

D3D.SetStreamSource(0, _ geoTriangle(i).VertexBuffer, 0) D3D.VertexFormat = _ Direct3D.CustomVertex.PositionColored.Format D3D.DrawPrimitives _ (Direct3D.PrimitiveType.TriangleList, 0, 1)

9

10

11 12 13

14 15 16

D3D.Transform.World = WorldMatrix Catch MessageBox.Show("Fehler in Sub: _ Render_Triangle Nr." & i.ToString) End Try Next End Sub

Die Renderroutine verbirgt keine Geheimnisse. Kommen wir also sofort zu den wichtigen Elementen. Richten Sie Ihr Augenmerk auf die Zeilen 5 und 6. Hier deklarieren wir die Matrix WorldMatrix. Das ist eine temporäre Matrix. Ihr Zweck ist es, die aktuelle 3D-Weltmatrix zu sichern. In Zeile 11 wird die WorldMatrix ihrem Zweck zugeführt und die 3D-Welt-

Transformation

179

Matrix wird wieder restauriert. Warum müssen wir die 3D-Weltmatrix restaurieren? In Zeile 7 rufen wir die Subroutine Transformation() auf. In dieser Subroutine wird die Weltmatrix so manipuliert, wie wir sie zum Rendern eines Dreiecks benötigen. Diese Manipulationen sollen aber nur für das eine spezielle Dreieck gültig sein, deshalb müssen wir die Welt restaurieren, bevor das andere Dreieck gerendert wird. Transformation Nun kommen wir zum Kern dieses Beispielprogramms. Wir transformieren die Welt. Wie funktioniert die Subroutine Transformation()? Wir wollen alles auf einen Schlag erledigen: eine Routine zum Positionieren, Rendern und Skalieren. Dabei gehen wir folgendermaßen vor: Wir nehmen eine Manipulation vor und speichern sie. Anschließend führen wir die nächste Manipulation durch und speichern erneut. So setzt sich das fort bis zur Zeile 29. In Zeile 29 weisen wir die neue, manipulierte Matrix der 3D-Welt zu. 1 2 3 4

5 6 7

8

9 10 11 12

13

14 15 16

17

18

19 20 21

Private Sub Transformation(ByVal Index As Integer) Dim WorldMatrix, tmpMatrix, outMatrix As DirectX.Matrix WorldMatrix = D3D.Transform.World tmpMatrix = DirectX.Matrix.Identity 'Position tmpMatrix.Translate(geoTriangle(Index).Position) outMatrix = DirectX.Matrix.Multiply(tmpMatrix, _ WorldMatrix) WorldMatrix = outMatrix 'scale tmpMatrix = DirectX.Matrix.Identity tmpMatrix.Scale(geoTriangle(Index).Scale) outMatrix = DirectX.Matrix.Multiply(tmpMatrix, _ WorldMatrix) WorldMatrix = outMatrix 'rotate x tmpMatrix = DirectX.Matrix.Identity tmpMatrix.RotateX(DirectX.Direct3D.Geometry. _ DegreeToRadian(geoTriangle(Index).RotateX)) outMatrix = DirectX.Matrix.Multiply(tmpMatrix, _ WorldMatrix) WorldMatrix = outMatrix 'rotate y tmpMatrix = DirectX.Matrix.Identity tmpMatrix.RotateY(DirectX.Direct3D.Geometry. _ DegreeToRadian(geoTriangle(Index).RotateY))

180 22

23

Matrizen outMatrix = DirectX.Matrix.Multiply(tmpMatrix, _ WorldMatrix) WorldMatrix = outMatrix

28

'rotate z tmpMatrix = DirectX.Matrix.Identity tmpMatrix.RotateZ(DirectX.Direct3D.Geometry. _ DegreeToRadian(geoTriangle(Index).RotateZ)) outMatrix = DirectX.Matrix.Multiply(tmpMatrix, _ WorldMatrix) WorldMatrix = outMatrix

29

D3D.Transform.World = outMatrix

24 25 26

27

30

End Sub

22 Texturen

In unseren bisherigen Beispielen haben wir Objekte gerendert, welche glatt und unrealistisch wirken. Eine perfekt glatte Oberfläche, wie die des Dreiecks, werden wir in der Realität nicht finden. Texturen werden uns helfen, eine Oberfläche realistischer wirken zu lassen. So können wir mit Texturen verschiedene Materialien simulieren. Holz, Stein, Metall, aber auch Gras oder Moos werden realitätsnah simuliert. Was ist eine Textur? Eine Textur ist ein Bild, welches über die Dreiecke eines Objektes gelegt wird. Dabei ist es unbedeutend, über welches Objekt sie gelegt werden soll. Stellen wir uns eine drei Meter lange und zwei Meter hohe Wand vor. Über diese Wand können wir eine Steintextur legen. Hierbei ist es nicht von Bedeutung, ob die Wand aus zwei Dreiecken oder zweihundert Dreiecken konstruiert wurde. Mit der Textur wird sie immer gleich aussehen. Von vorne betrachtet wird die Mauer uneben erscheinen. So wie wir es von einer natürlichen Mauer erwarten. Je mehr wir uns aber die Mauer von der Seite aus betrachten, desto stärker erkennen wir, dass die Mauer flach ist. Egal welche Textur wir auf die Mauer legen, sie wird immer absolut flach bleiben. Mit Texturen können wir kein Volumen schaffen. Obwohl Texturen den echten Oberflächen nicht ebenbürtig sind, werden wir in der 3D-Grafik nicht auf sie verzichten können.

22.1 Texturkoordinaten Wir wissen, dass eine Textur über ein 3D-Objekt gelegt wird. Wie können wir uns das aber vorstellen? Nehmen wir ein Blatt Papier und wickeln das Objekt damit ein? Im Grunde ist das so. Wir wickeln das Objekt ein. Was müssen wir dabei beachten? Beim Einwickeln können wir jede Menge Fehler machen. Wir könnten das Objekt seitenverkehrt, verzerrt oder gedreht einwickeln. Außerdem müssen wir darauf achten, dass die gesamte Textur zu sehen ist. Wie eine Textur über ein Objekt gelegt wird, wird durch die Texturkoordinaten bestimmt. Eine Textur ist immer rechteckig. Deshalb wählen wir zur

182

Texturen

Demonstration ein quadratischen Objekt. Unsere Aufgabe besteht darin, eine Textur über ein Quadrat zu legen.

Abb. 45. Textur über ein 3D-Objekt legen

Wenn wir uns die Abbildung betrachten, erkennen wir, dass die Textur genau auf das Objekt passt. Aber das ist ein Trugschluss. Die Texturgröße ist völlig irrelevant. Es ist egal, ob eine Textur aus 128x128 Pixeln oder aus 256x256 Pixeln besteht. Über das Konzept der Texturkoordinaten passt sich die Textur automatisch der Objektgröße an. Diese Technik wird auch generic addressing scheme genannt.

Abb. 46. Texturekoordinaten

Kacheln einer Textur

183

Die maximale Weite einer Textur ist 1. Die maximale Höhe einer Textur ist ebenfalls 1. Das bedeutet, dass wir dem Vertex links oben die Texturkoordinaten 0,0 zuweisen. Der Vertex rechts unten erhält die Texturkoordinaten 1,1.

Abb. 47. Texturkoordinaten mit mehreren Dreiecken

Wie Sie sehen, können wir eine Textur über ein beliebiges Objekt legen. Hierbei ist die Anzahl der verwendeten Dreiecke belanglos.

22.2 Kacheln einer Textur Warum es sinnvoll ist, eine Textur zu kacheln, erklären wir am besten anhand eines Beispiels. Wir wollen eine große Mauer konstruieren: drei Meter hoch und einhundertsiebzig Meter lang. Damit die Mauer auch wie eine Mauer aussieht, müssen wir eine Textur auflegen. Hierzu wählen wir uns ein schönes Steinmuster in der Größe 512x512 Pixel. Und hier fängt das Problem an. Wenn wir 512 Pixel auf einhundertsiebzig Meter verteilen, dann können wir nicht mehr von Pixeln sprechen, sondern von Klötzen. Genauer gesagt, von riesigen Klötzen. Die Lösung des Dilemmas besteht darin, die Textur öfter als einmal auf die Wand zu zeichnen. Das nennt man Kacheln. Schauen wir uns folgende Grafik an:

184

Texturen

Abb. 48. Texturen kacheln

An der Grafik können wir gut erkennen, dass die Textur viel kleiner ist als die beiden Dreiecke. Erinnern Sie sich: Zuvor haben wir gesagt, dass Texturkoordinaten im Bereich von null bis eins liegen. Wenn wir eine Textur kacheln möchten, erhöhen wir diesen Wertebereich. Soll eine Textur horizontal sechsmal dargestellt werden, verwenden wir als maximalen TuWert (horizontale Koordinate) nicht mehr eins, sondern sechs. Gleiches gilt für das vertikale Kacheln. Soll eine Textur viermal vertikal gekachelt werden, ist der maximale Tv-Wert (vertikale Koordinate) vier. In unserer Grafik würde die Textur sechsmal horizontal und viermal vertikal gekachelt. Durch Kachelung ist es möglich, Texturen dynamisch an eine Szene bzw. an ein Objekt anzupassen. Würde es das Mittel Kachelung nicht geben, müssten wir jedes Mal, wenn sich die Größe eines Objektes ändert, auch eine neue Textur erstellen. Das Erstellen von guten Texturen ist eine aufwendige Arbeit. Kachelung stellt hier eine echte Hilfe dar. Letztendlich müssen die Größenverhältnisse innerhalb einer Szene stimmen. Stellen Sie sich eine Hauswand vor, welche mit überdimensionalen Ziegelsteinen gerendert wird. Da können Sie unternehmen, was Sie wollen, die Szene wird nie realistisch wirken. Durch den geschickten Einsatz von Kachelung vermeiden Sie unrealistische Größenverhältnisse.

22.3 Das passende Vertexformat Wenn wir einen Vertexbuffer erstellen, müssen wir DirectX mitteilen, in welchem Format das geschehen soll. Wir benötigen einen Vertexbuffer, der in der Lage ist, die Texturkoordinaten aufzunehmen. Betrachten wir einmal, welche Eigenschaften unser Vertexbuffer erfüllen muss: • Der Vertexbuffer muss die Koordinaten der Vertices speichern. • Der Vertexbuffer muss die Koordinaten der Textur speichern.

Größe einer Textur

185

Direct3D.CustomVertex.PositionTextured kann uns die geforderten Eigenschaften bieten. Betrachten Sie die Bezeichnung PositionTextured. Sie besagt, dass der Vertexbuffer Positionskoordinaten und auch Texturkoordinaten aufnehmen kann. Hierzu folgender Sorcecode: 1Dim

2

3

4 5 6 7 8

iVertexBuffer As Direct3D.VertexBuffer = New Direct3D.VertexBuffer(GetType_ (Direct3D.CustomVertex.PositionTextured), 6, D3Device,_ Direct3D.Usage.WriteOnly,_ Direct3D.CustomVertex.PositionTextured.Format, _ Direct3D.Pool.Default) Dim vb As Direct3D.VertexBuffer = CType(iVertexBuffer, _ Direct3D.VertexBuffer) Dim verts As Direct3D.CustomVertex.PositionTextured() = _ CType(vb.Lock(0, 0), _ Direct3D.CustomVertex.PositionTextured()) verts(0).X = -1 verts(0).Y = -1 verts(0).Z = 0 verts(0).Tu = 0 verts(0).Tv = 1

Im Augenblick sind für uns die Zeilen 4 - 8 von Interesse. Hier erkennen wir die Vertexbuffer-Mitglieder X, Y und Z. Diese nehmen die Positionskoordinaten auf. Weiterhin finden wir die Mitglieder Tu und Tv. Diese nehmen die Texturkoordinaten auf. Hierbei ist Tu für die horizontale Koordinate und Tv für die vertikale Koordinate zuständig.

22.4 Größe einer Textur Als Textur kann eine beliebige 2D-Bitmap verwendet werden. Diese darf in unterschiedlichsten Formaten vorliegen. Einige der unterstützten Formate sind: BMP, JPG, TGA und PNG. Dennoch dürfen Sie als Programmierer nicht schalten und walten, wie Sie wollen. Die Grafikkarte verlangt die Einhaltung fester Regeln. So lassen die Grafikkarten nur eine bestimmte Maximalgröße zu. Viele Grafikkarten verlangen, dass sowohl die Breite als auch die Höhe einer Textur ein Vielfaches von 2 sein muss, z.B. 32x32, 64x64, 128x128, 256x256 oder 512x512. Die Maximalgröße ist oftmals auf 2048x2048 oder 4096x4096 begrenzt. Bei diesen Größen muss man allerdings kritisch hinterfragen, ob das noch Sinn macht. Schließlich muss eine Textur dieser Größe auch verwaltet und gespeichert werden. Ein beliebter Speicherplatz für Texturen

186

Texturen

ist der Speicher der Grafikkarte. Dies macht auch Sinn, da die Grafikkarte sehr oft auf die Texturen zurückgreifen muss. Würde die Textur im Systemspeicher abgelegt, müsste die Textur erst zur Grafikkarte kopiert werden. 22.4.1 Auslesen der maximalen Texturbreite und Höhe Da es die Restriktionen der Grafikkarte in Bezug auf die Texturbreite sowie der Texturhöhe gibt, ist es sinnvoll, die Fähigkeiten der Grafikkarte zu prüfen. Hierzu müssen wir die DeviceCaps befragen. Sehen Sie hier ein Beispiel dafür: 1

2

Dim D3DCaps As Direct3D.Caps = _ Direct3D.Manager.GetDeviceCaps(0, _ Direct3D.DeviceType.Hardware) MsgBox("Maximale Textur-Höhe:“_ & _ D3DCaps.MaxTextureHeight & " _ Maximale Textur-Breite: " & d3dCaps.MaxTextureWidth)

Mit den Methoden D3DCaps.MaxTextureHeight und D3DCaps. MaxTextureWidth Methode können Sie abfragen, welche maximale Größe von Ihrer Grafikkarte unterstützt wird. Je nachdem, welches Ergebnis Sie erhalten, können Sie per Sourcecode reagieren. Für die Stabilität Ihrer Programme ist das ein wichtiger Schritt.

22.5 Laden einer Textur Wir wissen, dass die Grafikkarte auf die Einhaltung korrekter Formate Wert legt. Dies ist auch der Fall, wenn eine Textur geladen werden soll. Das richtige Format ist deshalb so wichtig, weil DirectX die Daten der Textur nicht nur laden muss, sondern die Daten auch interpretiert. Wenn hierbei nicht mit einheitlichen Parametern gearbeitet wird, dann führt dies ins Chaos. DirectX verwendet spezielle Texturformate. DXT1 - DXT6 stellt ein gutes Verhältnis von Speicherbedarf und Geschwindigkeit. DXT1 bietet ein Kompressionsverhältnis von 6 zu 1 zur Verfügung. Je nachdem, wie groß die Texturen sind oder wie viele Texturen Sie verwenden wollen, werden Sie die Kompressionsmöglichkeiten zu schätzen wissen. Dennoch dürfen Sie auch die konventionellen Formate angeben, wie z.B. Format.R5G6B5 oder X8R8G8B8.

Laden einer Textur

187

DirectX wäre nicht DirectX, wenn wir nicht ausreichend unterstützt würden. So stellt uns DirextX die Methode Direct3D.TextureLoader. FromFile zur Verfügung. 1

2

3

4

5

public Texture FromFile (Device, String, Width, Height, _ 0,Format, Pool, Filter, Filter, ColorKey) public Texture FromFile (Device, String, Int32, Int32, _ Int32, Usage, Format, Pool, Filter, Filter, Int32, _ PaletteEntry) public Texture FromFile (Device, String, Int32, Int32, _ Int32, Usage, Format, Pool, Filter, Filter, Int32, _ ImageInformation) public TextureFromFile (Device, String, Int32, Int32, _ Int32, Usage, Format, Pool, Filter, Filter, Int32, _ ImageInformation, PaletteEntry) public TextureFromFile (Device, String)

Diese Methode steht insgesamt in fünf Varianten bereit. Da wir im Augenblick nur eine Textur laden möchten, reicht uns die Variante fünf. Diese besitzt lediglich zwei Parameter. Zum einen müssen wir das Direct3DDevice und zum anderen den Bitmap-Pfad angeben. Bei dieser Variante sollten Sie beachten, dass Sie die Größe der Textur nicht beeinflussen. Diese richtet sich nach der Größe der Bitmap. Hier wollen wir noch auf die Variante eins eingehen. Diese Variante verwenden wir, wenn wir transparente Texturen laden möchten. public Texture FromFile (Device, String, Width, _ Height, 0, Format, Pool, Filter, Filter, ColorKey) Tabelle 6. Parameter der Methode TextureFromFile Parameter Device String Width, Height Format Pool

ColorKey

Beschreibung Direct3D-Device Pfad zur Bitmap Breite und Höhe für die Textur. Sollte die Bitmap von diesen Werten abweichen, wird die Bitmap automatisch skaliert. Entweder ein spezielles Texturformat DXT1 - DXT6 oder ein Standardformat wie: R5G6B5 oder X8R8G8B8 Hier wird festgelegt, wie die Textur gespeichert werden soll. Indem wir Pool.Managed wählen, überlassen wir die Entscheidung DirectX. Hiermit wählen wir die Farbe, welche innerhalb der Textur transparent werden soll, z.B.

Drawing.Color.Black.ToArgb

188

Texturen

22.6 Texturfilter Die Hauptaufgabe von Texturfiltern ist es, die ungeliebten Artefakte in der Bilddarstellung zu verhindern. DirectX steht immer vor der Aufgabe, eine von uns (durch den Sourcecode) beschriebene 3D-Welt auf einen zweidimensionalen Monitor darstellen zu müssen. Insbesondere Texturen werden dabei verkleinert, vergrößert oder verzerrt. Letztendlich muss die Textur perspektivisch korrekt auf das Objekt passen. Ein elementares Problem ist die Annäherung an ein Objekt. Wenn wir immer näher auf eine Wand zulaufen, werden die einzelnen Pixel (bzw. Texel der Textur) immer größer. DirectX muss nun kontinuierlich entscheiden, in welcher Farbe ein bestimmtes Pixel dargestellt werden soll. Texturfilter können Artefakte verhindern bzw. vermeiden. Hierbei unterscheidet DirectX vier Berechnungsmethoden: 22.6.1 MinFilter und MagFilter Wir werden Ihnen gleich verschiedene Filtertechniken präsentieren. Jeder Filter hat mit zwei elementaren Problemen zu kämpfen: 1. Wie kann ich eine Textur verkleinern? 2. Wie kann ich eine Textur vergrößern? Wie wir wissen, sollen Texturfilter visuelle Artefakte vermeiden oder zumindest vermindern. Hierbei müssen wir die Verkleinerungs- und Vergrößerungsproblematik getrennt betrachten. Zum Verkleinern wird der so genannte MinFilter verwendet. Zum Vergrößern kommt der MagFilter zum Einsatz. Wichtig zu beachten ist, dass beide Filter für jede Texturschicht (siehe Abschnitt 21.7.4) verwendet werden können. 1

2

D3DDevice.SamplerState(0).MinFilter = _ Direct3D.TextureFilter D3DDevice.SamplerState(0).MagFilter = _ Direct3D.TextureFilter

22.6.2 Nearest Point Sampling Die Nearest-Point-Sampling-Methode gehört zu den Pionieren der Filtertechniken. Das Berechnungsprinzip ist einfach. Der Grundgedanke ist, dass Pixel auf dem Monitor immer als Ganzzahlkoordinate angegeben werden. Also werden alle Fließkommawerte gerundet. Hierdurch soll das wahrscheinlichste Texel (ein Texel ist ein Pixel einer Textur) selektiert

Texturfilter

189

werden. Natürlich ist diese Berechnung äußerst schnell, aber auch enttäuschend schlecht. Heute wird dieser Filter nicht mehr eingesetzt. Vielleicht könnte man über den Einsatz nachdenken, wenn es zu immensen Performance-Problemen kommt. Allerdings kann auch dann nur der Grundsatz lauten: Besser einen schlechten Texturfilter als überhaupt keinen. 1 2

D3DDevice.SamplerState(0).MinFilter = TextureFilter.Point D3DDevice.SamplerState(0).MagFilter = TextureFilter.Point

22.6.3 Linearer Texturfilter Ein echter Fortschritt ist der lineare Filter. Dieser ist auch als bilinearer Filter bekannt. Das gute Ergebnis und die verträgliche Rechenzeit machen diesen Filter zu dem beliebtesten Filtern. Spielehersteller schwören auf ihn. Bei aktivierter bilinearer Filterung wirken Texturen auf den ersten Blick etwas verwaschen. Kanten werden geglättet und Polygonübergänge verschleiert. Eigentlich sind das alles negative Eigenschaften, aber in der Summe sorgt der Filter für ein weiches harmonisches Bild. Die angewandte Mathematik ist wesentlich aufwendiger (durch den Source-Code) als eine einfache Rundung wie bei dem Nearest-Point-Sampling. Der bilineare Filter verwendet immer vier Texel einer Textur und ermittelt so einen Mittelwert, welcher dann als Pixel verwendet wird. Die Farbwerte der einzelnen Texel fließen nicht zu gleichen Teilen in die Berechnung ein. Jedes Texel erhält eine Gewichtung und somit eine starke oder schwache Dominanz. 1

2

D3DDevice.SamplerState(0).MinFilter = _ TextureFilter.Linear D3DDevice.SamplerState(0).MagFilter = _ TextureFilter.Linear

22.6.4 Anisotropic Filter (uneinheitlicher Filter) Dies ist eine der wenigen Techniken, welche von Direct3D unterstützt werden und deren Algorithmus nicht bekannt ist. Der Algorithmus ist von der Grafikkarte abhängig. Je nachdem, welchen Algorithmus der Hersteller der Grafikkarte implementiert hat, ist das Ergebnis besser oder schlechter. Dies ergibt einen Interpretationsspielraum, welcher von den Herstellern gern genutzt wird. So macht es sich doch für die Werbung gut, wenn man mit hohen Werten prahlen kann. Vielleicht ist aber auch nur der Algorithmus minderwertig bzw. die Performance optimiert. Dennoch gibt es einen Grundsatz zur Berechnung des uneinheitlichen Filters. Ähnlich wie beim

190

Texturen

linearen Filter, wird auch hier ein Mittelwert gebildet. Nur diesmal wird die perspektivische Verzerrung berücksichtigt. 1

2

D3DDevice.SamplerState(0).MinFilter = _ TextureFilter.Anisotropic D3DDevice.SamplerState(0).MagFilter = _ TextureFilter.Anisotropic

22.6.5 Bilineare und uneinheitliche Filterung Die Stärke der bilinearen Filterung liegt eindeutig bei der direkten Sicht auf eine Fläche. Das heißt, die Polygonfläche steht senkrecht zum Betrachter. Das liegt daran, dass der bilineare Filter eine rechteckige Fläche verwendet, um den Mittelwert zu bilden. Leider gibt es in einer Szene nicht viele senkrecht stehende Flächen. Dieser Umstand ist die Geburtsstunde des uneinheitlichen Filters. Wir müssen die perspektivische Verzerrung berücksichtigen. Der Gedanke ist gut, aber die technische Umsetzung umso schwieriger. Komplizierte Algorithmen verlangen mehr Rechenleistung, werden aber auch ein erstklassiges Ergebnis liefern. Dennoch finden wir die guten Algorithmen nicht oft, so dass viele Grafikkarten einen schnelleren Algorithmus implementiert haben. 22.6.6 Mipmaps Wir haben öfter erwähnt, dass das Problem der Texturfilter die Vergrößerung und die Verkleinerung von Texturen ist. Riesige Texturen von 2048x2048 auf winzige Polygone von 20x20 gerendert, erhöhen das Risiko von auftretenden visuellen Artefakten. Polygone haben folgende Eigenschaften: Liegen sie tief im Hintergrund, wirken sie kleiner, und liegen sie direkt vor unserer Nase, dann wirken sie viel größer. Jetzt wäre es doch ideal, wenn wir für unterschiedliche Entfernungen unterschiedlich große Texturen verwenden würden. Für Polygone, welche im Hintergrund liegen, würden wir kleine Texturen einsetzen, und für Polygone im Vordergrund kämen große Texturen zum Einsatz. Hierdurch müssten die Texturen nicht so stark skaliert werden. Weniger stark skaliert bedeutet auch, dass wir nur mit wenigen Artefakten rechnen müssen. Genau das ist die Arbeitsweise von Mipmaps bzw. von Mip-Mapping: Es wird eine Mipmap-Kette gebildet. Hierbei hat jede Stufe genau die halbe Höhe und Breite der vorangegangenen Stufe. Hier ein Beipiel:

Beispielprogramm für Texturen Level Level Level Level

0 1 2 3

64 128 256 512

x x x x

191

64 128 256 512 usw.

22.7 Beispielprogramm für Texturen Dieses Programm soll die Verwendung von Texturen demonstrieren. Hierzu werden wir eine einfache Fläche (bestehend aus zwei Dreiecken) erzeugen. Auf die entstandene quadratische Fläche werden wir die Textur legen. Wir haben das Programm bewusst klein gehalten. Hierdurch erleichtern wir den Einstieg in die Thematik der Texturen. Wichtig ist, dass Sie die eingesetzte Technik erkennen. Hierzu gehören sowohzl die richtige Verwendung der Texturkoordinaten als auch der korrekte Einsatz des richtigen Vertexformats. Um den Erfolg bewerten zu können, haben wir eine Textur gewählt, welche bei korrekter Verwendung entsprechend den Texturkoordinaten aufgelegt wird. Außerdem sollten Sie den Schriftzug in der Mitte richtig lesen können. Als zusätzliches Gimmick lassen wir eine Messagebox erscheinen, welche Sie über die maximale Texturbreite und -höhe informiert. Auf eine Auswertung dieser Informationen haben wir bei diesem kleinen Programm verzichtet. Wenn Sie wollen, können Sie das Programm entsprechen ergänzen.

Abb. 49. Beispielprogramm für Texturen

192

Texturen

Voraussetzungen für dieses Programm sind: • • • •

Ermitteln der maximalen Texturbreite und -höhe Erstellen des Vertexbuffers Erstellen und Laden einer Textur Rendern

22.7.1 Ermitteln der maximalen Texturbreite und -höhe Nachdem Sie die Grafikkarteneinstellungen vorgenommen haben, erscheint ein Infofenster, welches Sie über die maximale Texturgröße Ihrer Grafikkarte informiert.

Abb. 50. Infofenster - Texturbreite und -höhe

Diese Infos erhalten wir über die DeviceCaps. Die Abfrage ist nicht sonderlich kompliziert und somit leicht integrierbar. 1

2

Dim d3dCaps As Direct3D.Caps =_ Direct3D.Manager.GetDeviceCaps(0,_ Direct3D.DeviceType.Hardware) MsgBox("Maximale Textur-Höhe: " & _ d3dCaps.MaxTextureHeight & " ___ Maximale Textur-Breite:_ " & d3dCaps.MaxTextureWidth)

In Zeile 1 verwenden wir die GetDeviceCaps()-Methode. Diese Methode benötigt zwei Parameter. Der erste Parameter verlangt den Index der verwendeten Grafikkarte (Adapter). Bei der primären Grafikkarte ist das der Index 0. Sollten Sie zwei oder mehr Grafikkarten in Ihrem System verbaut haben, können Sie diesen Wert entsprechend ändern: für die zweite Grafikkarte Index 1, für die dritte Index 2 usw. Der zweite Parameter gibt den Device-Typ an. Da wir die Hardwarefähigkeiten ermitteln wollen, setzen wir den Wert auf DeviceType.Hardware. Die entstpechende Syntax lautet:

Beispielprogramm für Texturen 1

193

Public Shared Function GetDeviceCaps( _ ByVal adapter As Integer, _ ByVal deviceType As DeviceType) As Caps

22.7.2 Erstellen des Vertexbuffers Der Vertexbuffer soll insgesamt sechs Vertices aufnehmen. Somit sind das drei Vertices pro Dreieck. Doch bevor wir Daten in den Buffer schreiben können, müssen wir den Buffer deklarieren. 1

Public vbWand As Direct3D.VertexBuffer

Nachdem wir den Vertexbuffer deklariert haben, könne wir diesen mit Daten füllen. Hierzu rufen wir die Subroutine CreateVertexBuffer() auf. Diese wiederum ruft die Funktion CreateWall() auf. Sollten Sie sich fragen, warum wir diesen zwei Methoden verwenden, sollten Sie bedenken, dass wir in späteren Projekten mehr als nur einen Vertexbuffer erstellen. Dann können wir über die Subroutine CreateVertexBuffer() alle benötigten Buffer mit einem Aufruf erstellen. Außerdem ist ein zentraler Aufruf auch dann hilfreich, wenn z.B. das LostDeviceEreignis auftritt. Dieses Ereignis wird u.a. beim Verschieben oder bei einer Größenänderung des Ausgabefensters ausgelöst. Kommen wir nun zur eigentlichen Routine. CreateWall() füllt den Vertexbuffer mit Daten. Sie sollten insbesondere auf das verwendete Vertexformat achten. 1 2

3

4

Private Function CreateWall() As Direct3D.VertexBuffer Dim iVertexBuffer As Direct3D.VertexBuffer = New _ Direct3D.VertexBuffer(GetType(Direct3D.CustomVertex. _ PositionTextured), 6, D3Device, _ Direct3D.Usage.WriteOnly, _ Direct3D.CustomVertex.PositionTextured.Format, _ Direct3D.Pool.Default) Dim vb As Direct3D.VertexBuffer = CType(iVertexBuffer, _ Direct3D.VertexBuffer) Dim verts As Direct3D.CustomVertex.PositionTextured() = _ CType(vb.Lock(0, 0), _ Direct3D.CustomVertex.PositionTextured())

In Zeile 2 definieren wir das Vertexformat. Der Vertexbuffer muss die Positionskoordinaten der Vertices aufnehmen können und die Texturkoordinaten der Textur erfassen. Daraus folgt die Verwendung von Direct3D.CustomVertex.PositionTextured. Das Schlüsselwort Position zeigt das Vorhandensein von Positionskoordinaten an.

194

Texturen

Das Schlüsselwort Textured bedeutet die Verwendung einer Textur und somit die Notwendigkeit von Texturkoordinaten. Texturkoordinaten werden horizontal mit Tu und vertikal mit Tv bezeichnet. 5 6 7 8 9

10 11 12 13 14

15 16 17 18 19

verts(0).X = -1 verts(0).Y = -1 verts(0).Z = 0 verts(0).Tu = 0 verts(0).Tv = 1 verts(1).X = -1 verts(1).Y = 1 verts(1).Z = 0 verts(1).Tu = 0 verts(1).Tv = 0 verts(2).X = 1 verts(2).Y = 1 verts(2).Z = 0 verts(2).Tu = 1 verts(2).Tv = 0

In den Zeilen 5 - 19 definieren wir die drei Ecken des ersten Dreiecks. Zeile 5 - 9: Die Koordinaten der linken unteren Ecke werden bestimmt. Zeile 10 - 14: Die Koordinaten der linken oberen Ecke werden bestimmt. Zeile 15 - 19: Die Koordinaten der rechten oberen Ecke werden bestimmt. 20 21 22 23 24

25 26 27 28 29

30 31 32 33 34

verts(3).X = 1 verts(3).Y = -1 verts(3).Z = 0 verts(3).Tu = 1 verts(3).Tv = 1 verts(4).X = -1 verts(4).Y = -1 verts(4).Z = 0 verts(4).Tu = 0 verts(4).Tv = 1 verts(5).X = 1 verts(5).Y = 1 verts(5).Z = 0 verts(5).Tu = 1 verts(5).Tv = 0

In den Zeilen 20 - 34 definieren wir die drei Ecken des zweiten Dreiecks.

Beispielprogramm für Texturen

195

Zeile 20 - 24: Die Koordinaten der rechten unteren Ecke werden bestimmt. Zeile 25 - 29: Die Koordinaten der linken unteren Ecke werden bestimmt. Zeile 30 - 34: Die Koordinaten der rechten oberen Ecke werden bestimmt. 35 36 37

vb.Unlock() Return iVertexBuffer End Function

Wenn Sie sich die Reihenfolge zum Erstellen der Eckpunkte anschauen, werden Sie feststellen, dass diese im Uhrzeigersinn ausgegeben werden. Laut DirectX-Definition sind das damit Vorderseiten. Gegen den Uhrzeigersinn erstellte Polygone sind als Rückseiten zu bezeichnen.

22.7.3 Erstellen und Laden einer Textur Was müssen wir tun, um eine Textur zu verwenden? Erstens müssen wir ein Variable mit dem Datentyp Direct3D.Texture deklarieren. Zweitens müssen wir der Variablen einen Wert zuweisen. Im Falle der Textur müssen wir eine Textur laden. In diesem Beispielprogramm haben wir folgende Variable deklariert: 1

Public txWand As Direct3D.Texture

Anschließend laden wir eine Textur mit der Direct3D.TextureLoader.FromFile()-Methode. 1

txWand = Microsoft.DirectX.Direct3D_ .TextureLoader.FromFile _ (D3DDevice, DXUtility.FindMediaFile _ ("texturen\Texture-Edge.jpg"))

Wie wir zuvor bereits erklärten, benötigt diese Variante lediglich zwei Parameter: erstens das gültige Direct3D-Device und zweitens den Pfad zu einer texturtauglichen Bitmap. Lassen Sie sich nicht von der Methode DXUtility.FindMediaFile() irritieren. Dies ist eine Helferfunktion, welche lediglich sicherstellen soll, dass die Textur gefunden wird. Sie können auch einen direkten Pfad angeben. Die Verwendung der DXUtility.FindMediaFile()-Methode ist nur für uns sinnvoll. Schließlich wussten wir nicht, wohin Sie den Sourcecode des Buches installieren.

196

Texturen

22.7.4 Rendern Das Rendern von Objekten mit einer Textur unterscheidet sich nur unwesentlich vom Rendern von Objekten ohne Textur. Aus der Spieleschleife (zwischen Direct3D.BeginScene und Direct3D.EndScene) wird die Subroutine Render() aufgerufen. 1 2 3 4 5

6

7 8 9 10

Public Sub Render() Try D3DDevice.SetTexture(0, txWand) D3DDevice.SetStreamSource(0, vbWand, 0) D3DDevice.VertexFormat = _ Direct3D.CustomVertex.PositionTextured.Format D3DDevice.DrawPrimitives _ (Direct3D.PrimitiveType.TriangleList, 0, 2) Catch MessageBox.Show("Fehler in Sub: Render_Wand.") End Try End Sub

Diese Subroutine sollte Ihnen bereits vertraut vorkommen. Das für uns Interessante finden wir in Zeile 3. Hier weisen wir dem aktuellen Renderprozess eine Textur zu. Das nächste zu rendernde Objekt wirn diese Textur erhalten. Natürlich nur dann, wenn die Vertexdaten dies vorsehen. 1

Public Sub SetTexture( _ ByVal stage As Integer, _ ByVal texture As BaseTexture)

Die SetTexture()-Methode verlangt zwei Parameter. Der erste Parameter benennt die Texturebene. Wir könnten auch Texturschicht sagen. DirectX erlaubt es, bis zu acht Schichten übereinander zu legen. Das können Sie sich wie das Übereinanderlegen verschiedener Papierblätter vorstellen. Je nachdem, welches Papier Sie verwenden, werden Sie die unterschiedlichsten Effekte erhalten. Leicht transparentes Papier wird das darunter liegende Papier nicht völlig verdecken. Diese Transparenzeffekte sind auch mit DirectX möglich. DirectX kann aber noch viel mehr. Die einzelnen Texturschichten sind nicht von Transparenz abhängig. Das Kombinieren der Schichten ist noch vielfältiger. Dazu erfahren Sie mehr im Abschnitt über Multitexturing. Zurück zu unserem Beispiel. Wir verwenden eine Textur und legen sie auf die unterste Schicht (0). Als zweiten Parameter wird eine gültige Textur verlangt. Hierbei ist nicht der Pfad zu einer Textur gemeint, sondern die fertige Textur. Diese haben wir bereits deklariert und initialisiert. Die Va-

Multitexturing (Multi Texture Mapping)

197

riable txWand vom Datentyp Direct3D.Texture haben wir zuvor erstellt (siehe: Abschnitt 21.7.3)

22.8 Multitexturing (Multi Texture Mapping) Wir haben gelernt, wie eine Textur auf ein Objekt gelegt werden kann. Im vorangegangenen Abschnitt haben wir bereits angedeutet, dass es auch möglich ist, mehrere Texturen gleichzeitig auf eine Fläche (Objekt) zu legen. Das gleichzeitige Verwenden von mehr als einer Textur nennt man Multitexturing (Multi Texture Mapping). DirectX unterstützt die gleichzeitige Verwendung von bis zu acht Texturen. Hierbei werden die einzelnen Texturen wie Farbschichten übereinander gelegt. Eine Schicht wird Blending-Stage genannt und alle Schichten zusammen ergeben TexturBlending-Kaskade. Wenn wir verschiedene Texturen übereinander legen, macht das nur dann Sinn, wenn die Schichten miteinander kombiniert werden. Eine völlig deckende Textur in der obersten Schicht würde alle darunter liegenden Schichten verdecken. Das wäre völlig sinnlos. Die Texture-Blending-Kaskade hilft uns bei der Organisation der Schichten. Weiterhin beschreibt sie, wie die Schichten miteinander kombiniert werden sollen. Abbildung 51 zeigt eine Illustration der Textur-BlendingKaskade.

Abb. 51. Textur-Blending-Kaskade

198

Texturen

Beim Betrachten der Textur-Blending-Kaskade erkennt man schnell die gigantischen Möglichkeiten, welche sich dem Programmierer/Grafiker eröffnen. Die Möglichkeit, Texturen zu mischen, erspart oftmals das Erstellen neuer Texturen. Beispielsweise könnten wir eine Rasen-Textur in die unterste Texturschicht legen. In eine obere Schicht könnten wir je nach Bedarf einmal Sonnenblumen oder Schneeglöckchen platzieren. 22.8.1 Mischparameter Anhand der Textur-Blending-Kaskade erkennen wir, dass die einzelnen Schichten miteinander kombiniert werden müssen. Für jede Stage können Sie zwei Texturargumente festlegen, welche dann durch den Texturoperator miteinander verbunden werden. Die Argumente können sich auch auf vorherige Stages beziehen, so dass die einzelnen Stages gut kombiniert werden können.

Abb. 52. Mischen der Texturargumente durch den Texturoperator

Die Argumente geben an, woher die Farbe (das Farbpixel) genommen werden soll. Der Operator bestimmt, wie die beiden Farben gemischt werden sollen. Das ist recht logisch und sollte keine größeren Probleme bereiten. Problematischer ist dann schon eher die von DirectX angebotene


199

Vielfalt an Texturargumenten und Texturoperatoren. Eine sinnvolle Kombination zu finden ist dann schon etwas schwieriger. Unser MultitexturingBeispielprogramm wird Ihnen einige Beispiele unterbreiten. Die eingebauten Effekte sind alle praxistauglich. Dennoch bleibt es Ihnen nicht erspart, selber zu experimentieren und neue Kombinationen zu finden. Damit Ihnen diese Aufgabe etwas leichter fällt, erhalten Sie im Folgenden eine Liste der verfügbaren Texturargumente (siehe Tabelle 7) und der Texturoperatoren (siehe Tabelle 8). Tabelle 7. Texturargumente Argument Constant AlphaReplicate Complement Temp TextureColor SelectMask Specular

Current

Diffuse

Beschreibung Wählt eine Konstante von einer Stage. Ersetzt alle Farbwerte durch den Alphawert. Invertiert das Argument, so wird aus dem Farbwert x der Wert (1-x). Als Argument wird ein temporärer Farbspeicher verwendet. Dieser besitzt den Standardwert (0, 0, 0, 0). Das Texturargument ist die Texturfarbe der jeweiligen Stage. Maskenwert für alle Argumente (ist nur beim Arbeiten mit dem Stencilbuffer von Bedeutung) Die Specularfarbe ist das Texturargument. Diese wird beim Gouraud-Shading gebildet. Sollten die Vertices keine Diffusfarbe beinhalten, dann kommt der Defaultwert 0xFFFFFFFF zum Einsatz. Das Texturargument ist das Resultat aus vorherigen Blending-operationen der letzten Stages. In der Stage 0 gibt es noch kein Ergebnis einer vorherigen Blendingoperation, deshalb ist in dieser Stage der Wert gleichbedeutend mit Diffuse. Die Diffusfarbe ist das Texturargument. Diese wird beim Gouraud-Shading gebildet. Sollten die Vertices keine Diffusfarbe beinhalten, kommt der Defaultwert 0xFFFFFFFF zum Einsatz.

Tabelle 8. Texturoperatoren Operator Subtract

Beschreibung Subtrahiert die Werte des zweiten Arguments von den Werten des ersten Arguments.

Lerp

Argument2 und Argument3 werden linear interpoliert. Das Verhältnis der Interpolation wird durch das erste Argument festgelegt.

SRGBA = Arg1 - Arg2

SRGBA = Arg1 x Arg2 + (1 - Arg1) x Arg3

200

Texturen

MultiplyAdd

Das zweite und dritte Argument werden multipliziert. Anschließend wird das Ergebnis zum ersten Argument addiert.

SRGBA = Arg1 + Arg2 x Arg3 DotProduct3

Moduliert alle Farbanteile beider Argumente. Diese Operation ist für Farb- und Alphaoperationen verfügbar.

SRGBA = (Arg1R x Arg2R + Arg1G x Arg2G + Arg1B x Arg2B) BumpEnvironmentMapLuminance Unter Verwendung der Environmentmap in der nächsten Stage werden die Höhen und Tiefen berechnet. Beleuchtungs-operationen sind hier auch aktiv. BumpEnvironmentMap Unter Verwendung der Environmentmap in der nächsten Stage werden die Höhen und Tiefen Bumpmap-typisch berechnet. Beleuchtungsoperationen sind hier nicht aktiv. Diese Operation ist nur für die Farboperationen (D3DTSS_COLOROP) verfügbar. ModulateInvColorAddAlpha

Der invertierte Wert von Argument1 wird verwendet.

SRGBA = (1 - Arg1RGB) x Arg2RGB + Arg1A ModulateInvAlphaAddColor

Der umgekehrte Alphawert von Argument1 wird verwendet.

SRGBA = (1 - Arg1A) x Arg2RGB + Arg1RGB ModulateColorAddAlpha

Moduliert beide Argumente und addiert den Alphawert von Argument1 hinzu.

SRGBA = Arg1RGB x Arg2RGB + Arg1A ModulateAlphaAddColor

Die Farbe von Argument1 wird unter Berücksichtigung des Alphawertes des Arguments moduliert.

SRGBA = Arg1RGB + Arg1A x Arg2RGB PreModulate BlendCurrentAlpha

Moduliert die Stage mit der nächsten. Vermischt die Argumente anhand des Alphawertes der vorausgehenden Textur.

SRGBA = Arg1 x Alpha + Arg2 x (1 - Alpha) BlendFactorAlpha BlendTextureAlpha

Vermischt beide Argumente anhand des D3DRS_TEXTURFACTOR. Vermischt beide Argumente anhand des Textur-Alphawertes. Das Bildformat der Textur entscheidet, wie viele Alphawerte zur Verfügung stehen.

Multitexturing (Multi Texture Mapping) BlendDiffuseAlpha AddSmooth

201

Vermischt beide Argumente anhand des Alphawertes der Vertices. Addiert Argument1 und Argument2. Anschließend wird das Produkt von Argument1 und Argument2 subtrahiert.

SRGBA = Arg1 + Arg2 - Arg1 x Arg2 AddSigned2X

Addiert Argument1 und Argument2. Zusätzlich wird noch –0.5 addiert. Somit werden Werte zwischen –0.5 und +0.5 erzielt. Das Ganze wird anschließend mit zwei multipliziert.

AddSigned

Addiert Argument1 und Argument2. Zusätzlich wird noch –0.5 addiert. Somit werden Werte zwischen –05 und +0.5 erzielt.

Add

Addiert Argument1 und Argument2.

SRGBA = (Arg1 + Arg2 - 0.5) x 2

SRGBA = Arg1 + Arg2 – 0.5 SRGBA = Arg1 + Arg2 Modulate4X

Multipliziert Argument1 mit Argument2. Das Ergebnis wird nochmals mit vier multipliziert. Dies ergibt ein helleres Bild.

SRGBA = Arg1 x Arg2 x 4 Modulate2X

Multipliziert Argument1 mit Argument2. Das Ergebnis wird nochmals mit zwei multipliziert. Dies ergibt ein helleres Bild.

Modulate

Multipliziert Argument1 mit Argument2

SRGBA = Arg1 x Arg2 x 2 SRGBA = Arg1 x Arg2 SelectArg2

Verwendet das zweite Farb- oder AlphaArgument der Stage.

SelectArg1

Verwendet das erste Farb- oder AlphaArgument der Stage.

Disable

Deaktiviert Multitexturing ab der Stage, in der dieser Operator verwendet wurde. Wollen Sie Multitexturing komplett ausschalten, dann reicht es, den Operator in Stage 0 zu verwenden.

SRGBA = Arg2 SRGBA = Arg1

22.8.2 Multi-Pass-Technik vs. Single-Pass-Technik Die Single-Pass-Technik ist in der Lage, mehrere Texturschichten in einem Durchgang zu rendern. Ob diese Technik eingesetzt werden kann,

202

Texturen

hängt im Wesentlichen von der Hardware ab. Noch vor ein paar Jahren war dies eine kritische Frage. Nicht alle Grafikkarten haben diese Technik unterstützt. Selbst als die ersten geeigneten Grafikkarten auf den Markt kamen, war es immer noch kritisch, auf die Technik zu setzen. Schließlich waren noch jede Menge alter Grafikkarten im Umlauf. Somit hätten viele Anwender das Programm nicht nutzen können. Heute ist das kein Problem mehr. Jede moderne Grafikkarte unterstützt die Single-Pass-Technik. Als Alternative würde die Multi-Pass-Technik zur Verfügung stehen. Diese Technik benötigt mehrere Renderschleifen, um die Texturen zu mischen. Würden Sie drei Texturschichten einsetzen, müssten Sie auch dreimal dasselbe Dreieck mit genau der gleichen Position, Größe, Material usw. rendern. Wir werden uns mit der Single-Pass-Technik beschäftigen. Zum einen wird diese Technik von DirectX bestens unterstützt, zum anderen sind auch die Grafikkarten hierfür ausgelegt. Eines sollte Ihnen dennoch bewusst sein: Multitexturing wird immer mehr Rechenleistung fordern als die Verwendung von nur einer Textur. 22.8.3 Texturkoordinaten, Vertexformat und Vertexbuffer Wir haben Ihnen erzählt, dass man mit Multitexturing wunderbare Effekte realisieren kann und dass wir mit Hilfe von Texturschichten Systemressourcen sparen und Texturen häufiger wieder verwenden können. Es stellt sich die Frage: Wie können wir die Textur-Blending-Kaskade für Spezialeffekte nutzen? Reicht es, wenn wir Texturen übereinander legen? Wie entsteht daraus ein sehenswerter Effekt? Hierzu möchten wir Ihnen folgende Szene schildern: Wir blicken auf einen Gefängnishof. Hier und da laufen ein paar Gefangene herum. Plötzlich ertönt Geschrei und der Suchscheinwerfer fährt über den Boden zu den Gefangenen und ... Halt! Moment mal. Ein Suchscheinwerfer, dessen Lichtkegel auf dem Boden zu sehen ist? Wie soll denn das gehen? Technisch ist das eine echte Herausforderung. Im Lichtabschnitt werden Sie sehen, dass ein Suchscheinwerfer gar nicht so leicht zu realisieren ist. Vielleicht kann uns Multitexturing dabei helfen. Multitexturing kann einen Lichtkegel simulieren. Unglücklicher Weise ist der Lichtkegel eines Suchscheinwerfers in Bewegung. Mit statischen Texturkoordinaten kommen wir da nicht weiter. Außerdem hilft es nicht, wenn wir alle Texturschichten gleichzeitig bewegen Es muss also möglich sein, jede Texturschicht einzeln zu bewegen. Hierfür benötigen wir ein Vertexformat, welches in der Lage ist, mehrere Texturkoordinaten aufzunehmen. Mit den Standardformaten ist das nicht möglich. Es bleibt uns nicht anderes übrig, als ein eigenes Format zu generieren.

Multitexturing (Multi Texture Mapping) 1 2 3 4 5 6

203

Public Structure MyVertexFormat Dim Position As DirectX.Vector3 Dim Normal As DirectX.Vector3 Dim Textur1 As DirectX.Vector2 Dim Textur2 As DirectX.Vector2 End Structure

Hier möchten wir einen Vergleich zwischen dem Vertexformat des ersten Texturbeispiels und diesem Vertexformat durchführen. Bisher haben wir auf die CustomVertex-Formate zurückgegriffen. Dieses sind von DirectX vordefinierte Formate, welche gewöhnlich ausreichen. 1

Direct3D.CustomVertex.PositionTextured

Dieses Format ist in der Lage, Positionskoordinaten sowie Texturkoordinaten für eine Texturschicht aufzunehmen. Wir wollen aber zwei Schichten verwenden und beide Schichten sollen unabhängig voneinander sein. Die Struktur MyVertexFormat beinhaltet zwei Mitglieder, welche Texturkoordinaten aufnehmen können. Somit können wir auch beide Schichten unterschiedlich steuern. Zu dieser Struktur gehört aber auch noch ein passender Bezeichner. 1

Public mVertex As Direct3D.VertexFormats = _ Direct3D.VertexFormats.Position Or _ Direct3D.VertexFormats.Normal Or _ Direct3D.VertexFormats.Texture2

Warum ist mVertex so wichtig für DirectX? Hiermit wird DirectX über das verwendete Format informiert. Wir können uns eine fast beliebige Vertexstruktur zusammenbauen. Diese füllen wir mit Daten und übergeben sie an DirectX. Ohne den Aufbau dieser Struktur zu kennen, könnte DirectX nichts damit anfangen. Wir informieren DirectX über das Format. Hierdurch erfährt DirectX, welche Informationen enthalten sind und in welcher Reihenfolge sie vorliegen. Reihenfolge und Inhalt von MyVertexFormat: VertexFormats.Position --> Positionskoordinaten VertexFormats.Normal --> Koordinaten für den Normalvektor (Diesen haben wir bisher noch nicht kennen gelernt. Vorab möchten wir nur so viel sagen, er ist für die Lichtberechnung von entscheidender Bedeutung.)

204

Texturen

VertexFormats.Texture2 tenpaare.

-->

Es folgen zwei Texturkoordina-

Aus den Vertexdaten wird ein Vertexbuffer erstellt. Das haben wir im ersten Texturbeispiel bereits getan. Das ist bei Multitexturing nicht anders, nur diesmal müssen wir nicht nur ein Texturkoordinatenpaar angeben, sondern zwei. Zuweisen der Texturkoordinaten Woher weiß DirectX, welche Texturkoordinaten für welche Schicht gedacht ist? DirectX weiß es nicht. Deshalb verwendet es die ersten Texturkoordinaten. Diese sind für die unterste Schicht gedacht. Oftmals ist das gar nicht schlecht. Immer dann, wenn Sie sowieso mit statischen Texturen arbeiten wollen, brauchen Sie keine Änderungen vorzunehmen. Falls Sie individuelle Texturkoordinaten verwenden wollen, müssen Sie DirectX darüber informieren. Hierzu benutzen Sie die TexturCoordinateIndex()-Methode. 1

D3DDevice.TextureState(1).TextureCoordinateIndex = 1

Zuerst müssen Sie die Texturschicht auswählen, welche die neuen Texturkoordinaten erhalten soll. Das geschieht über die TexturState(1)Zuweisung. Danach müssen Sie die Texturkoordinaten auswählen, die Sie verwenden wollen. In diesem Fall weisen wir den Wert eins zu. Sie erinnern sich an die MyVertexFormat-Struktur. Diese beinhaltet die Mitglieder Textur1 und Textur2. Die Reihenfolge entscheidet über den Index, mit dem die Texturkoordinaten angesprochen werden. Textur1 --> Index 0 Textur2 --> Index 1

Welche Texturkoordinaten Sie für welche Schicht verwenden wollen, bleibt Ihnen überlassen. MyVertexFormat ist lediglich der Speicher, aus dem Sie sich bedienen dürfen. 22.8.4 Beispielprogramm für Multitexturing Wir werden zwei Texturschichten verwenden. Stage 0 ist statisch und Stage 1 wird dynamisch sein. Stage 1 bewegt sich über Stage 0. Hierdurch erhalten wir einen interessanten Effekt.


205

Abb. 53. Screenshot des Beispielprogramms für Multitexturing

Voraussetzung für das folgende Programm sind: • • • • • •

Variablen deklarieren MyVertexFormat deklarieren Texturen und Fonts laden Vertexbuffer erstellen Texturoperator wählen Rendern

Variablen deklarieren Eigentlich ist es nicht notwendig, auf die Deklaration von Variablen einzugehen. Doch diesmal möchten wir Ihnen eine neue Technik präsentieren. Mit ihr wollen wir einen zentralen Ort für alle Variablen schaffen. Dies hat den Vorteil, dass man sich nicht immer an den Namen der gesuchten Variablen erinnern muss. Das ist insbesondere dann von Vorteil, wenn ältere Projekte überarbeitet werden müssen. Wir werden Ihnen diese Möglichkeit vorstellen und Sie entscheiden selbst, ob Sie sie verwenden.

206

Texturen

Es fängt damit an, dass Sie Themenbereiche oder Sammelbegriffe für Variablen bilden. Wir haben u.a. den Themenbereich cMisc (Miscellaneous = Vermischtes, Verschiedenes) und den Sammelbegriff cTexturen definiert. cMisc wird diverse Variablen aufnehmen, und zwar alle Variablen, welche wir nicht in einen Themenbereich erfassen können oder wollten. cTexturen werden alle Texturvariablen aufnehmen. 1 2 3 4

5 6 7

8 9 10 11 12

13 14 15

16 17 18 19 20 21 22

Structure cTexturen Dim txWand1 As Direct3D.Texture Dim txWand2 As Direct3D.Texture End Structure Structure cFonts Dim Font1 As Direct3D.Font End Structure Structure cZeit Dim DXTimer As DXTimer Dim FrameRate As Integer Dim ElapsedTime As Double End Structure Structure cVertexBuffer Dim vbWand As Direct3D.VertexBuffer End Structure Structure cMisc Dim Speed As Double Dim Angle As Double Dim TextureOperationText As String Dim TextureOperationIndex As Integer Dim pause As Boolean End Structure

Wie Sie erkennen, haben wir die Bereiche cTexturen, cFonts, cZeit, cVertexBuffer und cMisc gebildet. Der ein oder andere Bereich beinhaltet nur einen Eintrag. Bei kleineren Programmen kommt das schon mal vor. 23 24 25 26 27 28 29

Public Structure cVariablen Dim Misc As cMisc Dim Texturen As cTexturen Dim Fonts As cFonts Dim Zeit As cZeit Dim VertextBuffer As cVertexBuffer End Structure

30 31

Public Var As cVariablen


207

Die fünf Bereiche fassen wir in der Struktur cVariablen zusammen. Anschließend deklarieren wir die Variable Var (Zeile 31) mit dem Datentyp cVariablen. Jetzt haben wir einen zentralen Terminus für Variablen. Jedes Mal, wenn wir eine Variable benötigen, tippen wir Var gefolgt von einem Punkt ein. Es erscheint die Auswahlliste der Bereiche und in den Bereichen finden wir die Variablen. Wollen wir z.B. auf die Variable Speed zugreifen, dann geben wir Folgendes ein: Var.Misc.Speed Das ist natürlich länger, als nur den eigentlichen Namen Speed einzugeben, aber durch die Autovervollständigung ist das eigentlich kein Problem. MyVertexFormat deklarieren Warum müssen wir ein eigenes Vertexformat definieren? Unser Problem ist, dass die vordefinierten Formate von DirectX unserem Anspruch nicht genügen. Wir möchten zwei Texturebenen mit unabhängigen Texturkoordinaten. 1 2 3 4 5 6

Public Structure MyVertexFormat Dim Position As DirectX.Vector3 Dim Normal As DirectX.Vector3 Dim Textur1 As DirectX.Vector2 Dim Textur2 As DirectX.Vector2 End Structure

7 8

Public mVertex As Direct3D.VertexFormats = _ Direct3D.VertexFormats.Position Or _ Direct3D.VertexFormats.Normal Or _ Direct3D.VertexFormats.Texture2

Dieses Vertexformat ist in der Lage, Positionskoordinaten, Normalvektorkoordinaten sowie zwei Texturkoordinaten aufzunehmen. Da wir DirectX über das entsprechende Format informieren müssen (z.B. beim Erstellen des VertexBuffers), deklarieren wir die Variable mVertex mit dem Datentyp Direct3D.VertexFormats. Dieses Format initialisieren wir direkt mit den Werten Position, Normal und Textur2. Letzteres gibt an, dass zwei Texturkoordinatenpaare enthalten sind.

208

Texturen

Texturen und Fonts laden Texturen und Fonts zu laden ist keine große Sache. Schließlich haben wir das bereits öfter getan. Hier der Soucecode: 1 2

3

4 5

'*** Textur laden ********************************* Var.Texturen.txWand1 = _ Microsoft.DirectX.Direct3D.TextureLoader.FromFile _ (D3DDevice, DXUtility.FindMediaFile _ ("texturen\directx1.bmp")) Var.Texturen.txWand2 = _ Microsoft.DirectX.Direct3D.TextureLoader.FromFile _ (D3DDevice, _ DXUtility.FindMediaFile("texturen\env0.bmp")) '*** Font laden ************************************ Var.Fonts.Font1 = DXUtilities.LoadFonts(D3DDevice, _ Me.CreateGraphics, "courier new", 10, False)

Beim Laden der Texturen ist nichts Besonderes zu erwähnen. Es spielt keine Rolle, ob die Textur später für die Texturschicht null oder eins verwendet werden soll. Das ist ein dynamischer Prozess und Sie dürfen die Textur in die Schicht legen, welche Ihnen gefällt. Vertexbuffer erstellen Wenn Sie sich bereits gefragt haben, wann die Texturkoordinaten zum Einsatz kommen - jetzt ist es soweit. Außerdem werden wir nun die Strukturen des selbst definierten Vertexformats nutzen. Um den Vertexbuffer zu erstellen, verwenden wir die Funktion CreateWall(). Wir werden ein Rechteck definieren, welches aus zwei Dreiecken besteht. Da wir nach der TriangleList-Methode arbeiten, erhält jedes Dreieck insgesamt drei Vertices. 1 2

3

4

5 6

7 8

Private Function CreateWall() As Direct3D.VertexBuffer Dim iVertexBuffer As Direct3D.VertexBuffer = New _ Direct3D.VertexBuffer(GetType(MyVertexFormat), 6, _ D3DDevice, Direct3D.Usage.Dynamic, mVertex, _ Direct3D.Pool.Default) Dim vb As Direct3D.VertexBuffer = CType(iVertexBuffer, _ Direct3D.VertexBuffer) Dim verts As MyVertexFormat() = CType(vb.Lock(0, 0), _ MyVertexFormat()) Dim tmpVector As DirectX.Vector2 Dim m As DirectX.Matrix = DirectX.Matrix.Identity verts(0).Position = New DirectX.Vector3(-1, -1, 0) verts(0).Normal = New DirectX.Vector3(0, 0, -1)

Multitexturing (Multi Texture Mapping) 9 10 11

12

13

209

verts(0).Textur1 = New DirectX.Vector2(0, 1) tmpVector = New DirectX.Vector2(0, 4) tmpVector.X = tmpVector.X * Math.Cos(Var.Misc.Angle / _ 57.296) - tmpVector.Y * Math.Sin(Var.Misc.Angle / 57.296) tmpVector.Y = tmpVector.X * Math.Sin(Var.Misc.Angle / _ 57.296) + tmpVector.Y * Math.Cos(Var.Misc.Angle / 57.296) verts(0).Textur2 = tmpVector

In Zeile 7 weisen wir die Positionskoordinaten zu. In diesem Fall ist das die linke untere Ecke des ersten Dreiecks. In Zeile 8 werden die Koordinaten des Normalvektors übermittelt. Für das Thema Multitexturing sind die Zeilen 9 und 13 von besondere Bedeutung. In Zeile 9 erhält die erste Texturschicht (Stage 0) ihre Texturkoordinaten. Die zweite Texturschicht (Stage 1) erhält in Zeile 13 ihre Texturkoordinaten. Beiden Schichten werden unterschiedliche Koordinaten zugewiesen. Falls Sie sich über die Zeilen 10 – 12 wundern, wir wollen die Stage 1 mit einem Effekt ausstatten. Dieser soll eine verzerrte Rotation darstellen. Deshalb lassen wir die Texturkoordinaten rotieren. Den Effekt kennen Sie aus dem Beispielprogramm. 49 50 51 52

… vb.Unlock() Return iVertexBuffer End Function

Texturoperator wählen 1 2 3 4

Private Sub BasicSettings() D3DDevice.RenderState.ZBufferEnable = True D3DDevice.RenderState.Lighting = False D3DDevice.RenderState.CullMode = Direct3D.Cull.None

5 6

7

D3DDevice.SamplerState(0).MinFilter = _ Direct3D.TextureFilter.Linear D3DDevice.SamplerState(0).MagFilter = _ Direct3D.TextureFilter.Linear

8 9 10

11

12

13

D3DDevice.TextureState(1).TextureCoordinateIndex = 1 D3DDevice.TextureState(1).ColorOperation = _ TextureOperationArray(Var.Misc.TextureOperationIndex) D3DDevice.TextureState(1).ColorArgument1 = _ Direct3D.TextureArgument.TextureColor D3DDevice.TextureState(1).ColorArgument2 = _ Direct3D.TextureArgument.Current End Sub

210

Texturen

In Zeile 9 setzen wir den TexturCoordinateIndex. Dieser gibt an, dass wir als Texturkoordinatenpaar (0 = Stage0, 1 = Stage1) der MyVertexFormat-Struktur das zweite Paar verwenden wollen. Wir könnten auch den Index null übergeben, dann würden wir die Texturkoordinaten von Stage 0 verwenden. Wenn Sie überhaupt keinen Wert angeben, wird automatisch der Wert null angenommen. In unserem Beispiel lassen wir die Texturargumente statisch auf ColorArgument1 = TextureColor und ColorArgument2 = Current stehen. Anders verhält sich das bei dem Texturoperator. Diesen möchten wir per KeyUp- und KeyDown-Taste verändern. Je nachdem welchen Wert der TexturOperationIndex besitzt, wählen wir aus dem ArrayTextureOperationArray()den entsprechenden Eintrag. 1

Public TextureOperationArray() = {Direct3D.TextureOperation.Add,_ Direct3D.TextureOperation.AddSigned, _ Direct3D.TextureOperation.AddSigned2X, _ Direct3D.TextureOperation.AddSmooth, _ Direct3D.TextureOperation.Disable, _ Direct3D.TextureOperation.DotProduct3, _ Direct3D.TextureOperation.Lerp, _ Direct3D.TextureOperation.Modulate, _ Direct3D.TextureOperation.Modulate2X, _ Direct3D.TextureOperation.Modulate4X, _ Direct3D.TextureOperation.MultiplyAdd, _ Direct3D.TextureOperation.Subtract}

Rendern Eine Renderroutine kennen wir bereits. Es ist nicht das erste Mal, dass wir eine Szene rendern. Dennoch gibt es ein paar Auffälligkeiten. Doch zuerst werfen wir einen Blick auf die Routine. 1 2 3 4 5

6 7

8 9 10 11

Public Sub Render() Try D3DDevice.SetTexture(0, Var.Texturen.txWand1) D3DDevice.SetTexture(1, Var.Texturen.txWand2) D3DDevice.SetStreamSource(0, _ Var.VertexBuffer.vbWand, 0) D3DDevice.VertexFormat = mVertex D3DDevice.DrawPrimitives _ (Direct3D.PrimitiveType.TriangleList, 0, 2) Catch MessageBox.Show("Fehler in Sub: Render_Wand.") End Try End Sub

Alpha-Textur-Blending

211

Was ist bei dieser Renderroutine anders? In den Zeilen 3 – 4 werden die Texturen zugewiesen. In Zeile 3 für die Stage 0 und in Zeile 4 für die Stage 1. Bisher haben wir nur eine Textur benötigt. Mehr war nicht notwendig, da wir bisher nur mit einer Texturschicht gearbeitet haben. Bei Multitexturing verwenden wir mindestens zwei Schichten. Etwas anderes fällt auch noch auf. In Zeile 6 informieren wir DirectX über das verwendete Vertexformat. Diesmal benutzen wir den selbst definierten Bezeichner mVertex.

22.9 Alpha-Textur-Blending Mit Hilfe von Alpha-Textur-Blending kontrollieren wir die Transparenz eines Bildpunktes. Jeder Bildpunkt wird aus den drei Farbkanälen Rot, Grün und Blau (RGB) erstellt. Oftmals kommt noch ein vierter Kanal hinzu. Dann spricht man vom ARGB-Format. Der zusätzliche Kanal ist der Alphakanal (Alphachannel). Er bestimmt, ob ein Pixel transparent oder solide dargestellt wird. Deshalb wird der Alphakanal oft Alphamaske oder schlicht Maske genannt. Bei einem niedrigen Wert wird das Pixel transparent dargestellt. Entsprechend ist ein hoher Wert für die solide (undurchsichtige) Darstellung verantwortlich. 22.9.1 Texturfaktor Beim Alpha-Textur-Blending können wir aus verschiedenen Quellen den Alphawert holen. Eine beliebte Technik ist es, den Alphawert einfach anzugeben. Dann ist es nicht mehr notwendig, auf Alphawerte der Vertices oder der Textur zurückzugreifen. Mit der Methode D3DDevice. RenderState.TextureFactor ist es möglich, den zu verwendenden Alphawert zu bestimmen. 1

2

D3DDevice.RenderState.TextureFactor = _ Color.FromArgb(AlphaWert, 0, 0, 0).ToArgb D3DDevice.TextureState(1).ColorOperation = _ Direct3D.TextureOperation.BlendFactorAlpha

Im Grunde ist das auch schon alles. Über den Faktor bestimmen wir den Grad der Transparenz. Dies lässt sehr feine Abstufungen zu. Wir haben hierzu ein Demoprogramm erstellt. Dieses finden Sie auf unserer CD. Da die Änderungen zu dem Multitexturing-Demo nur sehr klein sind, möchten wir auf eine Erläuterung verzichten. Lediglich die Modifikationen am Alphawert selber wollen wir besprechen.

212 1 2 3 4

5

6 7 8

9

10

Texturen

Select Case Var.Alpha.AlphaDirection Case True Var.Alpha.AlphaWert += Var.Misc.Speed If Var.Alpha.AlphaWert >= 255 Then _ Var.Alpha.AlphaDirection = False If Var.Alpha.AlphaWert > 255 Then _ Var.Alpha.AlphaWert = 255 Case False Var.Alpha.AlphaWert -= Var.Misc.Speed If Var.Alpha.AlphaWert = 0 Then

>= 250 Then

>= 500 Then

>= 750 Then

>= 1000 Then

Nach Durchlaufen dieses Konstrukts erhalten wir in der Variablen i den Wert des Objektes, das in diesem Durchlauf der Renderschleife darzustellen ist. Danach brauchen wir nur noch mit Hilfe des Befehls Static-

Mesh-Objekte: Tweening/Keyframe-Animation

263

MeshObjektRendern der aktuellen DXStaticMesh-Klasse unser Objekt ausgeben. Auf den ersten Blick ist diese Methode der Animation schnell zu realisieren und damit sehr effektiv. Sie führt jedoch zu Problemen, wenn man mehr als einen Bewegungsablauf für das Objekt realisieren will. Nach unserer Erfahrung benötigt man für einen einigermaßen sauberen Ablauf mindestens 14 Frames pro Sekunde / Bewegung. Dies bedeutet schon im Vorfeld einen enormen Zeitaufwand bei der Arbeit mit den 3D-ModellApplikationen. Da diese Arbeit auch nicht gerade die einfachste ist, haben wir uns bei unseren Projekten für die folgende Animationsart entschieden.

26.3 Mesh-Objekte: Tweening/Keyframe-Animation Zu dem erwähnten erhöhten Arbeitspensum bei der Animation eines Objektes kommt zusätzlich noch die enorme Menge an Daten, die diese Frame-Animation mit sich bringt. Dazu stellen wir an dieser Stelle einmal ein einfaches Rechenbeispiel auf. Wir gehen einmal von einem MeshObjekt in Form eines Fußballs aus. Dieser Ball besteht aus 1000 Polygonen. Die Koordinaten für jedes Polygon stehen in einer Zeile in der MeshDatei. Das bedeutet, wir benötigen eine 1000 Zeilen lange Mesh Datei. Nun wollen wir eine Bewegung realisieren, bei der der Ball gegen eine Wand geworfen wird, sich dabei deformiert und danach wieder von der Wand weg springt. Diese Bewegung benötigt ca. 50 verschiedene Bewegungsstufen, damit die Animation flüssig aussieht. Daraus folgt, wir brauchen 50 Mesh-Dateien mit jeweils 1000 Zeilen Information für diesen Bewegungsablauf, also 50.000 Datenzeilen. Selbst wenn wir die einzelnen Frames mit einem 3D-Modeller in einer Datei speichern könnten, hätten wir trotzdem eine unüberschaubar große Menge an Daten, die wir laden und verwalten müssten. Man erkennt somit, dass diese Art der Animation für größere Projekte nicht geeignet ist.

264

Animation des Mesh-Objektes Frame-Animation

Abb. 71. Beispiel Fußball

Um die Datenmenge für die einzelnen Objekte so gering wie möglich zu halten, müssen wir einen anderen Weg bei der Animation unserer Objekte gehen. Die Strategie, die wir bei unseren Projekten verfolgen, ist das so genannte Tweening, auch Keyframe-Interpolation genannt. Bei dieser Methode werden nur wichtige Eckpunkte der Bewegung gespeichert und die einzelnen Frames zwischen diesen Keyframes berechnet. Für unser Beispiel benötigt man drei Eckpunkte, um die Bewegungen zu definieren. Der erste Frame ist der Ball am Anfang des Wurfvorganges. Als nächsten Frame hätte man dann den an der Wand deformierten Ball. Zum Schluss müsste man noch einmal einen Frame für den wieder zurückprallenden, nicht mehr deformierten Ball benutzen. Die drei Dateien dieser Frames hätten eine Größe von 3000 Zeilen, was nur 6% der ursprünglichen Daten entspricht. Für diese Einsparung können wir die folgenden etwas komplizierteren Arbeitsabläufe in Kauf nehmen. Alles was wir bei dieser Art der Animation brauchen, sind die Vertex-Informationen aus jedem Keyframe und die aktuelle Zeit, an der wir uns gerade befinden. Wir haben die Keyframe-Animation in dem Beispiel Demo_Mesh3 realisiert. Wir benutzen in diesem Projekt die gleichen Mesh-Dateien wie im vorherigen Demo, um die Unterschiede zwischen den beiden Animationsarten besser darstellen zu können. Als Erstes wollen wir noch einmal die Theorie hinter der KeyframeAnimation beschreiben. Eigentlich ist dies eine ganz einfache Angelegen-


265

heit. Zuerst ermitteln wir die benötigten Daten aus den geladenen Dateien. Danach berechnen wir in jedem Durchlauf der Renderschleife die vergangene Zeit, seitdem die Animation gestartet ist, und damit auch den Zeitpunkt, an dem wir uns gerade innerhalb der Animation befinden. Mit diesem Zeitpunkt können wir den vorangegangenen Keyframe und den nächsten Keyframe bestimmen und anschließend festlegen, an welcher Position wir uns zwischen den beiden Frames befinden. Anschließend müssen wir nur noch diese beiden Frames unter zuhilfenahme der Position interpolieren und das Ergebnis danach rendern. Nach der Theorie kommt jetzt die Praxis. Dabei werden wir feststellen, dass das, was sich theoretisch schwer anhört, auch manchmal schwer sein kann. Wir werden aber auch sehen, dass diverse Techniken schon bekannt sind und einige bereits eingeführte Funktionen nur etwas modifiziert werden. Wie immer nehmen wir die bekannte frm_Start-Klasse als Grundlage für unser Projekt. Um die beiden Animationsmethoden zu trennen, haben wir für die Keyframe-Interpolation eine eigene Klasse DXDynamicMesh erstellt. Diese wird von der Klasse DXStaticMesh abgeleitet. Damit haben wir also Zugriff auf alle unsere bekannten Funktionen auch aus der neuen Klasse heraus. Wir starten mit der Instanzierung der neuen Klasse innerhalb des Projektes. 1 2 3 4 5 6 7

'Mesh-Klasse initialisieren Private clsMesh As DXDynamicMesh 'benötigte Variablen Private intCurTime As Integer = 0 Private lastCurTime As Integer Private lastAnim As Integer Private nextAnim As Integer

Außer den uns bekannten Variablen in Zeile 4 und 5 brauchen wir für den Renderablauf nachher noch die beiden Variablen lastAnim und nextAnim. Die jeweils den Wert des vorherigen Keyframes sowie des nächsten Keyframes beinhalten werden. Die Variable intCurTime müssen wir für den allerersten Durchlauf der Renderroutine vorsorglich füllen. Damit haben wir alle benötigten Objekte instanziert. Weiter geht es in der Load-Methode der frm_Start-Klasse, hier müssen wir wie gehabt die instanzierte Klasse mit Leben füllen. 8 9 10

' Objekte erstellen clsMesh = New DXDynamicMesh clsMesh.CreateDynamicMesh(D3DDevice, "C:\Buch DirectX _ VB.NET\Media\Meshes\", "NewSpieler", 4)

266


Auf den ersten Blick hat sich bei der Initialisierung der Klasse nichts geändert, bis auf die Verwendung der DXStaticMesh-Klasse. Außerdem hat die CreateDynamicMesh-Anweisung einen zusätzlichen Parameter bekommen. Dieser bestimmt die Anzahl der Frames, die zur Animation verwendet werden sollen. 1

2 3 4

Public Sub CreateDynamicMesh(ByRef device As Microsoft _ .DirectX.Direct3D.Device, ByVal strPath As String,_ ByVal strBasisMeshName As String, _ ByVal intAnzahlKeyFrames As Integer) Dim i, a As Integer Dim tmpSpieleobjekt As DynamicMesh ReDim AnimationsObjektArray(intAnzahlKeyFrames)

Die ersten vier Zeilen der Subroutine sind noch äußerst unspektakulär. Nach der Deklaration der Routine mitsamt ihren Parametern werden in Zeile 2 und 3 benötigte Variablen deklariert. Danach wird in Zeile 4 das Array neu dimensioniert, das anschließend mit den einzelnen Animationsframes gefüllt wird. 5 6 7

8

9 10 11 12 13 14

15

For a = 0 To intAnzahlKeyFrames With tmpSpieleobjekt .mesh = Direct3D.Mesh.FromFile(strPath + "\" + _ strBasisMeshName + a.ToString + ".x", _ Direct3D.MeshFlags.SystemMemory, device,_ .extendedMaterial) .material = New Di rect3D_ .Material(.extendedMaterial.Length) {} For i = 0 To .extendedMaterial.Length – 1 .material(i) = .extendedMaterial(i).Material3D .material(i).Ambient = .material(i).Diffuse Next i End With AnimationsObjektArray(a) = MeshKonvertierenInAnimation Frame(device, tmpSpieleobjekt, a) Next a

In der For-Next-Schleife in Zeile 5 bis Zeile 15 wird nun die Hauptarbeit bei der Erstellung der einzelnen Animationsabschnitten vorgenommen. Die Anzahl der Durchläufe für die Schleife bekommen wir beim Aufruf der Funktion übergeben. Mit der Hilfe des Durchlaufindexes können wir nun wie gehabt die Mesh-Dateien auslesen und weiterverarbeiten. Dabei gehen wir genau wie bei der DXStaticMesh-Klasse vor. Danach werden die gewonnenen Daten mit dem Befehl MeshKonvertierenInAnimationFrame für die Keyframe-Interpolation vorbereitet. Diesen Befehl werden wir im nächsten Abschnitt etwas genau-


267

er betrachten, da die Funktionen dieser Methode uns überhaupt erst in die Lage versetzen, die gewünschte Art der Animation durchzuführen. 16 17

currentAnimationsObjekt = AnimationsObjektArray(0) End Sub

Zum Schluss setzen wir noch das erste Objekt aus dem gefüllten FrameArray als aktuelles Animationsobjekt (Zeile 16) und beenden in Zeile 17 die Routine. Bevor wir nun aber zu der erwähnten Funktion zum Erstellen der einzelnen Keyframes kommen, müssen wir noch kurz zwei Objekte besprechen, die wir im Laufe der Funktion benötigen. Dabei handelt es sich als Erstes um die Struktur Vertex. Mit Hilfe dieser Struktur können wir im Laufe der Funktion die Größe eines einzelnen Vertex innerhalb des MeshDatenspeichers bestimmen und auslesen. 1 2 3 4 5

6

Public Structure Vertex Public p As DirectX.Vector3 Public n As DirectX.Vector3 Public tu, tv As Single Public Const Format As Direct3D.VertexFormats =_ Direct3D.VertexFormats.Position Or_ Direct3D.VertexFormats.Normal Or _ Direct3D.VertexFormats.Texture1 End Structure 'Vertex

In Zeile 1 wird die Struktur gestartet und der Name Vertex wird zugewiesen. Danach werden die einzelnen Variablen definiert, aus denen die Struktur bestehen soll. Hierbei ist p eine Variable des Typs Vector3, also ein Vektor mit drei Single-Werten (Zeile 2), der die Position des Punktes im dreidimensionalen Raum beschreibt. Die Variable n beschreibt den Normalvektor des Punktes (Zeile 3). Mit den beiden Variablen tu und tv werden die Texturkoordinaten des Punktes angegeben (Zeile 4). Zu guter Letzt werden in Zeile 5 für die Struktur noch konstante VertexFormats-Werte bestimmt. Die nächste Struktur wird benötigt, um alle Daten für das spätere Berechnen und Rendern der einzelnen Frames aufzunehmen. 1 2 3 4 5

Public Structure AnimationsObjekt Dim mesh As Direct3D.Mesh Dim VertexB As Direct3D.VertexBuffer Dim IndexB As Direct3D.IndexBuffer Dim Vertices As Integer

268 6 7 8


Dim Faces As Integer Dim TimeIndex As Integer End Structure

In Zeile 2 deklarieren wir die Variable zur Aufnahme der Mesh-Rohdaten für die weitere Verarbeitung innerhalb der Klasse. VertexB definiert den Buffer, den wir im weiteren Verlauf mit den Vertices des jeweiligen Keyframes füllen werden. Das Gleiche geschieht mit IndexB in Zeile 4. Die beiden Integer-Werte, in den Zeilen 5 und 6, werden benötigt, um die maximale Anzahl der Vertices des Meshes zu speichern sowie die sich aus den Vertices ergebende Anzahl der Faces. In der letzten Variablen TimeIndex speichern wir zum Schluss noch den Zeitwert des Keyframes, an der sich das Mesh innerhalb des Animationsdurchlaufes befindet. Mit diesen Informationen können wir uns nun die Funktion MeshKonvertierenInAnimationFrame ansehen und deren Programmzeilen genauer erörtern. Auch diesen Abschnitt unterteilen wir zur besseren Übersicht in sinnvolle Blöcke. Der erste Block in der Funktion ist der Deklarationsblock. Alle benötigten Variablen und Objekte werden in diesem Block deklariert. Es beginnt wie immer mit der Deklaration des Befehls mitsamt seinen Parametern. Wir bekommen für die Funktion das DirectX Device übergeben, in dem das gesamte Objekt erstellt werden soll. Der nächste Parameter ist ein Objekt, mit dem wir die benötigten Rohdaten des Meshes übergeben. Zum Schluss wird ein TimeIndex-Wert zur Ermittlung der Position im Frame-Ablauf der Funktion übertragen. Die gesamte Funktion gibt nach erfolgreicher Bearbeitung ein Objekt mit den berechneten Mesh-Daten zurück. 1

2 3 4 5 6 7 8 9

Function MeshKonvertierenInAnimationFrame(ByRef device As_ Microsoft.DirectX.Direct3D.Device, _ ByVal structObject As Object, _ ByVal dblTimeIndex As Double) As Object Dim tmpAnimationsObject As AnimationsObject Dim pMeshSourceVB As Direct3D.VertexBuffer = Nothing Dim pMeshSourceIB As Direct3D.IndexBuffer = Nothing Dim pTempLocalMesh As Direct3D.Mesh = Nothing Dim src As Vertex() = Nothing Dim dst As Direct3D.GraphicsStream = Nothing Dim dstib As Direct3D.GraphicsStream = Nothing Dim srcib As Short() = Nothing

Wie schon erwähnt, müssen wir die Daten für die Animation erst bearbeiten, bevor wir sie für unsere Zwecke nutzen können. Dafür erstellen wir


269

eine temporäre Instanz des Objektes, das wir am Ende der Routine zurückgeben werden (Zeile 2). Außerdem deklarieren wir in den Zeilen 3 bis 5 Variablen, die wir im Verlauf der Funktion benötigen, um die aus dem Mesh gewonnenen Daten zwischenzuspeichern. Zum Schluss werden noch die Variablen deklariert, mit deren Hilfe wir, die Mesh-Daten in die erforderliche Form konvertieren können. Im nächsten Block der Funktion sortieren wir die Daten des übergebenen Mesh-Objektes erst einmal so, dass wir sie ohne Probleme weiter verarbeiten können. Dazu speichern wir in Zeile 10 als Erstes die originalen MeshDaten, damit wir auf diese im Laufe des Programms noch einmal zugreifen können. Die weiteren Funktionen dieses Blocks stellen sicher, dass die Daten des Meshes für die weitere Verarbeitung auch alle benötigten Daten enthalten. 10 11

12 13 14

tmpAnimationsObject.mesh = structObject.mesh pTempLocalMesh = structObjekt.mesh.Clone(0, _ Vertex.Format, device) structObject.mesh = pTempLocalMesh pTempLocalMesh = Nothing structObject.mesh.ComputeNormals()

In Zeile 11 kopieren wir die Daten der Ursprungsdatei mit Hilfe des Clone-Befehls in die temporäre Variable pTempLocalMesh. Dabei sorgen die übergebenen Parameter dafür, dass die Daten der Datei bei der weiteren Bearbeitung auch alle benötigten Angaben haben. Das bedeutet, dass eventuell fehlende Informationen im Klon des Meshes aufgefüllt werden, und zwar mit den in der Struktur Vertex vorgegebenen Vertexformaten. Mit den gewonnenen Daten überschreiben wir die übergebenen Ursprungsdaten und löschen danach die temporäre Mesh-Variable für die spätere weitere Benutzung. Mit dem Befehl ComputeNormals() in Zeile 14 wird jetzt noch für jeden Vektor des Mesh-Objektes ein Normalvektor berechnet. Die nächsten Befehlszeilen werden wir nun einzeln betrachten, um deren Funktion genau zu erörtern. 15

tmpAnimationsObject.VertexB = New Direct3D._ VertexBuffer(GetType(Vertex),_ structObjekt.mesh.NumberVertices,_ device, Direct3D.Usage.WriteOnly, 0, _ Direct3D.Pool.Managed)

270


Mit der Zeile 15 erstellen wir den temporären Vertexbuffer zur Aufnahme der Vertexinformationen des Meshes. Wir benutzen hierbei die zweite New-Überladung der Vertexbuffer-Klasse. Wir übergeben dabei der Methode im ersten Parameter den Vertextyp, mit dem der neue Vertexbuffer gefüllt werden soll. Dabei benutzen wir unsere selbst definierte Struktur Vertex zur Bestimmung des Vertextyps. Zur Bestimmung der Größe des neuen Vertex-Objektes lesen wir die Anzahl der Verticies aus dem Ursprungs-Mesh mit Hilfe der NumberVertices-Funktion. Die letzten Parameter der Überladung bestimmen das Device, in dem der Vertexbuffer erstellt werden soll, sowie Usage und Pool-Flags die genauere Angaben über die Verwendung und den Speicherort des Buffers geben. 16

tmpAnimationsObject.IndexB = New Direct3D._ IndexBuffer(GetType(Short),_ structObjekt.mesh.NumberFaces * 3,_ device, Direct3D.Usage.WriteOnly, _ Direct3D.Pool.Managed)

Für die weitere Verarbeitung der Daten brauchen wir auch die Informationen des IndexBuffers des Original-Meshes. Diese speichern wir in die Indexbuffer-Variable der temporären Animationsstruktur. Dabei gehen wir wie bei der Erstellung des Vertexbuffers vor, nur dass wir dieses Mal der New-Überladung der Funktion als Datentyp einen Short übergeben und die Größe des Buffers sich aus der Anzahl der Faces des Meshes mit 3 multipliziert ergibt. 17

18

19

tmpAnimationsObject.Vertices = structObjekt.mesh _ .NumberVertices tmpAnimationsObject.Faces = structObjekt.mesh _ .NumberFaces pMeshSourceVB = structObjekt.mesh.VertexBuffer

Danach speichern wir noch die Anzahl der Vertices der Mesh-Datei sowie deren Face-Anzahl in die vorbereiteten Variablen. Zum Schluss laden wir noch die temporäre Mesh Variable mit den überarbeiteten Mesh-Daten und schließen damit die Vorbereitung der zu verarbeitenden Daten ab. 20

dst = tmpAnimationsObject.VertexB.Lock(0,_ DirectX.DXHelp.GetTypeSize(GetType(Vertex)) * _ structObjekt.mesh.NumberVertices, 0)

Nachdem wir nun sichergestellt haben, dass alle Daten, die wir brauchen, auch in der richtigen Form zur Verfügung stehen, können wir uns daran


271

machen, die Mesh-Daten in den vorbereiteten Buffer zu kopieren. Dabei gehen wir wie folgt vor: Als Erstes kopieren wir die gesamten Daten in einen großen Speicherbereich, den wir anschließend in die benötigten Einzelteile, nämlich die Vertices unterteilen. Dazu müssen wir in Zeile 20 zunächst den Speicherbereich, den GraphicStream dst, bestimmen. Wir benutzen dazu den Befehl Lock der Vertexbuffer-Klasse. Diese liefert eine GraphicsStream zurück, der mit den Parametern des Aufrufes der Funktion bestimmt wird. Der erste Parameter bestimmt den StartOffset , der zweite Parameter die Größe des zu besetzenden Bereichs. Dabei wird die Anzahl der Vertices des Meshes mit der Größe unserer Vertexstruktur multipliziert, um die Größe zu ermitteln. Für unseren Fall benötigen wir keine besonderen Flags beim Locken des Speicherbereichs. Deshalb übergeben wir an dieser Stelle als dritten Parameter eine 0. 21

src = CType(pMeshSourceVB.Lock(0, GetType(Vertex), 0,_ structObjekt.mesh.NumberVertices), Vertex())

Als Nächstes widmen wir uns in der Zeile 21 den Originaldaten. Wir nutzen erneut die Lock-Methode der Vertexbuffer-Klasse. Mit ihrer Hilfe lesen wir die Rohdaten aus dem temporären Mesh aus. Dabei nutzen wir die gleichen Parameter wie bei dem ersten Lock-Befehl. Mit Hilfe der CType-Funktion und unserer erstellten Vertexstruktur werden diese Daten sofort in ein Vertex-Array konvertiert und anschließend direkt dem GraphicsStream src zugewiesen. 22 23 24 25

dst.Write(src) tmpAnimationsObject.VertexB.Unlock() pMeshSourceVB.Unlock() pMeshSourceVB.Dispose()

Nachdem wir die Daten nun in das von uns gewünschte Format konvertiert haben, müssen wir diese noch in unseren endgültigen Speicherbereich schreiben. Dazu nutzen wir die Write-Methode des GraphicsStreamObjektes und schreiben so die Daten des src-Streams in den Speicherbereich des dst-Streams. In Zeile 23 geben wir den aufgefüllten Vertexbuffer des Animationsobjektes für die weitere Benutzung wieder frei. Die Zeilen 24 und 25 räumen nun noch das nicht mehr gebrauchte temporäre Mesh-Objekt auf. In der gleichen Weise gehen wir auch beim Kopieren der IndexBufferDaten des Meshes vor. Wie gehabt wird in Zeile 26 als Erstes ein temporärer IndexBuffer angelegt. Danach sperren wir den Speicher des Zielbereiches für die weitere Bearbeitung in Zeile 27. Die Quelldaten wer-

272


den in Zeile 28 ausgelesen und in den gewünschten Typ konvertiert. Anschließend werden sie dann im Speicher des Quellbereiches gespeichert und wie zuvor der Zielbereich gesperrt. Zeile 29 übernimmt das Schreiben der formatierten Daten in den zuvor bestimmten Zielbereich. Die folgenden Zeilen 30 - 32 geben den konvertierten IndexBuffer für die weitere Bearbeitung frei und sorgen dafür, dass der Speicherbereich des temporären IndexBuffers wieder freigegeben wird. 26 27

28

29 30 31 32

pMeshSourceIB = structObjekt.mesh.IndexBuffer dstib = tmpAnimationsObject.IndexB.Lock(0, _ DirectX.DXHelp.GetTypeSize(GetType(Short)) * _ structObjekt.mesh.NumberFaces * 3, 0) srcib = CType(pMeshSourceIB.Lock(0, GetType(Short), 0,_ structObjekt.mesh.NumberFaces * 3), Short()) dstib.Write(srcib) tmpAnimationsObject.IndexB.Unlock() pMeshSourceIB.Unlock() pMeshSourceIB.Dispose()

So das wäre geschafft. Die Daten liegen in unserer Animationsstruktur in genau dem Format vor, das wir zur weiteren Verarbeitung benötigen. Der Rest der Funktion ist im Vergleich dazu ein Kinderspiel. Hierbei müssen wir nur noch den TimeIndex auswerten, der der Funktion übergeben worden ist. Diesen übergeben wir der TimeIndexVariablen der aktuelle Animationsstruktur. Abschließend werden die erstellten Daten in Zeile 47 der aufrufenden Funktion zurückgegeben. 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

With tmpAnimationsObject Select Case dblTimeIndex Case 0 .TimeIndex = 0 Case 1 .TimeIndex = 250 Case 2 .TimeIndex = 500 Case 3 .TimeIndex = 750 Case 4 .TimeIndex = 1000 End Select End With Return tmpAnimationsObject End Function

Damit hätten wir den ersten der beiden anspruchsvollen Teile der Keyframe-Animation abgeschlossen, nämlich das Vorbereiten der Mesh-Daten.

Keyframe-Bestimmung

273

Den Zweck dieser Übung und auch des Zeitindexes werden wir in den nächsten beiden Abschnitten erarbeiten.

26.4 Keyframe-Bestimmung Als nächsten neuen Punkt im Mesh_Demo3 betrachten wir die Berechnung der beiden zur Animation benötigten Frames. Die Berechnung des Zeitindexes ist dagegen schon aus dem Mesh_Demo2-Projekt bekannt. Wie dort benötigen wir auch hier den Zeitwert, der vergangen ist, seitdem der letzte Animationsdurchlauf abgeschlossen ist. Da ein Bild manchmal mehr als tausend Worte sagt, haben wir versucht, das Prinzip der folgenden Methoden auch einmal grafisch darzustellen.

Abb. 72. Zeitkreisel Keyframe-Animation

Die Abbildung zeigt, dass wir die maximale Zeitspanne von 1000 ms (1 Sekunde) in vier gleich große Teile aufgeteilt haben. Dabei ist die erste und letzte Stelle nahezu identisch. Wir bewegen uns also während der Animation immer in diesem Bereich der 1000 Millisekunden. Bei jedem Durchlauf der Render-Funktion der frm_Start-Klasse bestimmen wir nun, an welcher Stelle innerhalb der 1000 ms wir uns gerade befinden. Das geschieht wie gehabt in der Zeile 1. Da wir bei der Erstellung unserer Keyframes weiter vorn den TimeIndex mit festgelegt haben, können wir über diesen jetzt feststellen, welche beiden Frames wir bei dem aktuellen Rendervorgang berücksichtigen müssen. Dazu gehen wir in der For-

274


Next-Schleife in Zeile 6 bis Zeile 10 die einzelnen Indexwerte so lange durch, bis wir den letzten Wert gefunden haben, der kleiner ist als unser aktueller Zeitwert. Ist das der Fall, bestimmen wir den Frame mit dem niedrigeren Zeitwert als den ersten Frame für unsere Animationsberechnung und den auf diesen Frame folgenden als zweiten Frame. In unserem Beispiel in der Abbildung wären das die Keyframes KF1 und KF2. 1

2 3 4 5 6

7 8 9 10

intCurTime = intCurTime + (Environment.TickCount - _ lastCurTime) If intCurTime > 1000 Then intCurTime = 0 lastCurTime = Environment.TickCount Dim i As Integer For i = 0 To 3 If intCurTime >= clsMesh.objAnimation(i)_ .TimeIndex Then lastAnim = i nextAnim = lastAnim + 1 End If Next i

Nach der Bestimmung der beiden zur Animation benötigten Keyframes sowie der aktuellen Durchlaufzeit können wir diese Informationen nun zur Berechnung unseres Objektes an die CalculateFrame-Methode unserer DXDynamicMesh-Klasse übergeben. 11

clsMesh.CalculateFrame(lastAnim, nextAnim, intCurTime)

26.5 Keyframe-Interpolation Die Keyframe-Interpolation ist das Kernstück unserer Animation. Mit ihrer Hilfe können wir die Bewegung zwischen unseren statischen MeshObjekten berechnen. Wir fügen also unseren bestehenden Frames rechnerisch weitere Frames hinzu. Dazu müssen wir an dieser Stelle einmal in die Mathematik abschweifen. Um wie in unserem Fall einen Wert zwischen den von uns bestimmten Animationsstufen zu berechnen, nutzen wir die folgende Formel: (V - A) / (B –A )

Wobei A der Ursprung der Berechnung ist. In unserem Fall also der durch lastAnim bestimmte Keyframe. B ist damit also folglich der Zielframe nextAnim. Mit V wird der Interpolant, der aktuelle Zeitwert zwischen

Keyframe-Interpolation

275

den beiden Rahmen, bestimmt. Die folgende Abbildung soll das Prinzip der Interpolation noch einmal verdeutlichen.

Abb. 73. Roboterarm mit einzelnen Frames

Auf der Abbildung sehen wir, wie ein Roboterarm einen Würfel vom Boden aufnimmt und diesen dann auf einer erhöhten Stelle absetzt. Diese drei Arme wären somit auch die Keyframes, die wir zur Berechnung unserer Bewegung benötigten. Alle anderen Bewegungsabschnitte werden mit Hilfe der Interpolation ermittelt. An dieser Stelle sei ein kleiner Hinweis gestattet. Die oben stehende Berechnung des Interpolants muss bei jedem Renderdurchlauf des Programms für jeden Punkt des Meshes durchgeführt werden. Je nach Größe und Komplexität des Meshes kommen hier schon mal ein paar tausend Berechnungen pro Durchlauf zusammen. Dies kann sich also auf die Performance des Programms auswirken. Deshalb sollte man beim Design der Mesh-Dateien darauf achten, nicht unnötig viele Polygone für seine Objekte zu nutzen. Wir müssen also das oben beschriebene Verfahren in unserer Funktion unterbringen. Dazu werden wir als Erstes den Interpolant berechnen, danach die beiden Frames mit Hilfe der GraphicsStream-Lock-Kombination auslesen und diese Daten mittels des Vector3.Lerp- Befehles berechnen. Zum Schluss werden die Daten für den Rendervorgang aufbereitet.

276


Wie das genau programmiertechnisch zu realisieren ist, sehen wir uns jetzt einmal an. Wir beginnen damit, die benötigten Zeitwerte für die Berechnung des Interpolants zu ermitteln. In Zeile 3 wird der Zeitwert des Startframes (A) bestimmt. Gleiches geschieht in Zeile 4 mit dem Zielwert (B). Den dritten benötigten Wert zur Berechnung des Interpolants bekommen wir durch den aktuellen Zeitindex (V), der mit Hilfe der CType-Funktion in Zeile 5 auch auf die gewünschte Form gebracht wird. 1

2 3

4

5

Public Sub CalculateFrame(ByVal lastFrame As Integer,_ ByVal nextFrame As Integer,_ ByVal currentTimeIndex As Integer) Dim a As Integer Dim StartTime As Single = CType(_ AnimationsObjektArray(lastFrame).TimeIndex,_ Single) Dim EndTime As Single = CType(_ AnimationsObjektArray(nextFrame).TimeIndex,_ Single) Dim CurrentTime As Single = CType(_ currentTimeIndex, Single)

Nachdem wir nun alle Daten für die Berechnung als Single-Typ vorliegen haben, können wir uns an die Berechnung des Interpolants begeben. Wir haben die zu erklärende Funktion in drei Schritte aufgeteilt. Jede Zeile steht für einen Teil der Berechnung. In Zeile 6 wird der Zeitindex des Startframes von der des Zielframes abgezogen ( B – A ). Die Berechnung V – A wird in der Zeile 7 vorgenommen. Dabei wird der Index des Startframes von der aktuelle Zeit abgezogen wird. Diese beiden Teilergebnisse werden zum Schluss noch in der Zeile 8 dividiert und so der Interpolant bestimmt, der in der Variablen interpolateAmount gespeichert wird. 6 7 8

EndTime = EndTime – StartTime CurrentTime = CurrentTime – StartTime Dim interpolateAmount As Single = CurrentTime / EndTime

Nun haben wir den wichtigsten Wert zur Animation unserer Keyframes bestimmt. Die nächsten Zeilen beinhalten zum größten Teil nur Deklarationen von Objekten, die wir im Laufe der Subroutine noch benötigen werden. Aus diesem Grund gehen wir an dieser Stelle nicht auf jede einzelne Zeile ein. Zusätzlich werden noch die zur Berechnung des Renderframes benötigten Daten aus den beiden Frames in temporäre Variablen kopiert.

Keyframe-Interpolation 9 10 11 12 13

14

15

16

17

277

Dim Dim Dim Dim Dim

dst As Direct3D.GraphicsStream = Nothing renderVertexArray As Vertex() = Nothing currentVertexArray As Vertex() = Nothing nextVertexArray As Vertex() = Nothing renderMeshSourceVB As Direct3D.VertexBuffer = _ currentAnimationsObjekt.mesh.VertexBuffer Dim currentMeshSourceVB As Direct3D.VertexBuffer = _ AnimationsObjektArray(lastFrame).mesh.VertexBuffer Dim nextMeshSourceVB As Direct3D.VertexBuffer = _ AnimationsObjektArray(nextFrame).mesh.VertexBuffer Dim RenderBufferSize As Integer = DirectX.DXHelp_ .GetTypeSize(GetType(Vertex)) * _ AnimationsObjektArray(lastFrame).Vertices Dim maxVertices As Integer = AnimationsObjektArray_ (lastFrame).mesh.NumberVertices

Der erste Schritt in der Berechnung unseres Renderframes ist die Belegung eines Speicherbereichs mit Hilfe eines GraphicsStream-Objektes in Zeile 18. In den nächsten drei Zeilen werden die VertexArrays der jeweiligen Frames vorbereitet und für die weitere Verarbeitung reserviert. Nun wird in den Zeilen 22 bis 24 die eigentliche Berechnung der Animation ausgeführt. In einer For-Next-Schleife werden alle Vertices der vorher definierten Vertex-Arrays durchlaufen und in Zeile 23 mit der Vector3.Lerp-Methode bearbeitet. Diese Methode interpoliert zwei vorgegebene Vektoren mit Hilfe des interpolateAmount-Wertes und gibt das Ergebnis als neuen Vektor zurück. Nachdem so alle Vektoren berechnet wurden, wird das Ergebnis im vorbereiteten GraphicsStream gespeichert. 18

19

20

21

22 23

24 25

dst = currentAnimationsObjekt.VertexB.Lock(0,_ RenderBufferSize, 0) renderVertexArray = CType(renderMeshSourceVB.Lock(0, _ GetType(Vertex), 0, maxVertices), Vertex()) currentVertexArray = CType(currentMeshSourceVB.Lock(0,_ GetType(Vertex), 0, maxVertices), Vertex()) nextVertexArray = CType(nextMeshSourceVB.Lock(0,_ GetType(Vertex), 0, maxVertices), Vertex()) For a = 0 To maxVerticies – 1 renderVertexArray(a).p = Microsoft _ .DirectX.Vector3.Lerp(currentVertexArray(a).p, _ nextVertexArray(a).p, interpolateAmount) Next a dst.Write(renderVertexArray)

Zum Schluss der Subroutine bleibt uns nur noch, die temporär erstellten Objekte wieder freizugeben und danach zu löschen, damit diese nicht den Arbeitsspeicher unseres Systems belegen.

278

26 27 28 29 30 31 32


currentAnimationsObjekt.VertexB.Unlock() renderMeshSourceVB.Unlock() nextMeshSourceVB.Unlock() renderMeshSourceVB.Dispose() currentMeshSourceVB.Dispose() nextMeshSourceVB.Dispose() End Sub

26.6 Keyframe rendern Zu guter Letzt steht uns in unserer DXDynamicMesh-Klasse ein berechnetes Mesh-Objekt zur Verfügung, das wir jetzt ohne lange zu zögern rendern wollen. Mit dem Befehl DynamicMeshObjektRendern in der Renderfunktion der Hauptklasse wird diese dann auch umgehend in der Klasse angestoßen. clsMesh.DynamicMeshObjektRendern(D3DDevice)

Im Gegensatz zu der Renderfunktion der statischen Mesh-Klasse können wir die DrawSubset-Methode bei unserem dynamisch erzeugten Objekt nicht mehr benutzen. Es handelt sich hier nämlich strenggenommen nicht mehr um ein Mesh, sondern um einen reinen Vertexbuffer. Deshalb gehen wir beim Rendern des Objektes genau wie bei jedem anderen geometrischen Objekt vor. Als Erstes müssen wir wieder die aktuelle Worldmatrix des Devices, speichern um diese nachher wieder herstellen zu können. Danach weisen wir der WorldMatrix des Devices die objekteigenen Matrixeinstellungen zu. In Zeile 5 weisen wir dem Device dann die Textur zu, die für den Rendervorgang unseres Objektes benutzt werden soll. Mit dem SetStreamSource-Befehl des Devices übergeben wir die zu rendernden Vertexdaten an eben dieses. Anschließend erhält das Device auch noch die benötigten Indexinformationen. In Zeile 9 wird nun endgültig das Objekt durch den Befehl DrawIndexedPrimitives im Device gezeichnet. Am Ende bleibt uns nur noch die gespeicherte Worldmatrix wiederherzustellen und die Funktion geordnet zu verlassen. 1

2 3 4

5 6

Public Function DynamicMeshObjektRendern(ByRef device As _ Microsoft.DirectX.Direct3D.Device) As Boolean Try 'objekt rendern Dim tmpMatrix As DirectX.Matrix = _ device.Transform.World device.Transform.World = MatrixObject() device.SetTexture(0, ObjektTexture())

Keyframe rendern 7

8 9

10 11 12 13 14 15

279

device.SetStreamSource(0, currentAnimationsObjekt_ .VertexB, 0, DirectX.DXHelp_ .GetTypeSize(GetType(Vertex))) device.Indices = currentAnimationsObjekt.IndexB device.DrawIndexedPrimitives(Direct3D.PrimitiveType_ .TriangleList, 0, 0, currentAnimationsObjekt_ .Vertices, 0, currentAnimationsObjekt.Faces) device.Transform.World = tmpMatrix Return True Catch Return False End Try End Function

Jetzt haben wir alle Funktionen kennen gelernt, die wir zur Animation unseres Objektes benötigen. Wenn wir unser Projekt starten, bekommen wir unser animiertes Objekt dargestellt. Wir können uns die Figur von allen Seiten ansehen, indem wir sie um alle drei Achsen drehen lassen.

Abb. 74. Mesh_Demo-Projekt

Damit haben wir das Kapitel der Mesh-Animation erfolgreich beendet. Als Fazit bleibt zu sagen, dass wir hier an dieser Stelle die beiden meistgenutzten Animationsarten erläutert haben. Es gibt noch weitere Animationstechniken, auf die wir bewusst nicht eingegangen sind, da diese den Rahmen einer ersten Einführung in das Thema bei weitem gesprengt hät-

280


ten. Wir werden das Thema Animation aber nicht aus dem Auge verlieren und auf unserer Internetseite (www.directxATvb.de) exklusiv für unsere Leser in nächster Zeit weitere Demos veröffentlichen.

27 Billboarding

Billboards werden auch 3D-Sprites genannt. Dennoch ist Billboarding mit einem herkömmlichen Sprite nicht vergleichbar. Wir sollten uns zunächst die Unterschiede dieser beiden Techniken anschauen. Tabelle 11. Vergleich Sprites und Billboarding Eigenschaft zweidimensional werden immer zum Betrachter ausgerichtet werden immer zum Monitor ausgerichtet können eine räumliche Position einnehmen besitzen einen transparenten Hintergrund werden von Lichteffekten beeinflusst können auf Kollision getestet werden

Sprite ja nein ja nein ja nein nein

Billboarding ja ja nein ja ja bedingt ja ja

Wie Sie sehen, herrscht in vielen Punkten Übereinstimmung. Dennoch unterscheiden sich die Techniken in einigen elementaren Eigenschaften. Die wesentlichste Unterscheidung finden wir in der räumlichen Position. Hiermit ist die Z-Koordinate gemeint. Ein Sprite besitzt keine ZKoordinate. Das können Sie mit einem Post-It vergleichen, welches Sie direkt auf Ihren Monitor kleben. Da es sich immer in vorderster Reihe befindet, wird es alle anderen Objekte überlagern.

27.1 Was sind Billboards? Was sind Billboards nun wirklich. Die Frage ist einfach zu beantworten. Billboards sind Polygone (Dreiecke). Nehmen wir ein rechteckiges Billboard. Dieses wird aus zwei Dreiecken zusammengestellt. Dieses platzieren wir an eine beliebige Stelle in unsere 3D-Welt. Bisher ist das nichts Neues. Das haben wir bereits einige Male getan. Aber was passiert, wenn wir mit der Kamera im Kreis um diese Fläche kreisen. Sobald wir uns der Seite unserer Fläche nähern, wird diese immer dünner. Die Fläche wird nicht zur Kamera ausgerichtet.

282

Billboarding

Jetzt kommt der Billboard-Effekt. Wenn wir die Fläche immer zur Kamera ausrichten, dann würden wir die Fläche niemals von der Seite sehen können. Somit könnten wir auch nicht erkennen, wie dick die Fläche ist, und wenn wir nicht erkennen können, wie dick die Fläche ist, dann erwecken wir den Eindruck, die Fläche wäre dreidimensional.

27.2 Warum werden Billboards eingesetzt? Sie könnten meinen, dass Billboard eine veraltete Technik wäre. Moderne Programme benötigen diese Methode nicht. Schließlich haben moderne Computer Rechenpower im Überschuss. Hierzu können wir Folgendes sagen. Sie hätten Recht aber auch Unrecht. Sicherlich haben Billboards an Glanz verloren und die Einsatzgebiete sind weniger geworden. Dennoch kommt kaum ein Computerspiel ohne Billboards aus. Hierzu möchten wir Ihnen zwei Beispiele vorstellenm, ein gutes und ein schlechtes Beispiel. Fangen wir mit dem schlechten Beispiel an: 27.2.1 Schlechtes Billboarding Ein typisches Beispiel für Billboarding ist die Darstellung von Bäumen. Viele ältere Spiele nutzten Billboards, um Bäume darzustellen. Aus der Ferne ist das auch kein Problem. Die Bäume werden zur Kamera ausgerichtet und der Betrachter bemerkt den Trick nicht. Dummerweise kann sich der Spieler in diesen Spielen bewegen. Sollte der Spieler auf einen Baum zugehen und direkt vor dem Baum stehen bleiben, dann hat sich die Perspektive nicht geändert. Er schaut nicht von unten in die Baumkrone sondern immer noch direkt von vorn. Der Trick ist als Illusion entlarvt. 27.2.2 Gutes Billboarding Explosionen sind ein gutes Beispiel für den Einsatz von Billboarding. Explosionen sind kurzfristig. Der Spiele hat meistens nicht die Gelegenheit in die Explosion zu laufen, und wenn er es dennoch schafft, dann befindet er sich im Zentrum des Sturms und er kann den Billboarding-Trick nicht erkennen. Wir könnten die Explosion auch durch ein 3D-Modell darstellen. Aber überlegen Sie sich einmal, was hier für Arbeit auf einen zukommt. Eine Explosion ist voller Dynamik. Wir müssten das 3D-Modell kontinuierlich in seiner Form anpassen. Ebenfalls müssten wir die Textur fluktuieren lassen.

Berechnungsmethoden

283

Einfacher ist in diesem Fall die Billboard-Technik. Hier müssen wir nur die Textur wie bei einem Daumenkino durchblättern. Genauso wie bei einem Sprite.

27.3 Berechnungsmethoden Billboards werden immer zur Kamera ausgerichtet. Hieraus ergeben sich zwei Berechnungsmethoden: Zum einen können wir die Ausrichtung für jedes einzelne Billboarding-Objekt berechnen oder wir können eine allgemein gültige Weltmatrix berechnen. Einzelberechnung Bei der Einzelberechnung müssen wir jedes Billboarding-Objekt einzeln berechnen und anschließend zur Kamera drehen. Hierbei bleibt das Objekt an der ursprünglichen Position in der 3D-Welt stehen. Unglücklicherweise müssen wir bei dieser Berechnungsart jedes Vertex einzeln rotieren. Bei vielen oder komplexen Billboarding-Objekten kann sich das auch als Performance-Killer herausstellen. Worldmatrix Bei der Berechnung über eine Worldmatrix machen wir uns das Leben etwas leichter. Wir erstellen eine Matrix mit Ausrichtung zur Kamera. Anschließend drehen wir die gesamte Welt und rendern dann die einzelnen Billboarding-Objekte. Also eine Matrix für alle Objekte. Nachdem wir die Objekte gerendert haben, drehen wir die Weltmatrix in die Ursprungsposition zurück und rendern den Rest der 3D-Objekte. Leider hat diese Technik auch ihre Schattenseiten. Schattenseiten können wir sogar wörtlich nehmen. Wir wissen, dass wir vor dem Rendern die Worldmatrix verändern. Aber wie wirkt sich das z.B. auf Lichtquellen aus. Nehmen wir den Fall an, dass eine Lichtquelle genau neben einem Billboard-Objekt platziert ist. Wenn wir nun die Worldmatrix vor dem Rendern des Billboard-Objektes verändern, dann ist zum Zeitpunkt des Renderns die Lichtquelle nicht da. Das bedeutet, dass die Lichtquelle beim Rendern des Objektes nicht berücksichtigt wird und dadurch die Lichtberechnung erfälscht wird. Im schlimmsten Fall würde das Objekt schwarz bleiben.

284

Billboarding

27.4 Beispielprogramm für Billboarding Wie einfach Billboarding in der Praxis einzusetzen ist, werden Sie anhand unseres Beispielprogramms erkennen. Einfache Strukturen und überschaubare Objekte erleichtern diesen Themenbereich. Wir werden lediglich drei Objekte verwenden. Eine Bodenplatte sowie zwei Anzeigen. Die Bodenplatte können wir völlig ignorieren. Sie soll lediglich demonstrieren, dass wir uns mit der Kamera kreisend bewegen. Für die beiden Anzeigen verwenden wir je zwei Polygone. Ein Polygon wird per Billboarding kontinuierlich zur Kamera ausgerichtet. Das zweite Polygon unterliegt nicht den Billboarding-Berechnungen. Wir verwenden lediglich zwei Objekte, um eine direkte Vergleichbarkeit zu gewährleisten. Insbesondere am zweiten Objekt können Sie erkennen, dass die Objekte keine Tiefe besitzen. Ohne Tiefe sind das natürlich keine echten dreidimensionalen Objekte. Damit dieser Missstand nicht auffällt, verwenden wir Billboarding.

Abb. 75. Billboarding (Beispielprogramm)

Folgende Techniken müssen wir in diesem Beispiel näher betrachten: • Texturoberfläche erstellen • Hauptspieleschleife erzeugen

Beispielprogramm für Billboarding

285

• Rendern 12 13

mit Billboarding ohne Billboarding

27.4.1 Textureoberfläche erstellen Warum erläutern wir das Erstellen einer Textureoberfläche? Das haben wir schließlich schon einige Male getan. Wir tun dies erneut an dieser Stelle, weil wir eine kleine Besonderheit berücksichtigen müssen. Billboarding funktioniert nur, wenn das Billboarding-Objekt mit SpriteEigenschaften aufwarten kann. Hierzu gehört vor allem ein transparenter Hintergrund. Es ist leicht verständlich, warum ein transparenter Hintergrund das A und O von Billboarding bedeutet. Bei Billboarding sprechen wir von einer rechteckigen flachen Form – einem Blatt Papier. Dieses Blatt Papier besitzt einen Rand. Dieser Rand darf natürlich nicht erkennbar sein. Sollten die Konturen sich in der 3D-Szene abzeichnen, funktioniert die Billboarding-Illusion nicht mehr. Zum Erstellen der Textureoberfläche verwenden wir die Subroutine CreateTextureSurface(). 1 2 3

Private Sub CreateTextureSurface() '*** Bodentextur Geo1.CreateTextureSurface(D3DDevice, DXUtilities.FindMediaFile("Texturen\Metal_GalvanizedS.jpg"))

In Zeile 3 erstellen wir die TextureSurface der Bodenplatte. Diese wird intern in der Geometry-Klasse erzeugt. Für unser Beispiel ist die Bodenplatte ohne Bedeutung. 4 5

'*** Billboardtextur Texture1 = Direct3D.TextureLoader.FromFile(D3DDevice, DXUtilities.FindMediaFile("Bilder\with_Billboarding.bmp "),_ 0, 0, _ Direct3D.D3DX.Default, _ 0, _ Microsoft.DirectX.Direct3D.Format.Unknown, _ Direct3D.Pool.Default, _ Direct3D.Filter.Linear, _ Direct3D.Filter.Linear, _ System.Drawing.Color.Black.ToArgb)

Zeile 5 ist für unsere Billboardtextur reserviert. Der letzte Parameter bestimmt eine Transparenzfarbe. In unserem Fall nutzen wir einen schwarzen Hintergrund, also wählen wir als Transparenzfarbe Schwarz.

286

6 7

8

Billboarding

'*** Billboardtextur Texture2 = Direct3D.TextureLoader.FromFile(D3DDevice, DXUtilities.FindMediaFile("Bilder\without_Billboarding.bmp"), _ 0, 0, _ Direct3D.D3DX.Default, _ 0, _ Microsoft.DirectX.Direct3D.Format.Unknown, _ Direct3D.Pool.Default, _ Direct3D.Filter.Linear, _ Direct3D.Filter.Linear, _ System.Drawing.Color.Black.ToArgb) End Sub

Mit der Zeile 7 erstellen wir die Textur für unser zweites Objekt. Dieses ist zwar nicht unser Billboarding-Objekt, aber dennoch wollen wir einen transparenten Hintergrund. Somit verwenden wir die gleiche Technik zum Erstellen der Textur. 27.4.2 Hauptspieleschleife erzeugen Die Hauptschleife ist schnell erklärt. Sie dient lediglich dazu, die notwendige Rotationsgeschwindigkeit der Kamera sowie die Framerate zu berechnen. Falls ein Fehler auftritt, wird das Programm beendet. 1 2 3 4 5 6 7 8 9 10 11

While Run Try oFrame.Tick = 1 CalcAddSpeed() Render() Catch Run = False End End Try Application.DoEvents() End While

In Zeile 3 finden Sie den Aufruf zur Berechnung der Framerate. Die eigentliche Berechnung findet dann in der DXUtilites-Klasse statt. Zur Frameraten-Berechnung müssen wir zwei Werte übergeben. 1

2 3

'Messzeit und Startzeit für die Berechnung der _ Framerate setzen oFrame.MessureTime = 1000 oFrame.StartTime = Environment.TickCount

Beispielprogramm für Billboarding

287

Wir haben die Messzeit auf 1000 Millisekunden festgelegt. Hierdurch wird jede Sekunde folgendes Ereignis ausgelöst. 1 2 3

Private Shared Sub NewFrameRate(ByVal Tick As Integer) iFrameRate = Tick End Sub

Die ermittelte Framerate wird der Variablen iFrameRate übergeben. Nachdem wir die Framerate ermittelt haben, möchten wir noch die Rotationsgeschwindigkeit der Kamera berechnen. Hierzu verwenden wir die Subroutine CalcAddSpeed(). 1 2 3

4 5

Private Sub CalcAddSpeed() Dim Time As Double Time = _ DXTimer.Timer(DXTimer.DirectXTimer.GetElapsedTime) Speed = 45.0F * Time End Sub

In Zeile 4 verwenden wir den Wert 45.0F. In unserem Fall möchten wir die Rotationsgeschwindigkeit festlegen. Hierzu werden wir natürlich mit einem Winkel (Blickwinkel) arbeiten. Der Wert 45.0F bedeutet eine Rotation von 45 Grad pro Sekunde. Somit werden wir für eine volle Umdrehung 8 Sekunden benötigen. Aufgrund der Berechnungsmethode ist das auf allen Systemen gleich. Hierbei spielt es keine Rolle, ob es sich um einen schnellen oder um einen langsamen PC handelt. Ein langsamer PC wir dann natürlich ruckeln. 27.4.3 Rendern Die Subroutine Render() sorgt für die Szenendarstellung. Hier wird der Backbuffer / Z-Buffer gelöscht, World-, View- und Projektionsmatrix aktualisiert, Text dargestellt und natürlich Objekte gerendert. 1 2 3

Private Sub Render() Dim msg As Boolean '*** Hintergrund der Ausgabeform sowie den Z-Buffer löschen

4 5

6

D3DDevice.Clear(Direct3D.ClearFlags.Target Or _ Direct3D.ClearFlags.ZBuffer, _ System.Drawing.Color.FromArgb(255, 0, 0, 0), 1.0F, 0) 'Voreinstellung zum Erstellen des Direct3D-Devices

7 8

D3DDevice.BeginScene()

288 9

Billboarding

'Kameraposition aktualisieren

10 11 12

CreateVertexBuffer() 'World-, View- und Projektionsmatrix aktualisieren

13 14 15

SetupMatrices() 'Bildschirmtexte einblenden

16 17 18

DrawText() 'Objekte rendern

19 20 21 22 23 24 25 26 27 28

Geo1.Render() If CameraWinkel > 0 And CameraWinkel < 180 Then Billboarding() withoutBillboarding() Else withoutBillboarding() Billboarding() End If 'Scene schliessen

29 30 31

D3DDevice.EndScene() 'Scene darstellen

32 33 34

D3DDevice.Present() End Sub

Richtig interessant wird es in den Zeilen 21 bis 27. Hier wird eine wichtige Entscheidung getroffen. Zur Erinnerung: Wir verwenden zwei Objekte. Je nach Kameraposition wird Objekt 1 vor Objekt 2 oder Objekt 2 vor Objekt 1 dargestellt. Da die Objekte einen transparenten Hintergrund haben, muss das Objekt, welches das andere Objekt überlagert, als letztes gerendert werden. Also wenn sich Objekt 1 im Vordergrund befindet, dann wir zuerst Objekt 2 gerendert und anschließend Objekt 1. Billboarding Kommen wir nun zur eigentlichen Billboarding-Berechnung. Diese finden wir in der Subroutine Billboarding(). Sie erinnern sich? Wir wollen eine Billboarding-Matrix für die gesamte Welt berechnen. Dies ist wesentlich schneller und auch leichter umsetzbar. Die Matrix wird in den Zeilen 4 - 8 berechnet. 1 2 3

4

Private Sub Billboarding() BillboardMatrix = D3DDevice.Transform.World Dim vDir As DirectX.Vector3 = DirectX.Vector3.Subtract _ (New DirectX.Vector3(0.0F, 0.0F, 0.0F), CameraPos) If vDir.X > 0.0F Then

Beispielprogramm für Billboarding 5

6 7

8 9

289

BillboardMatrix = DirectX.Matrix.RotationY _ (CSng(-Math.Atan(vDir.Z / vDir.X) + Math.PI / 2)) Else BillboardMatrix = DirectX.Matrix.RotationY _ (CSng(-Math.Atan(vDir.Z / vDir.X) - Math.PI / 2)) End If tmpMatrix = D3DDevice.Transform.World

In Zeile 9 speichern wir die aktuelle Worldmatrix. Diese benötigen wir nach dem Rendern des Billboarding-Objektes zum Rendern der restlichen Objekte. Wir müssen sozusagen die Welt wieder gerade rücken. 10 11 12

BillboardMatrix.M41 = -2 BillboardMatrix.M42 = 0 BillboardMatrix.M43 = 0

Da wir eine neue Worldmatrix berechnet haben, sind die Positionsangaben verloren gegangen. Mit den Zuweisungen in den Zeilen 10 - 12 korrigieren wir das. 13

D3DDevice.Transform.World = BillboardMatrix

In Zeile 13 wird die neue Matrix der 3D-Welt zugewiesen. Ab jetzt hat die Billboarding-Matix das Sagen. In Zeile 31 wird diese Zuweisung wieder rückgängig gemacht. 14 15 16 17 18 19 20 21

22

Try Dim mtrl As Direct3D.Material mtrl.Ambient = System.Drawing.Color.White mtrl.Diffuse = System.Drawing.Color.White mtrl.Specular = System.Drawing.Color.White D3DDevice.Material = mtrl 'iMaterial D3DDevice.RenderState.AlphaBlendEnable = True D3DDevice.RenderState.SourceBlend = _ Direct3D.Blend.SourceAlpha D3DDevice.RenderState.DestinationBlend = _ Direct3D.Blend.InvSourceAlpha

Einen transparenten Hintergrund erhalten wir durch Alpha-Blending. In den Zeilen 20 - 22 werden die notwendigen Parameter eingestellt. So erhalten wir einen komplett transparenten Hintergrund. 23

D3DDevice.SetTexture(0, Texture1)

24

D3DDevice.SetStreamSource _ (0, WithBillboardingVertexBuffer, 0) D3DDevice.VertexFormat = _ Direct3D.CustomVertex.PositionNormalTextured.Format

25

290 26

27 28 29 30 31 32

Billboarding

D3DDevice.DrawPrimitives _ (Direct3D.PrimitiveType.TriangleList, 0, 6 / 3) D3DDevice.RenderState.AlphaBlendEnable = False Catch MessageBox.Show("Fehler Render: whithBillboard") End Try D3DDevice.Transform.World = tmpMatrix End Sub

28 Wasser

Vielleicht haben Sie schon einmal versucht eine Wasseroberfläche zu erschaffen. Mit diesem Kapitel wollen wir Ihnen die notwendige Technik offen legen. Natürlich ist es nicht leicht, eine realistische Wasseroberfläche zu programmieren. Hieran haben sich bereits die Besten versucht und sind gescheitert. Zwar sind die Oberflächen immer besser geworden, aber von einer wirklich realistischen Wasseroberfläche kann man nicht sprechen. Das ist aber auch nicht unbedingt notwendig. In den meisten Fällen reicht es, die Assoziation mit Wasser zu erzeugen. Außerdem stehen Realismus und Performance meistens in striktem Widerspruch. Für ein komplexes Spiel ist eine realistische Wasseroberfläche viel zu rechenintensiv. Haben Sie ein Spiel oder ein Demo zur Hand – dann betrachten Sie die Wasseroberflächen etwas genauer. Manchmal kann man sehr gut erkennen, welche Technik verwendet wurde. Aber kehren wir zu unserer eigenen Wasseroberfläche zurück. Hierzu ist es hilfreich, wenn wir uns die charakteristischen Eigenschaften von Wasser anschauen. Zur programmtechnischen Umsetzung konzentrieren wir uns auf die Elementareigenschaften: • Wasser ist transparent • Wasser ist stehts in Bewegung • Wasser ist wellig Wir werden gleichmäßige Meereswellen mit mehreren schwimmenden Kisten erzeugen. Hierzu verwenden wir einen dynamischen Wellengenerator, welcher uns das Einstellen von individuellen Welleneigenschaften erlaubt. Die schwimmende Kiste wird dem Wellengang folgen und so die Szene realistischer wirken lassen.

292

Wasser

Abb. 76. Wasser mit Wellen und schwimmenden Kisten

Was benötigen wir zur Realisierung dieses Beispiels? • • • •

Technik zum Erstellen der Wasseroberfläche Wasseroberfläche erstellen (inkl. Wellen und Textur) Schwimmende Kisten integrieren Rendern (Alpha-Blending)

28.1 Technik zum Erstellen der Wasseroberfläche Zunächst überlegen wir uns, wie wir Wellen erzeugen bzw. berechnen können. Am einfachsten ist das „Auf und Ab“ einer Welle mit dem Verlauf einer horizontalen Sinuskurve vergleichbar.

Technik zum Erstellen der Wasseroberfläche

293

Abb. 77. Sinuskurve

Die Sinuskurve liefert uns einen harmonischen Verlauf. Dieser wird automatisch mit dem harmonischen „Auf und Ab“ des Wassers (Meer) assoziiert. Idealerweise können wir über die Modifikation der Amplitude die Wellenhöhe beeinflussen. Dies ermöglicht die Anpassung an stille oder stürmische See.

Abb. 78. Sinuskurve mit veränderter Amplitude

Durch die Änderung der Kreisfrequenz wird die Welle gedehnt oder gestaucht. Auch hiervon gibt es ein kleines Schaubild.

Abb. 79. Sinuskurve mit veränderter Kreisfrequenz

294

Wasser

Diese drei Manipulationsmöglichkeiten helfen uns die Wellenform (Oberflächengestalt) individuell anzupassen. Würden wir die Welle so in Bewegung bringen, würden wir ein wunderbares „Auf und Ab“ beobachten. Bei genauerem Hinsehen würden wir jedoch schnell bemerken, dass die einzelnen Wellen auf der Stelle stehen. Die Welle würde sich nicht vom offenen Meer zum Strand bewegen. Wir benötigen noch die Möglichkeit der Amplitudenverschiebung (Phasenwinkel).

Abb. 80. Sinuskurve mit verändertem Phasenwinkel

Bevor Sie es merken, gestehen wir es lieber sofort. Kreisfrequenz und Phasenwinkel werden wir für unser Demo nicht benötigen. Dennoch haben wir die Begriffe der Vollständigkeit halber erläutert. Schließlich stellen wir nur eine Möglichkeit der Wellengestaltung vor. Entwickeln Sie das Demo weiter oder kreieren Sie Ihren eigenen Wellengenerator. Vielleicht noch realistischer als in unserem Beispiel.

28.2 Aufbau der Wasseroberfläche (Gittergerüst) Wir wissen, wie wir eine Welle berechnen. Wie aber können wir eine Welle auf dem Bildschirm darstellen? Natürlich benötigen wir ein Vertexgitter.

Abb. 81. Vertexgitter für die Wasseroberfläche

Wasseroberfläche erstellen (inkl. Wellen und Textur)

295

Mit diesem Gitter können wir Wellen über die gesamte Wasseroberfläche erzeugen. Stellen Sie sich vor, die Vertices würden dem Verlauf der Sinuskurve folgen. Hierbei haben jeweils zwei Vertices die gleiche Höhe, also Vertex 1 und Vertex 2 sowie Vertex 3 und Vertex 4 usw.

28.3 Wasseroberfläche erstellen (inkl. Wellen und Textur) Jetzt wird es ernst. Wir erstellen den dynamischen Wellengenerator. Unser Wellengenerator ist eine Funktion, welche uns anhand der übergebenen Parameter einen fertigen Vertexbuffer zurückgibt. Um diesen Vertexbuffer zu erstellen, benutzen wir die Funktion CreateWaves(). Diese hat folgende Parameter: move. Der Wertebereich von move liegt zwischen 0 und 360. Betrachtet man den Wertebereich als Gradeinheit, so würde 0 den Anfang einer Sinuskurve und 360 das Ende einer Sinuskurve beschreiben. Speed. Speed beschreibt die Geschwindigkeit, mit der die Textur über die Wellen bewegt wird. Hierdurch entsteht der Eindruck, das Wasser würde strömen. Wellenhöhe. Äquivalent zur Amplitude der Sinuskurve WasserLänge. Länge der Wasserfläche WasserBreite. Breite der Wasserfläche 1 2 3 4 5 6 7 8

9

Public Shared Function CreateWaves( _ ByVal device As Direct3D.Device, _ ByVal move As Single, _ ByVal Speed As Single, _ ByVal Wellenhöhe As Single, _ ByVal WasserLänge As Single, _ ByVal WasserBreite As Single) As Direct3D.VertexBuffer Dim VertexBuffer As Direct3D.VertexBuffer = _ New Direct3D.VertexBuffer(GetType_ (Direct3D.CustomVertex.PositionColoredTextured), 62, _ device, Direct3D.Usage.WriteOnly,_ Direct3D_ .CustomVertex.PositionColoredTextured.Format, _ Direct3D.Pool.Default) Dim vb As Direct3D.VertexBuffer = _ CType(VertexBuffer, Direct3D.VertexBuffer)

296 10

11 12 13 14 15

16 17

18 19

20 21

22 23 24 25 26

Wasser

Dim verts As Direct3D.CustomVertex_ .PositionColoredTextured() = CType(vb.Lock(0, 0),_ Direct3D.CustomVertex.PositionColoredTextured()) Dim tmpWasserLänge = WasserLänge / 30 Dim tmpWasserBreite = WasserBreite / 2 Dim x As Single For x = -15 To 15 verts((x + 15) * 2 + 0).SetPosition_ (New DirectX.Vector3(CSng(x * tmpWasserLänge),_ CSng(Math.Sin(x + move) * Wellenhöhe), _ CSng(tmpWasserBreite))) verts((x + 15) * 2 + 0).Color = C110 verts((x + 15) * 2 + 0).Tu = _ ((x + 15) / 30) + move / Speed verts((x + 15) * 2 + 0).Tv = 1 verts((x + 15) * 2 + 1).SetPosition_ (New DirectX.Vector3(CSng(x * tmpWasserLänge), _ CSng(Math.Sin(x + move) * Wellenhöhe), _ CSng(-tmpWasserBreite))) verts((x + 15) * 2 + 1).Color = C010 verts((x + 15) * 2 + 1).Tu = _ ((x + 15) / 30) + move / Speed verts((x + 15) * 2 + 1).Tv = 0 Next x vb.Unlock() Return VertexBuffer End Function

Mit der Schleife von Zeile 14 bis Zeile 23 erstellen wir das benötigte Vertexgitter. Die Koordinaten der Vertices werden über die Parameter WasserLänge, Wellenhöhe, WasserBreite und move gesteuert. Für die eigentliche Wellenhöhe ist folgende Berechnung verantwortlich: CSng(Math.Sin(x + move) * Wellenhöhe)

Letztendlich haben wir einen dynamischen Wellengenerator geschaffen. Genauso dynamisch geht es mit der Textur weiter. Das Aufziehen der Textur ist vom Parameter move abhängig. Die Texturkoordinaten für die geraden Vertices lauten: Tu = ((x + 15) / 30) + move / Speed Tv = 1

Und die Texturkoordinaten für die ungeraden Vertices: Tu = ((x + 15) / 30) + move / Speed Tv = 0

Schwimmende Kisten integrieren

297

Mit dem Farbwert der Vertices können wir die Szene in eine bestimmte Atmosphäre tauchen. Hierdurch steigern wir den Realismus der Szene.

28.4 Schwimmende Kisten integrieren Wenn wir ein schwimmendes Objekt (in unserem Fall mehrere Kisten) in die Szene integrieren möchten, müssen wir uns zunächst überlegen, wie sich das Objekt verhalten soll. • Die Kiste soll zu einem bestimmten Anteil im Wasser verschwinden, also teilweise im Wasser und teilweise über Wasser zu sehen sein. • Da das Wasser transparent ist, soll der im Wasser liegende Teil erkennbar sein. • Die Kiste soll dem Wellengang folgen. Die beiden ersten Punkte machen uns keine Sorgen. Aber dass die Kisten dem Wellengang folgen sollen, ist etwas schwieriger. Da wir ein definiertes Vertexgitter für die Wasseroberfläche verwendet haben, lassen die Parameter Rückschlüsse auf die korrekten Höhenwerte der jeweiligen Kisten zu. Mit den Parametern WasserLänge, Anzahl der Vertexstreifen und move können wir die y-Position der Kisten berechnen. Damit das ein wenig klarer wird, betrachten wir die gesamte Funktion zum Erstellen der Kiste. 1 2 3 4 5 6 7 8

9

10

11

Public Shared Function CreateKiste( _ ByVal device As Direct3D.Device, _ ByVal move As Single, _ ByVal größe As Single, _ ByVal x As Single, _ ByVal z As Single, _ ByVal WasserLänge As Single) As Direct3D.VertexBuffer Dim VertexBuffer As Direct3D.VertexBuffer = _ New Direct3D.VertexBuffer_ (GetType(Direct3D._ CustomVertex.PositionColoredTextured), 36, device,_ Direct3D.Usage.WriteOnly, Direct3D.CustomVertex_ .PositionColoredTextured.Format, _ Direct3D.Pool.Default) Dim vb As Direct3D.VertexBuffer =_ CType(VertexBuffer, Direct3D.VertexBuffer) Dim verts As Direct3D.CustomVertex_ .PositionColoredTextured() = CType(vb.Lock(0, 0),_ Direct3D.CustomVertex.PositionColoredTextured()) Dim y As Single = _ Math.Sin((30 / WasserLänge * x) + move)

298

Wasser

verts(0) = CreateLitVertex(x - größe, y - größe, größe, C110, 0, 0, 0) 13 verts(1) = CreateLitVertex(x + größe, y + größe, größe, C110, 0, 1, 1) 14 verts(2) = CreateLitVertex(x - größe, y + größe, größe, C110, 0, 0, 1) 15 verts(3) = CreateLitVertex(x + größe, y + größe, größe, C110, 0, 1, 1) 16 verts(4) = CreateLitVertex(x - größe, y - größe, größe, C110, 0, 0, 0) 17 verts(5) = CreateLitVertex(x + größe, y - größe, größe, C110, 0, 1, 0) ... 12

18

19

20

21

22

23

24 25 26

verts(30) = CreateLitVertex(x größe, C110, verts(31) = CreateLitVertex(x + größe, C110, verts(32) = CreateLitVertex(x größe, C110, verts(33) = CreateLitVertex(x + größe, C110, verts(34) = CreateLitVertex(x größe, C110, verts(35) = CreateLitVertex(x + größe, C110, vb.Unlock() Return VertexBuffer End Function

größe, y 0, 0, 1) größe, y 0, 1, 0) größe, y 0, 0, 0) größe, y 0, 0, 1) größe, y 0, 1, 0) größe, y 0, 0, 0)

z +_ z +_ z +_ z +_ z +_ z +_

- größe, z +_ - größe, z +_ - größe, z -_ - größe, z +_ - größe, z -_ - größe, z -_

Diese Funktion liefert uns einen fertigen Vertexbuffer. Dieser kann unverzüglich in die Szene integriert werden. Bitte beachten Sie die Zeile 11. Hier wird die korrekte Höhe der Kiste ermittelt. Da die Parameter WasserLänge, move und die Anzahl der Vertexstreifen (in unserem Fall 30) mit der erstellten Wasserfläche übereinstimmen, kann die benötigte Höhe korrekt ermittelt werden. Über den Parameter größe können wir die Ausdehnung der Kisten beeinflussen.

28.5 Rendern Alpha-Blending Wir haben bereits davon gesprochen, dass die Wasseroberfläche eine gewisse Transparenz besitzt. Hierzu können wir die Alpha-BlendingEigenschaften von DirectX nutzen. Neben den passenden Parametern für die gewünschte Transparenz ist die Renderreihenfolge der Objekte von Bedeutung.

Rendern Alpha-Blending

299

In unserem Beispiel sind zwei Objekte an der Szene beteiligt. Objekt 1 ist das Wasser und Objekt 2 sind die Kisten. Die Kisten müssen zeitlich passend vor dem Wasser gerendert werden. Sollte die Reihenfolge nicht stimmen, können die Parameter für die Wassertransparenz nicht umgesetzt werden und die Kisten würden nicht durch das Wasser scheinen. Renderoptionen für die Kisten: 1

Direct3DDevice.RenderState.AlphaBlendEnable = False

Renderoptionen für das Wasser: 1 2

3

Direct3DDevice.RenderState.AlphaBlendEnable = True Direct3DDevice.RenderState.SourceBlend = _ DirectX.Direct3D.Blend.One Direct3DDevice.RenderState.DestinationBlend = _ DirectX.Direct3D.Blend.One

29 Nebel

DirectX-Programmierer streben stets nach möglichst realistischen Szenen. Um dieses Ziel zu realisieren, ist der Einsatz von Nebel eine gute Wahl. Vielleicht ist es Ihnen nicht bewusst, aber in der Realität haben wir es täglich mit Nebel zu tun. Selbst an scheinbar klaren Tagen können wir nicht unendlich weit blicken. Irgendwann werden die Objekte undeutlich und verschwinden am Horizont (im Nebel). Nebel ist allgegenwärtig, selbst wenn er noch so schwach ist. Nebel bietet eine gute Möglichkeit, eine bestimmte Atmosphäre zu schaffen. Hierzu gibt es viele Filmbeispiele aus der Gruselkategorie. Aber es muss nicht immer gruselig sein. Stellen Sie sich den roten Planeten Mars vor. Hier würde jedes Objekt leicht rötlich schimmern und alles würde in einem leichten rötlichen Dunst liegen. Programmiertechnisch könnten wir einen schwachen Nebel mit rotem Touch verwenden. Aber wir müssen nicht zu fernen Planeten schweifen, um den Einsatz von Nebel zu erläutern. Ein morgendlicher Spaziergang entlang des Hafens verlangt geradezu den Einsatz von Nebel. Für den Programmierer ist der Nebel ein wahrer Segen. Eines der größten Probleme des Programmierers ist die Begrenzung der Sichtweite. In so genannten In-Door-Levels ist dies weniger ein Problem. In-Door bedeutet, die Szene spielt in Räumen, in denen die Sichtweite durch Wände begrenzt wird. Aber wie sieht es im Freien (Out-Door) aus? Hier gibt es keine Wände, die den Blick ins Unendliche verhindern. Wenn wir die Sichtweite nicht begrenzen, schaut der Spieler ins Nichts. Bei DirectX würde dies im Regelfall einen Blick ins Schwarze bedeuten. Solche Perspektiven steigern nicht unbedingt den Realismus einer Szene. Aber mit einer Begrenzung der Sichtweite alleine ist es nicht getan. Vielleicht können Sie sich an alte Spiele erinnern, bei denen Objekte (Bäume, Häuser, Autos usw.) plötzlich im Bild erschienen sind. Es ist nicht realistisch, dass ein Objekt von der momentanen Position aus nicht, einen Schritt weiter jedoch voll und uneingeschränkt sichtbar wird. Realistischer ist es, wenn das Objekt beim nächsten Schritt langsam aus einem allgegenwärtigen Dunst (Nebel) eingeblendet würde.

302

Nebel

Was wäre nun der programmiertechnische Idealfall? Eine Sichtweitenbegrenzung durch Nebel. Hinter dem Nebel könnte die Welt zu Ende sein und der Spieler würde es nicht merken. Objekte werden langsam in die Szene eingeblendet, ohne sprunghaft zu erscheinen.

29.1 Was kann Nebel? Wir haben Ihnen erläutert, wann der Einsatz von Nebel sinnvoll ist. Leider gibt es aber auch Einschränkungen, die wir beachten müssen. Unter Nebel verstehen wir im Allgemeinen: Nebel, Bodennebel, Nebelbänke, Nebelschwaden oder Rauch. Vielleicht denken Sie auch an einen örtlich gebundenen Nebel (z.B. Nebel über einem kleinen See). An dieser Stelle muss ich Ihre Erwartungen etwas bremsen. Die Nebelmodelle von DirectX beherrschen lediglich einen allgemeinen Nebel. Dieser gilt dann für die gesamte Welt und kann nicht örtlich begrenzt werden. Lediglich Entfernungs-, Dichte- und Farbparameter werden zugelassen. Eine weitere Fähigkeit von Nebel ist es, Artefakte zu vermindern. Weit entfernt liegende Objekte werden stärker skaliert. Diese Skalierung ist eine Ursache für das Erscheinen von Artefakten. In diesem Zusammenhang sind Artekfakte als Rechenfehler zu betrachten, welche zu einer fehlerhaften Bildschirmausgabe führen. Wird diese fehlerhafte Bildschirmausgabe durch Nebel überlagert, dann ist der Fehler entweder weniger stark ausgeprägt oder gar ganz verschwunden.

29.2 Berechnungsarten DirectX verwendet zwei Berechnungsarten. Hier spricht man von Linear Fog und von Exponential Fog. 29.2.1 Linear Fog Die Berechnungsformel für Linear-Fog lautet:

f =

end − d end − start

• end beschreibt die Entfernung, in welcher der Nebel die maximale Stärke erreicht hat. • start beschreibt die Entfernung, in welcher der Nebel beginnt. Hier ist die minimale Auswirkung zu messen.

Berechnungsarten

303

• d beschreibt die Entfernung zur Kamera (Viewpoint). Je größer d wird, desto intensiver wird die Nebeldichte. Dies ist ein recht einfaches Rechenmodell: eine einfache lineare Verteilung. Nehmen wir ein Beispiel zur Hilfe. In unserem kleinen Beispiel verwenden wir folgende Parameter: Der Nebel beginnt direkt bei der Kamera (start = 0). Der Nebel soll 1000 Einheiten tief sein (end = 1000). Die aktuelle Tiefe wird über den Parameter d angegeben. So erhalten wir für folgende Rechnung direkt bei der Kamera (Entfernung (d) von 0). 1000 − 0 = 1.0 1000 − 0

Auf halben Weg (also bei einer Entfernung von 500) erhalten wir diese Berechung: 1000 − 500 = 0.5 1000 − 0

Objekte, welche in der maximalen Entfernung liegen, werden völlig vom Nebel eingehüllt. Hier die Berechnung: 1000 − 1000 = 0.0 1000 − 0

Sollten Sie sich über die Ergebnisse wundern, dann sollten Sie Folgendes beachten: • 1.0 bedeutet, dass ein Objekt nicht im Nebel liegt. • 0.0 bedeutet, dass ein Objekt völlig vom Nebel umhüllt wird. Das Objekt selber ist nicht mehr sichtbar. 29.2.2 Exponential Fog Exponential Fog berechnet sich, wie der Name schon sagt, exponentiell. Für dieses Berechnungsmodell wird weder ein Startwert noch ein Endwert benötigt. Folglich reicht dieser Nebel unendlich weit. Im Detail werden zwei Varianten unterschieden. Zum einen wäre da der einfach exponentiel-

304

Nebel

le Nebel und zum anderen finden wir den quadratisch exponentiellen Nebel. Einfach exponentieller Nebel: f=

e

1 d*Dichte

Quadratisch exponentieller Nebel: 1

f=

e

(d*Dichte)

2

• e ist die Basis des natürlichen Logarithmus (ca. 2.71828). • d ist die Entfernung. • Dichte ist ein Multiplikator, welcher die Intensität des Nebels beschreibt. Sein Wertebereich liegt zwischen 0.0 und 1.0. Interpretation der Werte Wir haben es bereits erwähnt, ein Nebelwert von 1.0 bedeutet, dass das Objekt vom Nebel nicht beeinflusst wird. Ein Wert von 0.0 hingegen bedeutet, dass das Objekt völlig im Nebel verschwindet. Es ist nicht mehr sichtbar. Für eine gewisse Irritation sorgt die Zuweisung 1 gleich keine Beeinflussung und 0 gleich maximale Beeinflussung. Die errechneten Nebelwerte geben an, wie viel von der ursprünglichen Objektfarbe (Pixelfarbe) eines Objektes erhalten bleibt. Haben wir einen Nebelwert von 0.7 ermittelt, so bleibt 70% der Objektfarbe erhalten und zu 30% fließt die Nebelfarbe ein. Ein Nebelwert von 0.0 bedeutet, dass 0% von der Objektfarbe erhalten bleibt und 100% von der Nebelfarbe einfließen.

29.3 VertexFog oder Pixel-Fog/Table-Fog In den vorangegangenen Abschnitten haben wir die Berechnungsmodelle kennen gelernt. Eine wichtige Unterscheidung fehlt uns aber noch. DirectX unterscheidet zwischen einer pixelorientierten und einer vertexorientierten Berechnung.

VertexFog oder Pixel-Fog/Table-Fog

305

Beim VertexFog (vertexorientierten Berechnung) wird die Nebelintensität für das einzelne Vertex berechnet. Diese Berechung ist etwas ungenauer als die Berechnungen beim PixelFog (pixelorientierte Berechnung). Bei den PixelFog-Berechnungen wird die Nebelintensität für jedes einzelne Pixel berechnet. Natürlich ist diese Berechnungsmethode wesentlich intensiver als die einfache vertexbasierte Berechnungsmethode. Um den erhöhten Rechenaufwand auszugleichen, wird von der Grafikkarte eine Nebeltabelle (Fog-Table) angelegt. Dies beinhaltet vorberechnete Werte für die unterschiedlichen Entfernungen und Berechnungsmethoden. Deshalb wird der Pixel-Fog auch Fog-Table genannt. Ungenaue oder nicht detaillierte Berechnungen können zu unschönen Effekten führen. Diese treten vor allem dann auf, wenn mit sehr großen Polygonen gearbeitet wird. Ein großes Polygon, welches einige hundert Einheiten in die Tiefe geht, kann mit dem einfachen VertexFog nicht ordentlich berechnet werden. Hierzu werden ja nur die Vertices zur Berechnung herangezogen. Vertex 1 liegt bei z = 0 und Vertex 2 liegt bei z = 375, zuletzt folgt Vertex 3 mit einer Tiefe von z = 200. Die Distanzen bei solch einem großen Polygon sind zu groß, so dass die Berechnungen ungenau und plump wirken. Hierfür benötigen wir die detailgetreue Berechnung des PixelFogs. Noch schlimmer wäre es, wenn ein Teil des Polygons im Nebel liegen soll und ein anderer Teil außerhalb des Nebels. Mit den Berechnungen des VertexFog, würde das gesamte Polygon vom Nebel beeinflusst, also auch der Teil, der eigentlich nicht im Nebel liegen soll. 29.3.1 Prüfung Eigentlich ist es nicht mehr notwendig zu prüfen, ob eine Grafikkarte VertexFog oder PixelFog unterstützt. Alle uns bekannten modernen Grafikkarten besitzen die Fähigkeit, beide Nebelmodelle zu handhaben. Falls Sie dennoch zweifeln, ob Ihre Grafikkarte das gewünschte Nebelmodell unterstützt, können Sie es wie folgt prüfen: Vertex-Fog: 1 2 3

4

Dim DeviceCaps As New Direct3D.Caps Dim D3DManager As Direct3D.Manager DeviceCaps = D3DManager.GetDeviceCaps(0, _ Direct3D.DeviceType.Hardware) If (DeviceCaps.RasterCaps.SupportsFogVertex) Then D3DDevice.RenderState.FogVertexMode = _ Direct3D.FogMode.Linear

306

Nebel

Pixel-Fog (Table-Fog): 1 2 3

4

Dim DeviceCaps As New Direct3D.Caps Dim D3DManager As Direct3D.Manager DeviceCaps = D3DManager.GetDeviceCaps(0, _ Direct3D.DeviceType.Hardware) If (DeviceCaps.RasterCaps.SupportsFogTable) Then D3DDevice.RenderState.FogTableMode = _ Direct3D.FogMode.Linear

29.4 Die wahre Tiefe DirectX ist eine High-Performance-Schnittstelle. Kontinuierlich verwendet DirectX vereinfachte Simulationsmodelle. Um die Nebelwerte zu berechnen, wird in erster Linie die Z-Koordinate verwendet. Diese Koordinate bestimmt die Tiefe im Raum. Somit erhalten alle Objekte, welche die gleiche Z-Koordinate haben den gleichen Nebelwert. Das scheint auf den ersten Blick richtig zu sein. Dennoch sollten wir uns mit dem Thema etwas genauer beschäftigen. Stellen Sie sich ein Objekt mit einem Z-Wert von 100 direkt vor der Kamera vor. Ein weiteres Objekt befindet sich mit einem Z-Wert von 100 seitlich versetzt von der Kamera. Das seitlich versetzte Objekt hat eine größere Distanz zur Kamera als das erste Objekt, direkt (senkrecht) vor der Kamera. Das würde aber auch bedeuten, dass das zweite Objekt stärker vom Nebel verhüllt sein müsste. Ist es aber nicht. DirectX weist allen Objekten mit der gleichen Z-Koordinate den gleichen Nebelwert zu. Dieses Problem wurde erkannt und es gibt auch eine Lösung dazu. D3DDevice.RenderState.RangeFogEnable = True

RangeFogEnable veranlasst DirectX die echten Distanzwerte zur Berechnung zu verwenden. Dieser RenderState ist nur für den VertexFog zugelassen. Es ist fast unnötig, zu erwähnen, dass dies natürlich zu Lasten der Performance geht. Schließlich muss für jedes Vertex die tatsächliche Entfernung ermittelt werden. Ob sich diese Berechnungen wirklich lohnen, müssen Sie für sich bzw. für Ihr Projekt selber entscheiden. Wir haben die Erfahrung gemacht, dass kaum eine Veränderung sichtbar ist. Dies ist aber auch von der Größe der verwendeten Polygone abhängig. Bei großen Polygonen wird eine Verbesserung am deutlichsten. Das soll aber nicht heißen, dass Sie nur mit großen Polygonen arbeiten sollen. Sollte es die Performance zulassen, setzen Sie möglichst kleine Polygone ein.

Renderstates

307

29.5 Renderstates Tabelle 12. Verfügbare Renderstates zur Nebelkonfiguration RenderState FogEnable As Boolean

Beschreibung

Mit True aktivieren Sie den Nebel. Mit False wird der Nebel deaktiviert. Default: False FogColor As Color Hier wird die Nebelfarbe definiert. Sie müssen nicht immer einen weißen Nebel erzeugen. Sie können mit farbigen Nebeln spezielle Stimmungen erzeugen. Oder Sie füllen einen Raum mit Nebel, um z.B. Gas zu simulieren. FogTableMode As FogMode Zur Auswahl stehen die Elemente aus der FogMode Enumeration. • None • Linear • Exp • Exp2 Default: FogMode.None FogVertexMode As FogMode Zur Auswahl stehen die Elemente aus der FogMode Enumeration. • None • Linear • Exp • Exp2 Default: FogMode.None FogStart As Single Sie können den Nebel direkt beim Betrachter beginnen lassen. Wollen Sie einen Tiefennebel zum Begrenzen Ihrer Welt verwenden, dann lassen Sie den Nebel in weiter Ferne beginnen. Dieser Parameter wird nur bei einer linearen Berechnung berücksichtigt. Default: 0.0f FogEnd As Single Hiermit wird der Nebel bei einer linearen Berechnung begrenzt. Die lineare Verteilung ergibt sich aus der Distanz zwischen Endwert – Startwert. Default: 1.0f FogDensity As Single Dies ist die Dichte, welche zur Berechnung der exponentiellen und quadratisch exponentiellen Berechnung benötigt wird. Default: 1.0 Wertebereich: 0.0 – 1.0

308

Nebel

RangeFogEnable As Boolean

Hiermit legen Sie fest, ob Sie für den VertexFog die echten Entfernungen verwenden wollen. Bei False werden die Z-Koordinaten verwendet. Default: False

29.6 Beispielprogramm für Nebel Das Beispielprogramm soll die unterschiedlichen Nebelmodelle in der Praxis demonstrieren. Hierbei legen wir besonderen Wert auf bewegte Bilder. Nur in der Bewegung können wir die Fähigkeiten und Eigenheiten der Nebelmodelle erkennen. Das Programm lässt es zu, dass Sie die unterschiedlichen FogModeEinstellungen anwählen. Sie können auch zwischen Vertex-Fog und TableFog umschalten. Beim Vertex-Fog können Sie die RangeFog-Berechnung (wahre Tiefe) aktivieren. Parameter wie Dichte, Beginn des Nebels und Ende des Nebels haben wir fest voreingestellt. Diese können Sie leicht im Sourcecode ändern. Während unseres Qualitätsmanagements haben wir ein merkwürdiges Verhalten festgestellt. Bei einigen Grafikkarten funktionierte der TableFog (Pixel-Fog) nicht. Diese ist um so seltsamer, da es sich um eine relativ einfache Programmierung handelt. Wir konnten den Fehler mit der Darstellung des Textes in Verbindung bringen. Wenn wir den Text nicht darstellen lassen, dann funktioniert der Tabel-Fog einwandfrei. Sollten Sie Probleme beim Table-Fog haben, dann deaktivieren Sie die Textdarstellung mit der Taste „T“. Kommen wir nun zu der eigentlichen Programmierung des Beispielprogramms. Wir wollen eine Straße mit einem stehenden Auto erstellen. Die Straße wird von Bäumen begrenzt. Wir werden mit der Kamera über die Straße fliegen und den Blick auf das Auto richten. In dieser Dynamik können wir gut beobachten, wie das Auto aus dem Nebel erscheint und anschließend wieder verschwindet. Durch den Flug über die Straße können wir aber auch das Verhalten von großen oder in unserem Fall von langen Objekten beobachten. Die Straße ist 1000 Einheiten lang und wurde aus relativ wenig Polygonen erstellt. Bei solchen Objekten wird die Schwäche des Vertex-Fogs deutlich.

Beispielprogramm für Nebel

309

Abb. 82. Beispielprogramm für Nebel

To-do-Liste zur Erstellung des Programm: • Erzeugen des D3DDevices • Das D3DDevice wird mit der bekannten DXSettings-Klasse erzeugt und wird somit nicht weiter erläutert. Weitere Informationen finden Sie in Kapitel 19. • Erstellen der Straße • Einbinden der Meshes (Bäume und Auto) • Initialisierung des Nebels • Rendern

29.6.1 Erstellen der Straße Das Erstellen der Straße wird von der Geometry-Klasse übernommen. Diese kennen wir bereits aus anderen Projekten. Der eigentliche Aufruf, um den notwendigen Vertexbuffer zu erstellen, erfolgt aus der frm_Start-Klasse heraus. Zuvor übergeben wir aber der GeometryKlasse einige Basisparameter. Vor allem gehört hierzu ein Verweis auf ein

310

Nebel

gültiges Direct3D-Device. Wir beginnen mit dem Load-Ereignis der frm_Start-Klasse. 1 2 3 4 5

6 7

'Geometry-Klasse Basis-Settings 'D3DDevice an die Klassen geben Geo1.SetD3DDevice = D3DDevice ' Material msg = Geo1.SetMaterial(System.Drawing.Color.White, _ System.Drawing.Color.White, _ System.Drawing.Color.FromArgb_ (255, 255, 255, 255)) 'Texturen laden msg = Geo1.CreateTextureSurface(D3DDevice, _ DXUtility.FindMediaFile_ ("Texturen\Metal_GalvanizedS.jpg"))

In Zeile 3 übergeben wir der Geometry-Klasse das Direct3D-Device. Mit der Zeile 5 sorgen wir für das richtige Material. Indem wir „Weiß“ als Materialfarbe zuweisen, tragen wir Sorge, dass die Straße gut sichtbar ist. Die Zuweisung der passenden Textur wird in Zeile 7 vorgenommen. Bitte beachten Sie, dass wir unsere Helferfunktion FindMediaFile() verwenden. Diese Funktion finden Sie in der DXUtility-Klasse. 1 2 3

4

Private Sub CreateVertexBuffer() Dim msg As Boolean msg = Geo1.CreateVertexBuffer(D3DDevice,_ 1, 10, 0, 0, 0, 30, 1000, 4, 20, _ Geometry.WallType.Bottom_Top) End Sub

Die Subroutine CreateVertexBuffer() ruft die Funktion CreateVertexBuffer der Geometry-Klasse auf. CreateVertexBuffer erstellt den eigentlichen Vertexbuffer der Straße. Dabei erfahren wir, dass die gesamte Straße (immerhin eine Länge von 1000 Einheiten) aus lediglich 20 Dreiecken erstellt wird. Diese grobe Rasterung wählen wir hauptsächlich aus dem Grund, damit wir die Nachteile des Vertex-Fogs demonstrieren können. Unter normalen Umständen ist kaum ein Unterschied zwischen Pixel-Fog und Vertex-Fog zu erkennen. 29.6.2 Einbinden der Meshes (Bäume und Auto) Zur Integration der Bäume und des Autos verwenden wir Meshes. Dies ist auch notwendig, da die komplexen Strukturen nur mit einem Editor erstellt werden können. Wir verwenden eine Meshes-Klasse. Mittels dieser Klasse können wir die Meshes (Objekte) komfortabel positionieren und

Beispielprogramm für Nebel

311

skalieren. Außerdem können wir das Mesh rotieren. Im Fall der Bäume ist dies auch notwendig. Bevor wir die Meshes rendern dürfen, müssen wir diese erstellen. Die Initialisierung haben wir in der frm_Start-Klasse (Load-Ereignis) untergebracht. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

'Meshes 'Car Car1.SetD3DDevice = D3DDevice Car1.Scale(1, 1, 1) Car1.UseExterneWorldMatrix = False Car1.SetPosition = New DirectX.Vector3(10, 2.5, 500) Car1.LoadMesh(DXUtility.FindMediaFile("Meshes\car.x")) '*** Tree Tree1.SetD3DDevice = D3DDevice Tree1.Scale(2.5, 2.5, 2.5) Tree1.UseExterneWorldMatrix = False Tree1.SetPosition = New DirectX.Vector3(2, 10, 500) Tree1.LoadMesh(DXUtility.FindMediaFile("Meshes\tree2.x")) Tree1.AngleX = 90 Tree1.AngleY = 0 Tree1.AngleZ = 0

Car1 und Tree1 sind jeweils eigene Instanzen der Meshes-Klasse. Diese wurden in dem Modul GlobaleVariablen deklariert. In Zeile 3 - 7 wird das benötigte Auto erzeugt. Der Bereich Zeile 9 - 16 ist für einen einzelnen Baum reserviert. Diesen Baum können wir beim Rendern beliebig oft duplizieren. Den Baum müssen wir um die X-Achse um 90° drehen. Ansonsten würde er nicht senkrecht stehen, sondern auf der Straße liegen. 29.6.3 Initialisierung des Nebels Die Initialisierung des Nebels wird in zwei Stufen vorgenommen. Im Load-Ereignis der frm_Start-Klasse deklarieren wir zunächst einige Grundwerte. 1 2 3 4 5 6 7

'*** Fog Default FogTyp = Direct3D.FogMode.Exp PixelFogEnable = False FogStart = 0 FogEnd = 200 FogDensity = 0.025 RangeFogEnable = False

312

Nebel

Wir wollen Vertex-Fog (PixelFogEnable = False) einsetzen und dieser soll exponentiell (FogTyp = Direct3D.FogMode.Exp) berechnet werden. Die Nebeldichte soll 0.025 (FogDensity = 0.025) betragen. Das sind die Grundeinstellungen, mit denen wir den Nebel starten wollen. Nunmehr müssen wir diese Grundeinstellungen an Direct3D weiterleiten. Dies erledigen wir mit Hilfe der Subroutine iniFog(). 1 2 3 4 5

6 7 8 9

10 11 12 13 14 15

16 17

Private Sub iniFog() Select Case PixelFogEnable Case True D3DDevice.RenderState.FogTableMode = FogTyp D3DDevice.RenderState.FogVertexMode = _ Direct3D.FogMode.None RangeFogEnable = False Case False D3DDevice.RenderState.FogVertexMode = FogTyp D3DDevice.RenderState.FogTableMode = _ Direct3D.FogMode.None End Select D3DDevice.RenderState.FogDensity = FogDensity D3DDevice.RenderState.FogStart = FogStart D3DDevice.RenderState.FogEnd = FogEnd D3DDevice.RenderState.RangeFogEnable = RangeFogEnable D3DDevice.RenderState.FogColor = _ System.Drawing.Color.FromArgb_ (255, 220, 220, 220) D3DDevice.RenderState.FogEnable = True End Sub

Hier weisen wir die zuvor festgelegten Grundwerte den Nebel-RenderStates zu. Dies bedarf keiner weiteren Erläuterung. Falls Sie sich fragen, warum wir die Werte nicht sofort zugewiesen haben, dann sollten Sie bedenken, dass wir die RenderStates per Tastatureingabe verändern können. Die iniFog()-Subroutine ist so universeller einsetzbar. 29.6.4 Rendern Bei den Erläuterungen zur Render()-Subroutine möchten wir uns auf das Rendern der Straße, der Bäume und des Autos beschränken. 1 2

'Objekte rendern Geo1.Render()

3 4 5 6

' Meshes Car1.Render()

Beispielprogramm für Nebel 7 8 9 10 11 12 13

313

Dim i For i = 0 To 1000 Step 100 Tree1.SetPosition = New DirectX.Vector3(2, 12, i) Tree1.Render() Tree1.SetPosition = New DirectX.Vector3(30, 12, i) Tree1.Render() Next i

In Zeile 2 wird die Straße gerendert, in Zeile 5 das Auto. Wir wollen einen Blick auf die Zeilen 7 - 13 werfen. Hier werden die Bäume gerendert. Sie erinnern sich, wir haben lediglich einen einzigen Baum deklariert. Diesen können wir nun diverse Male duplizieren. Es ist ebenfalls erlaubt, Position, Skalierung, Farbe oder Drehung zu verändern. Wir wollen aber nur die Position neu festlegen. Dies geschieht in Zeile 9 sowie 11. In der kleinen For-Next-Schleife rendern wir jeweils einen Baum auf der linken Straßenseite und einen Baum auf der rechten Straßenseite.

30 Partikeleffekte

Um ein Spiel richtig aufzupeppen, sind Partikeleffekte genau richtig. Damit katapultieren Sie Ihr Spiel in die Spieleoberliga. Nichts macht eine Szene realistischer als scheinbar unkontrollierte Kleinstteile. Mit der richtigen Technik wird Ihr Spiel sofort um mehrere Stufen realistischer. Was wäre ein mit Vollgas startender Wagen ohne qualmende Reifen oder wenigstens ein paar kleine Steinchen, die nach hinten geschleudert werden. Wäre es nicht phantastisch, wenn beim Laufen durch eine staubige Gegend auch ein wenig Staub aufgewirbelt würde. Schnee und Regen sind weitere Beispiele für Partikeleffekte. Natürlich dürfen Sie Partikeleffekte auch einsetzen, weil sie einfach nur toll aussehen. Denken Sie z.B. an eine Lichtsäule, an der sich eine Staubspirale emporschraubt. Das ist zwar nicht realistisch, aber dafür wunderbar anzusehen. Kehren wir aus dem „Reich der Phantasie“ zurück an unsere Tastatur und schauen uns die nüchterne technische Seite an. Wie wir bereits festgestellt haben, werden Partikeleffekte für Flammen, Rauch, Explosionen, Regen, Schnee usw. verwendet. Um all diese Facetten darzustellen, benötigen wir Partikelsysteme. Die Betonung liegt auf Systeme, denn das, was sie darstellen, wird ganz wesentlich von den Partikeleigenschaften geprägt. Derart abweichende Verhaltensmuster können nur mit unterschiedlichen Systemen simuliert werden. Wir werden eine Lösung anbieten, welche eine Reihe von Einsatzgebieten abdeckt. Außerdem kann unsere Lösung als Ausgangsbasis für neue Ansätze genutzt werden.

316

Partikeleffekte

Abb. 83. Beispielprogramm für Partikeleffekte

Eine Partikel-Engine soll einen echten Mehrwert für ein Programm darstellen. Deshalb ist es von hoher Bedeutung, dass die Engine unseren Erwartungen entspricht. Sicherlich hat jeder Programmierer seine eigenen Vorstellungen von einer perfekten Engine. Die eigenen Vorstellungen werden durch den Verwendungszweck beeinflusst und Verwendungsmöglichkeiten für Partikeleffkte gibt es reichlich. Wir benötigen also die eierlegende Wollmilchsau. Das sind die Eigenschaften, die wir von einer Partikel-Engine erwarten: • • • •

Hohe Performance Flexibilität Einfache Systemintegration Ausbaufähig

Betrachten wir zunächst die To-do-Liste für die Erstellung unserer Engine: • Anlegen einer Partikelstruktur • Erstellen einer Partikelklasse

Partikelstruktur

317

• CreateTexture() (Laden einer Textur mit transparentem Hintergrund) • Partikel rendern (RenderStates)

30.1 Partikelstruktur Wenn wir von Partikeln sprechen, sind das auch Kleinstteile wie Staubkörner, Wassertropfen, Qualm usw. Unglücklicherweise (für den Programmierer) treten diese Kleinstteile vornehmlich in riesigen Scharen auf. Überlegen Sie sich bitte, wie viel Partikel man für einen richtigen Regenschauer benötigt. Um diese Partikelhorden im Griff zu haben, brauchen wir eine alltagstaugliche Partikelstruktur. Diese sollte so schlank wie möglich sein. Würden wir eine aufgeblähte, fette Struktur wählen, dann würden wir mit Sicherheit die notwendige Performance nicht erreichen. Hier ist unser Vorschlag für eine Partikelstruktur. 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Public Type Particle PosX As Single PosY As Single PosZ As Single SpeedX As Single SpeedY As Single SpeedZ As Single StartColor As D3DCOLORVALUE EndColor As D3DCOLORVALUE CurrentColor As D3DCOLORVALUE LifeTime As Long Created As Long Status As Particle_Status End Type

PosX, PosY und PosZ geben natürlich die Position des Partikels im Raum an. SpeedX, SpeedY und SpeedZ definieren Geschwindigkeit und Bewegungsrichtung des Partikels, z.B. SpeedX = 1, SpeedY = 0 und SpeedZ = 0 würde eine Bewegung in östliche Richtung festlegen. Entsprechend würde SpeedX = 1, SpeedY = 1 und SpeedZ = 0 eine Bewegung nach Nordosten definieren.

Viele Partikeleffekte verwenden Partikel mit einer gewissen Lebenszeit. Oftmals werden solche Partikel mit zunehmender Lebenszeit stetig transparenter. Das beste Beispiel ist ein Silvesterfeuerwerk. Die einzelnen Partikel verlieren zunehmend an Leuchtkraft, bis sie gänzlich verblassen. Solche Effekte werden mit Hilfe der Parameter StartColor, EndColor, CurrentColor, LifeTime und Created umgesetzt. Eigentlich sind

318

Partikeleffekte

diese Parameter bei Effekten ohne Ausblendeffekt oft überflüssig, dennoch schaden sie in Hinblick auf die Flexibilität nicht. Soll der Partikel die Farbe nicht ändern, so können Sie mit StartColor und EndColor die gleiche Farbe festlegen. Soll der Partikel unbegrenzt erhalten bleiben, so definieren Sie für die LifeTime einen extrem hohen Wert, ansonsten wird der Partikel nach und nach ausgeblendet. Create ist ein Parameter, der nur für interne Berechnungen eingesetzt wird. Der letzte Parameter ist Status. Status kann in vielfältiger Art und Weise verwendet werden. Eine der einfachsten Möglichkeiten ist die Verwendung als Existenzindex. 1 2 3 4

Public Enum Particle_Status Alive = 0 Dead = 1 End Enum

30.2 Zweidimensional vs. dreidimensional Nachdem wir uns Gedanken über den Aufbau eines einzelnen Partikels gemacht haben, denken wir darüber nach, wie wir die Partikel auf dem Monitor darstellen. Wir könnten ein dreidimensionales Objekt erzeugen. Für Schnee wählen wir eine Kugel, für Regen eine zylindrische Form. Diese Objekte würden sich hervorragend in einem 3D-Raum integrieren. Alternativ zu einem echten dreidimensionalen Objekt können wir mit einer Täuschung arbeiten. Wir verwenden einfach ein 2D-Bild. Dieses Bild können wir nach guter alter Sprites-Technik mit einer transparenten Hintergrundfarbe und Alpha-Blending-Effekten in die Szene zeichnen. Bevor wir uns entscheiden, sollten wir uns die „Pros“ und „Contras“ der beiden Techniken anschauen. Pro 3D-Partikel • Sehr realistisch • Gute Systemintegration Contra 3D-Partikel • Hoher Performance-Anspruch • Geeignete Formen sind schlecht konstruierbar. • Blending-Effekte sind schlecht anwendbar. (Der Blending-Effekt muss für die Vorder- und Rückseite des Objekts berechnet werden.) • Texturen müssen umständlich berechnet werden. • Die meisten Partikeleffekte verwenden derart kleine Partikel, so dass die eigentliche Objektform vernachlässigt werden kann.

Zweidimensional vs. dreidimensional

319

Ein Staubkorn unter einem Mikroskop besitzt sicherlich eine dreidimensionale Form. Wenn wir den Staub im Sonnenlicht betrachten, können wir von der ursprünglichen Dreidimensionalität nichts mehr wahrnehmen. Der Einsatz von echten 3D-Partikeln wäre somit eine Vergeudung von wertvollen Ressourcen. Wir wollen nicht verheimlichen, dass es durchaus Szenarien gibt, die nach echten 3D-Partikeln verlangen. Die meisten Effekte können jedoch mit 2D-Objekten simuliert werden. DirectX bietet auch eine geeignete Lösungstechnik an. Das Zauberwort in diesem Fall heißt Point-Sprite. Diese 2D-Objekte sind zur Simulation von Partikeln bestens geeignet. Schauen wir uns die Pro und Contras an. Pro Point-Sprites • Geringer Performance-Anspruch • Gute Systemintegration • Hohe Flexibilität • Für die meisten Effekte sehr realistisch. • Texturen werden leicht berechnet. • Gute Blending-Effekte (Alpha-Blending) • Transparenter Hintergrund Contra Point-Sprites • Nicht für alle Effekte geeignet • Keine echte 3D-Struktur (können oftmals als Täuschung identifiziert werden) Die Macher von DirectX haben sich schon längst entschieden. Ab DirectX 8 stehen dem Softwareentwickler Point-Sprites zur Verfügung. Diese sind laut „Microsoft DirectX-SDK“ für Partikelsysteme geeignet. Um Partikeleffekte einsetzen zu können, ist die verfügbare Performance ein entscheidender Faktor. Je weniger Parameter Sie einsetzen desto höher ist die zu erwartende Performance. Abbildung 85 zeigt den Aufbau eines Point-Sprites.

320

Partikeleffekte

Abb. 84. Texturkoordinaten eines Point-Sprites

Eigentlich benötigen wir für einen Point-Sprite lediglich die Koordinaten. Diese können wir durch einen Direct3D-Vektor übergeben. Da wir für die meisten Partikeleffekte einen Ausblendeffekt benötigen, brauchen wir noch einen Farbparameter und eine Konstante, welche das entsprechende DirectX.VertexFormat aufnimmt. Wir erstellen folgende Point SpriteStruktur (PartikelVertex): 1 2 3 4

5

Private Structure PartikelVertex Dim V As DirectX.Vector3 Dim Color As Integer Public Const Format As DirectX.Direct3D.VertexFormats =_ DirectX.Direct3D.VertexFormats.Position Or _ DirectX.Direct3D.VertexFormats.Diffuse 05End Structure

V als Direct3D-Vektor beschreibt mit den Koordinaten die Position im Raum. Da wir auf die Farbe der Partikel Einfluss nehmen möchten, gibt es noch den Parameter Color. Abschließend haben wir noch die Konstante Format. Diese Konstante ist insoweit wichtig, als sie der Render-Engine von DirectX die notwendigen Format Parameter mitteilt. In unserem Beispiel werden die beiden Formate Position (V As DirectX.Vector3) und Diffuse (Color As Integer) verknüpft.

30.3 Partikelklasse Mit Hilfe einer Partikelklasse werden wir eine einfache Partikel-Engine entwickeln. Diese soll möglichst autonom agieren, so dass sie in andere Projekte integrierbar ist. Um ein Partikel zu berechnen, haben wir die Partikelstruktur definiert. Diese muss nun mit Daten gefüllt werden. Indem wir spezifische Partikel-Klasseneigenschaften definieren, haben wir eine

Partikelklasse

321

ideale Schnittstelle zum Füllen der Partikelstruktur gebildet. Wir definieren folgende Klasseneigenschaften: NumPartikel As Integer

Hiermit wird die Anzahl der Partikel festgelegt. Der Wertebereich liegt zwischen 1 und unendlich. (Die Anzahl ist lediglich durch die Leistungsfähigkeit des Computersystems begrenzt.) Size As Single

Dieser Parameter bestimmt die Größe der Partikel. Der Wertebereich liegt zwischen 0 und 1. Natürlich ist ein Größe von 0 absolut sinnlos. MinLifeTime As Long MaxLifeTime As Long

Diese beiden Parameter beschreiben die Lebensdauer der Partikel. Für jeden einzelnen Partikel wird eine zufällige Lebensdauer ermittelt. Die Untergrenze für die Zufallszahl wird durch den Parameter MinLifeTime und die Obergrenze durch MaxLifeTime beschrieben. StartColor As D3DCOLORVALUE EndColor As D3DCOLORVALUE

Währen der Lebensdauer des Partikels soll sich die Partikelfarbe verändern. Diese beginnt mit StartColor und endet bei EndColor. Texture As String

Natürlich muss unser Partikel auch eine Texture erhalten. Neben diesen Eigenschaften benötigen wir auch ein paar Funktionen. Um die Bedienung und Integration in weitere Projekte möglichts einfach zu gestalten, gibt es nur zwei öffentliche Funktionen. CreateTexture() ist die erste öffentliche Funktion und eine davon weist eine Besonderheit auf. 1

2

Public Function CreateTexture( _ ByVal device As Direct3D.Device, _ ByVal sTexture As String, _ ByVal d3dFormat As Direct3D.Format) _ As Direct3D.Texture Return Direct3D.TextureLoader.FromFile(device,_ sTexture, 0,0,Direct3D.D3DX.Default,0, _ d3dFormat, _ Direct3D.Pool.Default, _

322

3

Partikeleffekte

Direct3D.Filter.Linear, _ Direct3D.Filter.Linear, _ System.Drawing.Color.Black.ToArgb) End Function

Eigentlich ist uns die Methode Direct3D.TextureLoader.FromFile bestens bekannt, dennoch haben wir hier eine Neuerung zu verzeichnen. Unser Ziel ist es eine Textur mit transparentem Hintergrund zu erzeugen. Unter DirectX 8 gab es hierfür die Methode Texture.LoadFromFileEX(). Diese ist unter Managed DirectX 9 nicht mehr vorhanden. Das wir dennoch in den Genuss transparenter Hintergrundfarben kommen, haben wir der Overload-Funktion Direct3D.TextureLoader.FromFile() zu verdanken. Als letzter Parameter wird die Farbe des Hintergrundes oder die Farbe, die transparent dargestellt werden soll, angegeben. Bitte beachten Sie, dass der transparente Hintergrund nur dann funktioniert, wenn Sie eine geeignete Bitmap verwenden. Hier werden eine Reihe von Formaten unterstützt. Wir haben meistens BMP- oder TIF-Files verwendet. Bei Point-Sprites müssen Sie zusätzlich Direct3D.RenderState.ZBufferWriteEnable = False setzen. Beim Aufruf der Funktion Render() übergeben wir lediglich das gültige Direct3D-Device. Ansonsten arbeitet die Routine völlig autonom und erledigt alle notwendigen Aufgaben. Bevor wir diese Funktion aufrufen, füllen wir die Eigenschaften der Partikelklasse mit den notwendigen Daten. In unserem Beispielprojekt haben wir diese Zuweisungen in die Subroutine init() von Form frmStart.vb untergebracht. 1 2 3 4 5 6 7 8

9

10

Public Shared Sub init() Dim tmpFarbe1 As System.Drawing.Color Dim tmpFarbe2 As System.Drawing.Color Partikel.MaxLifeTime = 20000 Partikel.MinLifeTime = 5000 Partikel.NumPartikel = PCount Partikel.Size = PSize Partikel.StartColor = tmpFarbe1.FromArgb_ (255, PFarbe1.R, PFarbe1.G, PFarbe1.B) Partikel.EndColor = tmpFarbe2.FromArgb_ (PAlphaFarbe2, PFarbe2.R, PFarbe2.G, PFarbe2.B) End Sub

In Zeile 8 und 9 weisen wir der Partikelklasse die Startfarbe sowie die Endfarbe zu. Dies tun wir nicht auf direktem Weg, sondern wir verwenden die temporären Variablen tmpFarbe1 und tmpFarbe2. Das erscheint auf den ersten Blick etwas umständlich, da wir ja zwei gültige globale Variablen (PFarbe1 und PFarbe2) haben. Diese globalen Variablen könnten wir

Rendern

323

der Partikelklasse doch direkt zuweisen? Leider haben beide Variablen nicht den passenden Alphawert. Die Alphawerte stehen auf 255 und wir benötigen bei der Endfarbe zumindest einen Alphawert von 0, um einen Ausblendeffekt zu erreichen.

30.4 Rendern Nun sollten wir uns aber die Funktion Render() von unserer Partikelklasse anschauen. 1

2 3 4 5 6 7 8

9 10 11 12 13

Public Function Render(ByVal device As Direct3D.Device)_ As Boolean Try device.RenderState.AlphaBlendEnable = True device.RenderState.ZBufferWriteEnable = False device.SetTexture(0, Texture_Partikel) device.SetStreamSource(0, VertexBuffer_Partikel, 0) device.VertexFormat = PartikelVertex.Format device.DrawPrimitives(Direct3D.PrimitiveType.PointList, 0, mvarNumPartikel) device.RenderState.ZBufferWriteEnable = True Catch MessageBox.Show("Fehler in Sub: Render in PartikelClass") End Try End Function

Das sieht nicht besonders aufregend aus. Zu beachten ist lediglich, dass unbedingt device.RenderState.AlphaBlendEnable = True und device.RenderState.ZBufferWriteEnable = False gesetzt wird. Ohne Alpha-Blending haben wir keine Transparenz, und wenn wir ZbufferWriteEnable auf True belassen, kommt es zu Fehlern beim Erstellen des transparenten Hintergrundes der Point-Sprites. An der Render-Routine ist aber noch etwas auffällig. Den Render-Beginn und das Render-Ende wird nicht mit der Methode BeginScene() eingeleitet und mit der Methode EndScene() abgeschlossen. 1 2 3 4

D3DDevice.BeginScene … … D3DDevice.EndScene

Normalerweise werden die aufgeführten Methoden der Partikel.Render()-Funktion durch die BeginScene- und EndSceneAnweisungen begrenzt. Diese Begrenzung ist zum Rendern auch zwingend

324

Partikeleffekte

notwendig. Wie sich das in unserem Beispiel verhält, können Sie an der folgenden Grafik erkennen.

Abb. 85. Integration der Partikel.Render()-Funktion

Sie erkennen, dass die Partikel.Render()-Funktion innerhalb der Render()-Subroutine des Hauptprojekts aufgerufen wird. In diesem Fall arbeiten wir mit drei Klassen und einer Form, abgesehen von der OptionsForm. • Klasse 1: DirectXClass.vb • Klasse 2: Geometry.vb • Klasse 3: PartikelClass.vb Die beiden Klassen Geometry.vb und PartikelClass.vb besitzen autonome Renderroutinen. Die DirectXClass.vb enthält die Methoden BeginScene() und EndScene(). Durch diesen Aufbau sind wir in der Lage, dynamisch Objekte zum Rendern zu integrieren oder zu entfernen. Hier die Hauptschleife des Projektes aus Form frmStart.vb.

Rendern 1 2 3 17

325

While bolRunning = True … … SetupMatrices()

18 19

DXClass.FrameRendernStart()

20 21 22 23 24 25 26

27

Try GeometryKiste(0).Dispose() Catch End Try GeometryKiste(0) = Nothing GeometryKiste(0) = Geometry.CreateKiste_ (DXClass.Direct3DDevice, 1, 0, 0, 0, DFC) Geo.Render_Kiste(0)

28 29 30 31 32 33 34

35

Try VertexBuffer_Partikel.Dispose() Catch End Try VertexBuffer_Partikel = Nothing VertexBuffer_Partikel = Partikel.CreatePartikel_ (DXClass.Direct3DDevice) Partikel.Render(DXClass.Direct3DDevice)

36 37 38

DXClass.FrameRendernEnd() End While

In Zeile 19 wird über die DirectXClass-Klasse der Renderprozess gestartet. In Zeile 21 bis 27 wird der Würfel über die Geometry-Klasse und in Zeile 29 bis 35 werden die Partikel über die PartikelKlass-Klasse gerendert. In Zeile 37 wird der Renderprozess wieder über die Klasse DirectXKlass beendet. Nachdem der Renderprozess durchleuchtet wurde, kümmern wir uns um die Updateberechnungen der Partikel. Diese sollen schließlich wild durch die Luft schwirren und zusätzlich noch Farbe und Transparenz ändern. Diese einigermaßen komplexen Berechnungen werden von der Subroutine Update_Partikel() übernommen. Diese Subroutine ist eine private Subroutine der PartikelClass-Klasse. 1 2 3 4 5

Private Function Update_Partikel() As Boolean On Error GoTo ERROR_Update_Partikel Dim I As Long Dim msg, Counter Dim dummy As Single

6 7

For I = 0 To mvarNumPartikel – 1

326 8

9

10

11

Partikeleffekte If PartikelData(I).Status = _ Particel_Status.Aktiv And InitPartikelComplete = _ True Then PartikelData(I).PosX = PartikelData(I).PosX + _ ((PartikelData(I).SpeedX / 300) * _ (Environment.TickCount - LastUpdatedParticles)) PartikelData(I).PosY = PartikelData(I).PosY +_ ((PartikelData(I).SpeedY / 300) * _ (Environment.TickCount - LastUpdatedParticles)) PartikelData(I).PosZ = PartikelData(I).PosZ + _ ((PartikelData(I).SpeedZ / 300) * _ (Environment.TickCount - LastUpdatedParticles))

In Zeile 8 bis 11 werden die neuen Koordinaten (X, Y und Z) der aktiven Partikel berechnet. Hierbei wird die verstrichene Zeit sowie die individuelle Geschwindigkeit berücksichtigt. 12 13

14 15

dummy = (Environment.TickCount - _ PartikelData(I).Created) / _ PartikelData(I).LifeTime If dummy > 1 Then dummy = 1 PartikelData(I).CurrentColor = _ Direct3D.ColorOperator.Lerp_ (PartikelData(I).StartColor, _ PartikelData(I).EndColor, dummy

Zeile 15 beinhaltet den interessantesten Teil der Subroutine. Hier wird die neue Farbe des Partikels berechnet. Hierzu werden die Startfarbe, die Endfarbe sowie ein Index der verstrichenen Zeit benötigt. Mittels der Direct3D.ColorOperator.Lerp()-Methode wird die neue Mischfarbe berechnet. 16 17

18 19 20

If Environment.TickCount - _ PartikelData(I).Created >= _ PartikelData(I).LifeTime Then_ PartikelData(I).Status = _ Particel_Status.Deaktiv Else PartikelData(I).Status = Particel_Status.Aktiv PartikelData(I).LifeTime = _ (mvarMaxLifeTime - mvarMinLifeTime + 1) * Rnd()_ + mvarMinLifeTime

21 22 23 24 25

PartikelData(I).Created = Environment.TickCount PartikelData(I).PosX = 0 PartikelData(I).PosY = 0 PartikelData(I).PosZ = 0

GUI 26

27

28

29 30 31

32 33

327

PartikelData(I).SpeedX = _ (Rnd() * XVariation) - (XVariation / 2) PartikelData(I).SpeedY = _ (Rnd() * YVariation) - (YVariation / 2) PartikelData(I).SpeedZ = _ (Rnd() * ZVariation) - (ZVariation / 2) PartikelData(I).StartColor = mvarStartColor PartikelData(I).EndColor = mvarEndColor PartikelData(I).CurrentColor = _ PartikelData(I).StartColor Counter += 1 End If

Die Zeilen 19 bis 32 beschäftigen sich mit dem Erstellen neuer Partikel. Hier werden lediglich Standardwerte zugewiesen. 34

Next I

35 36 37

LastUpdatedParticles = Environment.TickCount InitPartikelComplete = True

38 39 40

Update_Partikel = True Exit Function

41 42 43 44 45

ERROR_Update_Partikel: MsgBox(Err.Description) Update_Partikel = False End Function

30.5 GUI Dem Projekt haben wir noch eine grafische Bedienoberfläche hinzugefügt. Diese soll Sie animieren, die Einstellungen zu variieren und so das Verhalten der Point-Sprites besser studieren zu können.

328

Partikeleffekte

Abb. 86. GUI zum Einstellen der Partikelparameter

Dieses Interface ist nicht das, was man ein grafisches Meisterwerk nennen würde, aber immerhin ist es zweckmäßig. Die Partikelanzahl haben wir auf 50000 begrenzt. Dies ist nicht die Obergrenze, sondern soll das Ganze einfach im Rahmen halten. Natürlich steht es Ihnen frei, die Grenzen zu sprengen.

31 DirectSound: Modell

Nachdem wir jetzt im ersten Teil des Buches alle wichtigen Techniken des 2D- und 3D-Grafikbereiches kennen gelernt haben, kommen wir nun zu einem weiteren wichtigen Bestandteil des DirectX-Frameworks. Mit der DirectSound-Schnittstelle hat Microsoft auch in der aktuellen Version des Frameworks ein mächtiges, objektorientiertes Programmiermodell zur Verfügung gestellt. Mit Hilfe der Klassen und Objekte dieses Modells können auf einfache Weise 2D- und 3D-Soundwiedergaben realisiert werden. Dabei beschränkt sich die Wiedergabe der Sounddateien nicht nur auf den Bereich der Spieleprogrammierung, sondern durch die vergleichsweise einfache Handhabung der Objekte hält DirectSound auch Einzug in immer weiteren Applikationen. Das Haupteinsatzgebiet der Schnittstelle bleibt aber die Spieleprogrammierung. Hierzu werden vom DirectXSystem verschiedene Möglichkeiten zur Verfügung gestellt, mit den Sounddaten zu arbeiten. In diesem Kapitel werden wir hauptsächlich die Techniken kennen lernen, die wir für das Einfügen von Sound in unsere Grafikprojekte benötigen. Wie werden dafür nacheinander die wichtigsten Elemente der DirectSound-Schnittstelle kennen lernen und besprechen. Dabei beschreiben wir die generelle Erstellung des Sound-Devices unter Berücksichtigung der Systemvoraussetzungen, die Verwaltung der Sounddaten mit Hilfe der SoundBuffer-Objekten und zum Schluss die Möglichkeiten, die uns geboten werden, um diese Daten zu modifizieren und auszugeben. Das DirectSound-Modell stellt dabei dem Programmierer zusätzlich noch Funktionen zur Verfügung, verschiedene Sounddateien zu mischen mit Effekten zu versehen und punktgenau wiederzugeben. Weiterhin ist es möglich, alle diese Funktionen entweder mit der vorhandenen Hardware zu realisieren oder diese über Software zu simulieren. Zum Schluss bleibt dann nur noch die Möglichkeit der Soundaufnahme zu erwähnen, die ebenfalls im DirectSound-Framework verankert ist. Da diese bei der Nutzung des Frameworks für die Spieleprogrammierung aber selten verwandt wird, werden wir die Soundaufnahme nur theoretisch besprechen und nicht mit einem Beispiel demonstrieren.

330

DirectSound: Modell

Das DirectSound-Modell enthält alle Objekte, die wir benötigen, um mit Sounddateien in unseren Projekten zu arbeiten. Die wichtigsten Elemente sind dabei: • • • • • •

Microsoft.DirectX.DirectSound.DeviceInformation Microsoft.DirectX.DirectSound.Device Microsoft.DirectX.DirectSound.Buffer Microsoft.DirectX.DirectSound.3DBuffer Microsoft.DirectX.DirectSound.3DListner Microsoft.DirectX.DirectSound.CaptureBuffer

Das bevorzugte Datenformat der DirectSound-Klassen ist das WAVAudioformat. Dieses wird direkt von der Schnittstelle unterstützt und bedarf bis auf wenige Ausnahmen keiner Anpassung. Andere Datenformate müssen vor ihrer Verarbeitung erst in das benötigte Format konvertiert werden.

31.1 DirectSound-DeviceInformation Das erste Objekt, das wir uns näher ansehen wollen, ist das DeviceInformation-Objekt der DirectSound-Schnittstelle. Mit Hilfe dieses Objektes können wir Informationen über ein im System zur Verfügung stehendes Sound-Device erhalten. Diese Informationen bekommen wir, indem wir das Objekt DevicesCollection auswerten. Dieses Objekt fasst alle für das DirectSound-Modul verfügbaren Geräte zusammen. Dabei beinhaltet das DeviceInformation-Objekt unter anderem eine Beschreibung des Objektes und die Treiber-GUID des Devices. Mit den gewonnenen Daten kann man dann die Wiedergabe des Sounds dediziert über das gewählte Device realisieren.

31.2 DirectSound-Device Genau wie im Grafikbereich muss bei Nutzung der DirectSound Schnittstelle ein Device erstellt werden, mit dem wir die gesamten Soundmöglichkeiten des Frameworks nutzen können und auf dem alle weiteren Aktionen aufbauen. Es wird dabei benötigt um die benötigten Objekte zur Soundwiedergabe zu erstellen und zu verwalten. Außerdem legen wir mit dem Device die Soundparameter für unsere Soundumgebung fest.

DirectSound-Buffer

331

31.3 DirectSound-Buffer Die wohl wichtigsten Elemente in der DirectSound-Schnittstelle sind die so genannten DirectSound-Buffer. Diese Buffer verwalten die gesamten Daten zur Wiedergabe der Sounddateien. Sie speichern die Daten und geben diese zur Wiedergabe an die Soundkarte weiter. Es gibt verschiedene Arten von Sound-Buffern. Wir wollen uns dieseim Folgengen nacheinander ansehen. SecondaryBuffer (static/streaming). Das erste Element der BufferFamilie ist der SecondaryBuffer. Mit diesem können wir Speicherplatz reservieren, in dem wir die Daten ablegen, die später wiedergegeben werden sollen. Dabei gibt es zwei Arten des SecondaryBuffers, die sich darin unterscheiden, wie der Buffer die Daten für die Wiedergabe im Speicher ablegt. Der Static SecondaryBuffer legt die Sounddaten komplett im Speicher ab und verteilt die Daten von dort weiter. Beim Streaming SecondaryBuffer werden dagegen immer nur die Daten in den Speicher des Systems geladen, die wiedergegeben werden sollen. Es entsteht ein Datenstrom (Stream), der dem Buffer seinen Namen gibt. Welche Art des SecondaryBuffers benutzt wird, hängt von dem Anwender ab, er entscheidet, wie er die Buffer einsetzen will. Generell sollten die statischen Buffer aber nur für kurze Soundeffekte genutzt werden, da ansonsten der Arbeitsspeicher sehr schnell knapp wird. Die Art des SecondaryBuffer wird dabei mit Hilfe der BufferDescription-Klasse festgelegt. BufferDescription. Mit der BufferDescription-Klasse können wir unserem Sound-Buffern also mit auf den Weg geben, wie er die gespeicherten Daten behandeln sollen. Dabei können wir mit der Description-Klasse grundlegende Dinge wie Lautstärke (Volume), Panorama (Pan) und Samplefrequenz (Frequency) festlegen. Aber auch spezielle Dinge, wie die verschiedenen Effekte, mit denen der SoundBuffer die originalen Sounddaten modifizieren kann. Dabei ist aber zu sagen, dass mit der BufferDescription diese Modifikationen nicht gemacht werden, sondern dem Soundbuffer nur mitgeteilt wird, welche Modifikationen mit seinen Daten möglich sind. Die BufferDescription werden bei der Erstellung des Soundbuffers benötigt und diesem in seiner New-Überladung mitgegeben. EffectDescription. Das zweite Description-Objekt ist die Struktur EffectDescription. Diese Struktur dient dazu, Effekte an den

332

DirectSound: Modell

Soundbuffer zu übergeben, die dieser dann auf seine Sounddaten anwendet. Dabei besitzt jeder weitere Effekt noch weitere Eigenschaften, die manuell eingestellt werden können. Um die Standardeffekte des Soundbuffers nutzen zu können, müssen wir das ControlEffects-Flag in der BufferDescription setzen. Mit einer Instanz des EffectDescription-Objektes können wir nun die einzelnen Effekte freischalten. Mit Hilfe der DSoundHelper-Klasse können wir dabei die Effektbeschreibungen der einzelnen Effekte ermitteln, anschließend müssen werden die Effekte an den gewünschten Soundbuffer übergeben. PrimaryBuffer. Ein besonderer Buffer innerhalb der DirectSoundProgrammierschnittstelle ist der PrimaryBuffer. Dieser Buffer ist zwar generell auch nur ein Bereich, in dem Daten zur Wiedergabe der Soundelemente verwaltet werden, das Besondere an ihm ist aber, dass es pro Applikation nur einen PrimaryBuffer gibt, im Gegensatz zu den SecondaryBuffern, die nur durch den Speicherplatz des Systems begrenzt werden. Die besondere Aufgabe des PrimaryBuffers besteht darin, die Daten zur Wiedergabe von den SecondaryBuffern zu übernehmen und an die Soundkarte weiterzugeben.

31.4 DirectSound-3DBuffer Alle Elemente, die wir bis jetzt kennen gelernt haben, dienen der Ausgabe von zweidimensionalem Sound innerhalb der DirectSound-Klasse. Die Schnittstelle hat aber noch eine weitere Möglichkeit zur Wiedergabe von Sounddaten. Mit dem 3DBuffer-Objekt können wir nun die dritte Dimension erobern. Die Ersteller der DirectSound-Klasse haben versucht, reale Soundeffekte in die Schnittstelle zu integrieren. Sie arbeiten dabei mit einer Kombination von 3DBuffern und 3DListenern. Die 3DBuffer stellen die einzelnen Geräuschquellen dar und der 3DListener den Zuhörer. Dabei werden die Audiodaten, die am Ende ausgegeben werden, unter Berücksichtigung von Position, Geschwindigkeit und Ausrichtung der Objekte errechnet. Programmiertechnisch ist der 3DBuffer ein normaler SecondaryBuffer, der um die Möglichkeit der Positionsbestimmung erweitert wurde. Eine weitere Eigenart des 3DBuffers ist, dass er nur Mono-Sounddaten unterstützt. Dieses ist aber auch logisch, da in der Natur ja auch alle Töne „mono“ sind. Die Effekte werden dann über die DirectSound-Klasse berechnet.

DirectSound-3DBuffer

333

31.4.1 Ausrichtung des 3DBuffers Außer der Ausgabe der Position des Soundbuffers hat man beim 3DBuffer-Objekt noch die Möglichkeit, verschiedene andere Optionen einzustellen. Wir müssen uns diese Einstellungsmöglichkeiten wie die Eigenschaften einer Lautsprecherbox vorstellen: Je nachdem, wo sie vor der Lautsprecherbox stehen, hören Sie den Ton in einer anderen Lautstärke, dieses hat mit der unterschiedlichen Ausbreitung der Schallwellen zu tun. Um diesen Effekt auch im 3D-Soundbereich der DirectSoundSchnittstelle zu realisieren haben die Entwickler von DirectX dem 3DBuffer-Objekt noch verschiedene Eigenschaften zur Verfügung gestellt, die diesen Effekt simulieren. Diese Eigenschaften sind ConeOutsideVolume, ConeInsideVolume, ConeAngles und ConeOrientation. Mit Hilfe der ConeOrientation-Eigenschaft des Buffers können Sie die Richtung bestimmen in die der Sound ausgerichtet werden soll. Danach können Sie mit den ConeAngles Eigenschaften den Inner- und OuterCone der Soundquelle festlegen. Diese beiden Einstellungen bestimmen, ab welchem Winkel, von der Soundrichtung aus gesehen, die Lautstärke des Sounds abnehmen soll. Um welche Größe sich dabei die Lautstärke vermindert, wird dann durch die ConeOutsideVolumen-Eigenschaft ausgegeben.

Abb. 87. Schallkegel 3DBuffer

334

DirectSound: Modell

31.5 DirectSound-3DListener Die generelle Funktion des 3DListeners haben wir ja bereits kennen gelernt. Wir wollen uns das Objekt aber noch ein wenig näher ansehen. Generell ist der 3DListener der Zuhörer innerhalb der Anwendung. Deshalb gibt es auch nur ein Objekt dieses Typs pro Programm, da es keinen Sinn macht, einen Ton für mehrere Zuhörer auszurechnen, wenn wir sowieso nur einen Hören können. Deshalb wird der 3DListener vom PrimaryBuffer unsere Anwendung abgeleitet. 31.5.1 Ausrichtung des 3DListeners Im Gegensatz zur Richtung der Soundquelle des 3DBuffers müssen wir beim 3DListener die Orientierung des Objektes bestimmen. Dieses geschieht mit zwei Vektoren. Der erste (Front) zeigt dabei in die Blickrichtung des Listeners und der zweite (Top) zeigt nach oben. Dabei müssen die beiden Vektoren immer einen Winkel von 90 Grad ergeben.

Abb. 88. Standardausrichtung eines 3DListener-Objekts

31.6 DirectSound-CaptureBuffer Das letzte Buffer-Objekt innerhalb der Klasse wollen wir nur kurz erwähnen. Der CaptureBuffer dient zur Aufnahme von Daten über die Soundhardware. Die Daten werden dabei im Speicher zwischengelagert und können vom Anwender von dort weiterverarbeitet werden. Wie gesagt gehört diese Aufgabe der DirectSound-Schnittstelle nicht zu den Standardaufgaben eines Spieles und wird deshalb hier auch nicht weiter

DirectSound-CaptureBuffer

335

behandelt. Wir können an dieser Stelle auf die Internetseite (www.directxATvb.de) zum Buch verweisen, auf dieser werden wir in Zukunft auch Beispiele zu dieser Technik für unsere Leser bereitstellen. Damit haben wir alle wichtigen Elemente des DirectSound-Objektes kennen gelernt. Im folgenden Abschnitt wollen wir verschiedene Beispiele zu den beschriebenen Techniken vorstellen und erklären. Dabei gehen wir auch intensiver auf bestimmte Eigenarten der einzelnen Klassen ein und werden diese erläutern.

32 2DSound-Demo

Das erste Beispiel zum Thema DirectSound ist das Projekt 2DSound. Mit diesem Projekt werden wir die generelle Funktionsweise der Soundwiedergabe demonstrieren und das Handling von SecondaryBufferObjekten. Wir haben zu diesem Zweck eine Klasse geschaffen, die alle wichtigen Aufgaben in diesem Bereich für uns ausführt. Diese Klasse DirectXSound haben wir mit unserem Projekt verknüpft und im Deklarationsbereich der frmStart-Klasse instanziert.

Abb. 89. frmStart-Klasse des 2DSound-Projektes

Zu Anfang des Projektes müssen wir in der Load-Methode der frmStart-Klasse die Parameter der Steuerelemente festlegen. Wir füllen als Erstes die ComboBox mit den Informationen der zur Verfügung stehenden Sound-Devices. 1 2 3 4 5 6

DevCollection = New DirectSound.DevicesCollection Dim Dev As DirectSound.DeviceInformation For Each Dev In DevCollection Dim dd As New DeviceDescription(Dev) ComboBox_Device.Items.Add(dd) Next Dev

338 7 8 9

2DSound-Demo

If 0 < ComboBox_Device.Items.Count Then ComboBox_Device.SelectedIndex = 0 End If

Wir erstellen eine neue Instanz des DevicesCollection-Objektes in Zeile 1. Mit Hilfe dieser Collection und den daraus gewonnenen Informationen wollen wir die ComboBox füllen. Zu diesem Zweck erstellen wir für jedes Sound-Device eine Instanz der Struktur DeviceDescription, die ebenfalls im Deklarationsbereich der frmStart-Klasse definiert wurde. Diese Information speichern wir dann in die ComboBox. In den Zeilen 7 bis 8 treffen wir dann eine Vorauswahl für die Anzeige der ComboBox. 10 11 12 13 14 15

With TrackBar_Volume .Minimum = -10000 .Maximum = 0 .SmallChange = 1000 .Value = -500 End With

Als Nächstes legen wir die Parameter für den TrackBar fest, mit dem wir im Verlauf des Programms die Lautstärke unseres Sounds einstellen werden. Dabei legen wir den Wertebereich von TrackBars-Volume auf den Bereich, der auch von einem SecondaryBuffer unterstützt wird. Wenn man einen Sound in einen SecondaryBuffer lädt, so hat dieser immer die höchste Lautstärke voreingestellt. Diese Lautstärke hat den Wert 0. Wir können also die Lautstärke des SecondaryBuffers von –10000 bis 0 verändern. 16 17 18 19 20 21

With TrackBar_Pan .Minimum = -10000 .Maximum = 10000 .SmallChange = 1000 .Value = 0 End With

Das nächste TrackBar-Objekt repräsentiert die Panoramaeinstellung des SecondaryBuffers. Dieser kann man einen Wert von –10000 bis 10000 zuweisen. Wobei –10000 die linke Seite darstellt und 10000 die rechte Seite. Der Wert 0 ist dementsprechend genau die Mitte. 22 23 24 25

With TrackBar_Frequency .Minimum = 0 .Maximum = 100000 .SmallChange = 1000

DirectSound-CaptureBuffer 26 27

339

.Value = 0 End With

Mit dem letzten TrackBar-Objekt wollen wir die Samplefrequenz des SecondaryBuffers im Laufe des Programms beeinflussen. Der Wertebereich für diese Eigenschaft geht von 0–10000. Wobei die Startfrequenz zur Wiedergabe des Sounds einen Wert von 100 hat. 28

PlaySound = New DirectXSound

Als Nächstes instanzieren wir die Klasse DirectXSound für unser Projekt. In dieser Klasse haben wir, wie bereits erwähnt, alle Funktionen zur Wiedergabe und Erstellung von Soundobjekten zusammengefasst. 29

30

31

32

33

34

35

36

37

AddHandler TrackBar_Volume.ValueChanged, _ AddressOf ValueChanged AddHandler TrackBar_Frequency.ValueChanged, _ AddressOf ValueChanged AddHandler TrackBar_Pan.ValueChanged, _ AddressOf ValueChanged AddHandler RadioButton_Chorus.CheckedChanged,_ AddressOf CheckedChanged AddHandler RadioButton_Distortion.CheckedChanged,_ AddressOf CheckedChanged AddHandler RadioButton_Echo.CheckedChanged,_ AddressOf CheckedChanged AddHandler RadioButton_Flange.CheckedChanged,_ AddressOf CheckedChanged AddHandler RadioButton_Gargle.CheckedChanged,_ AddressOf CheckedChanged AddHandler RadioButton_Compression.CheckedChanged,_ AddressOf CheckedChanged

Zum Schluss der Load-Methode müssen wir nur noch verschiedenen Ereignissen unserer Control-Objekte eine Behandlungsroutine zuweisen. Wir wollen uns jetzt die beiden wichtigsten Funktionen des Projektes ansehen und die dabei benutzten DirectSound-Methoden näher erklären. Dazu werden wir an dieser Stelle auch die DirectXSound -Klasse näher kennen lernen. Als Erstes wollen wir uns die Button_FileLoad_Click-Methode einmal ansehen. Mit Hilfe dieser Methode wollen wir ein Sound-Device erstellen, einen SecondaryBuffer für die Sounddaten definieren und diese Daten anschließend sofort wieder ausgeben.

340 1 2 3 4

2DSound-Demo

OFile.ShowDialog() If OFile.FileName "" Then Dim itemSelect As DeviceDescription itemSelect = CType(ComboBox_Device.Items_ (ComboBox_Device.SelectedIndex), DeviceDescription)

Da wir Daten aus einer Sounddatei wiedergeben wollen, starten wir die ganze Funktion mit dem OpenFileDialog-Objekt. Wir benutzen dieses, um dem Anwender die Möglichkeit zu geben, eine Datei auszuwählen. Wenn der Dialog geschlossen wird und es wird kein Dateiname zurückgegeben, beenden wir die Funktion sofort wieder. Liefert der Dialog aber einen Dateinamen zurück, dann muss als Nächstes die Hardware festgestellt werden, mit der wir diese Sounddatei wiedergeben sollen (Zeile 4). 5 6 7

8 9

10

If Guid.Empty.Equals(itemSelect.info.DriverGuid) Then If (PlaySound.CreateDevice()) = False Then_ MessageBox.Show("Device konnte nicht _ initialisiert werden") : Exit Sub Else If PlaySound.CreateDevice_ (itemSelect.info.DriverGuid) = False Then _ MessageBox.Show("Device konnte nicht _ initialisiert werden") : Exit Sub End If

In Abhängigkeit mit der Hardware entscheiden wir, wie das Sound-Device erstellt werden soll. Sollte das Erstellen des Devices fehlschlagen, dann wird eine Fehlermeldung ausgegeben und die Methode verlassen. An dieser Stelle setzen wir die beiden ersten Funktionen unserer eigenen DirectXSound-Klasse ein. Diese beiden und die nächste Funktion CreateSound werden wir im Anschluss an diese Funktion kennen lernen. 11

12

13 14

If PlaySound.CreateSound(Me, OFile.FileName) =_ False Then MessageBox.Show("Buffer konnte nicht initialisiert _ werden") Exit Sub End If

Wenn das Device erstellt werden konnte, erzeugen wir in Zeile 11 dann den SecondaryBuffer und füllen diesen mit den Daten aus der Sounddatei. 15 16

TextFileName.Text = OFile.FileName Button_Play.Enabled = True

DirectSound-CaptureBuffer 17 18 19

341

Button_StopPlay.Enabled = True CheckLoop.Enabled = True End If

Da wir innerhalb der Funktion bei jedem Fehler, der auftreten könnte, den Programmablauf abbrechen, können wir davon ausgehen, dass wir in Zeile 15 ein funktionstüchtiges Device mit erstelltem SecondaryBuffer zu Verfügung haben. Wir geben deshalb die Button-Controls frei, um den Sound abspielen zu können. Wir wollen uns jetzt die drei Methoden ansehen, die wir innerhalb der letzten Funktion benutzt haben. 1 2 3 4 5 6 7 8

1

2 3 4 5 6 7 8

Public Function CreateDevice() As Boolean Try DirectSoundDevice = New Device Catch ex As Exception Return False End Try Return True End Function Public Function CreateDevice(ByVal devGUID As _ System.Guid) As Boolean Try DirectSoundDevice = New Device(devGUID) Catch ex As Exception Return False End Try Return True End Function

Die Erstellung des Devices ist dabei kaum der Rede wert. Wir haben trotzdem mal die beiden Überladungen der CreateDevice-Funktion an dieser Stelle aufgelistet. Der einzige Unterschied in den beiden Überladungen besteht darin, dass wir in der zweiten Version explizit die Hardware auswählen können, mit der das Programm den Sound wiedergeben soll. Die nächste Funktion zum Erstellen des SecondaryBuffers ist da schon etwas aufwendiger. 1

2 3 4 5

Public Function CreateSound(ByVal Handle As _ System.Windows.Forms.Control, _ ByVal SoundFileAndPath As String) As Boolean Try If DirectSoundDevice Is Nothing Then Return False End If

342

2DSound-Demo

Wenn das SoundDevice nicht initialisiert ist, brauchen wir nicht weiterzumachen und können die Funktion verlassen. 6 7 8 9 10 11 12

Dim BDesc = New BufferDescription With BDesc .ControlPan = True .ControlVolume = True .ControlFrequency = True .ControlEffects = True End With

Wenn ein funktionierendes Device vorliegt, können wir uns an die Einstellung des SecondaryBuffers begeben. Diese wird über ein BufferDescription-Objekt realisiert. Wir stellen die Description so ein, dass unser SecondaryBuffer die Optionen zugewiesen bekommt, um Volumen-, Panorama-, Frequenz- und Effektänderungen durchführen zu können. 13

DirectSoundDevice.SetCooperativeLevel(Handle,_ DirectSound.CooperativeLevel.Normal)

Als Nächstes legen wir fest, wie der PrimaryBuffer unserer Applikation mit dem System und somit mit möglichen anderen Soundapplikationen interagiert. 14

SecBuffer = New SecondaryBuffer(SoundFileAndPath, BDesc, DirectSoundDevice)

Abschließend können wir nun den SecondaryBuffer erstellen, dabei übergeben wir alle Informationen, die wir im Laufe der Methode zusammengestellt haben, an die New-Überladung der SecondaryBufferKlasse. 15 16 17 18 19

Catch ex As Exception Return False End Try Return True End Function

Wir haben nun also einen funktionierenden SecondaryBuffer zur Verfügung, der obendrein noch mit den ausgewählten Sounddaten gefüllt ist. Wir müssen uns also nur noch darum kümmern, diese Daten auch wiederzugeben. Die Wiedergabe der Daten soll mit einem Klick auf den


343

Button_Play starten. Dazu haben wir die Click-Methode des Buttons folgendermaßen gestaltet. 1

2 3 4 5 6 7 8

Private Sub Button_Play_Click(ByVal sender As_ System.Object, ByVal e As System.EventArgs)_ Handles Button_Play.Click PlaySound.Volume(TrackBar_Volume.Value) PlaySound.Pan(TrackBar_Pan.Value) If TrackBar_Frequency.Value < 100 Then PlaySound.Frequency(0) Else PlaySound.Frequency(TrackBar_Frequency.Value) End If

Als erste Handlung übergeben wir die Werte der TrackBar-Controls an den Soundbuffer. 9 10

11 12

13 14 15

16 17 18

19 20 21

22 23 24

25 26 27

28

Dim FX() As DirectSound.EffectDescription ReDim FX(0) If RadioButton_Echo.Checked = True Then FX(0).GuidEffectClass = _ DirectSound.DSoundHelper.StandardEchoGuid End If If RadioButton_Chorus.Checked = True Then FX(0).GuidEffectClass =_ DirectSound.DSoundHelper.StandardChorusGuid End If If RadioButton_Flange.Checked = True Then FX(0).GuidEffectClass =_ DirectSound.DSoundHelper.StandardFlangerGuid End If If RadioButton_Gargle.Checked = True Then FX(0).GuidEffectClass =_ DirectSound.DSoundHelper.StandardGargleGuid End If If RadioButton_Distortion.Checked = True Then FX(0).GuidEffectClass =_ DirectSound.DSoundHelper.StandardDistortionGuid End If If RadioButton_Compression.Checked = True Then FX(0).GuidEffectClass =_ DirectSound.DSoundHelper.StandardCompressorGuid End If

Danach überprüfen wir in Zeile 11 bis 28, ob der Anwender einen Effekt für die Wiedergabe ausgewählt hat. Wenn ein Effekt gewählt wurde, ermitteln wir die Standardinformationen zu dem gewählten Effekt aus dem

344

2DSound-Demo

DSoundHelper-Objekt. Dazu übergeben wir die GUID des Effektes an ein vorher erstelltes Array des Typs EffectDescription. 29 30 31 32 33 34

Try PlaySound.Effects(FX) CheckBox_EffektOK.Checked = True Catch ex As Exception CheckBox_EffektOK.Checked = False End Try

Die vorher eingestellten Effekte übergeben wir nun in Zeile 30 dem Soundbuffer und überprüfen mit dem Try-Catch-End-Try-Block, ob die Einstellung erfolgreich war. Sind die Effekte vom Buffer übernommen worden, bleibt uns nur noch den Buffer abzuspielen. 35 36 37 38 39 40

If CheckLoop.Checked = True Then PlaySound.LoopSound() Else PlaySound.PlaySound() End If End Sub

Zur Wiedergabe des Buffers überprüfen wir noch das CheckLoopObjekt. Ist dieses markiert, dann geben wir den Sound als Schleife wieder, ist die CheckBox nicht markiert, dann wird der Sound einmalig wiedergegeben. Mit dieser Anwendung können wir nun alle WAV-Dateien laden und abspielen. Dabei können wir uns einen Überblick verschaffen, welche Möglichkeiten wir bei der Modifizierung von Sounddateien haben und wie wir diese vielleicht in unsere Spielprojekte einfügen können.

33 3DSound-Demo

Die 2DSound-Möglichkeiten des DirectSound-Objektes haben wir nun kennen gelernt und auch ein Beispiel für ihren Einsatz vorgestellt. Diese Art der Wiedergabe ist der eines konventionellen Audioprogramms ähnlich, wir können eine Datei laden, diese mit Effekten versehen und danach wieder ausgeben. Für ein dreidimensionales Spiel ist diese Art der Wiedergabe aber wenig realistisch. Denn die richtige Atmosphäre bei einem Spiel kommt erst dann auf, wenn man hört, aus welcher Richtung sich der Gegner nähert, bevor man den Gegner zu Gesicht bekommt. Um diese Soundeffekte in das DirectSound-Objekt zu integrieren, haben sich die Entwickler von DirectX eine Kombination von verschiedenen Objekten ausgedacht. Diese Objekte, den 3DBuffer und den 3DListner, haben wir ja schon erwähnt. An dieser Stelle wollen wir uns um den Einsatz dieser beiden Objekte kümmern.

Abb. 90. frmStart-Klasse des 3DSound-Projektes

Wie wir auf der Abbildung sehen, ähnelt die 3DSound-Applikation ihrem Vorgänger stark. Das Programm ist lediglich um ein Anzeigefeld erweitert worden. Mit diesem Feld wollen wir die Bewegung der Geräuschquelle

346

3DSound-Demo

darstellen und deren Steuerung durchführen. Da sich die beiden Applikationen von ihrem Aufbau nicht sehr unterscheiden, beschränken wir uns bei der Erklärung dieser Applikation auf die Neuerungen gegenüber der ersten Anwendung. Die erste Änderung, die wir vorgenommen haben, ist das Einfügen eines Bereiches zu Darstellung der Soundquelle und des Hörers. Diese Objekte haben wir in der Picturebox auf der rechten Seite der Applikation angesiedelt. Mit ihr wollen wir die 3DSound-Objekte optisch darstellen. Zur Initialisierung der Objekte haben wir in der Load-Methode der frmStart-Klasse die Bilder für die Darstellung eingebunden. 1

2

3

4

5

6

icoSateliteIcon = New Icon_ (DXUtilities.FindMediaFile("Bilder\satelite.ico")) icoListener = New Icon_ (DXUtilities.FindMediaFile("Bilder\system.ico")) icoBoxVL = New Icon_ (DXUtilities.FindMediaFile("Bilder\boxvl.ico")) icoBoxVR = New Icon_ (DXUtilities.FindMediaFile("Bilder\boxvr.ico")) icoBoxHL = New Icon_ (DXUtilities.FindMediaFile("Bilder\boxhl.ico")) icoBoxHR = New Icon_ (DXUtilities.FindMediaFile("Bilder\boxhr.ico"))

Den Timer benötigen wir zum Updaten der Darstellung unserer Objekte. Wir lassen mit Hilfe des Timers die Picturebox an der rechten Seite alle 200 ms neu zeichnen. 7

RefreshTimer.Enabled = True

Die nächsten Änderungen haben wir in der Click-Funktion des Button_FileLoad vorgenommen. 1

2 3

4

5 6 7 8

Private Sub Button_FileLoad_Click(ByVal sender As_ System.Object, ByVal e As System.EventArgs)_ Handles Button_FileLoad.Click ... If PlaySound.Create3DSound_ (Me, OFile.FileName) = False Then MessageBox.Show("Buffer konnte nicht _ initialisiert werden") Exit Sub End If If PlaySound.Create3DListener(Me) = False Then MessageBox.Show("Listener konnte nicht _ initialisiert werden")

DirectSound-CaptureBuffer 9 10 11 12 13 14 15 16

347

Exit Sub End If TextFileName.Text = OFile.FileName Button_Play.Enabled = True Button_StopPlay.Enabled = True CheckLoop.Enabled = True End If End Sub

Der Anfang der Funktion bleibt im Vergleich zum 2DSound-Beispiel unverändert. Die erste Änderung haben wir in Zeile 3 vorgenommen. Anstelle der CreateSound-Methode der DirectXSound-Klasse rufen wir bei dem 3DSound-Projekt die Funktion Create3DSound auf. Zusätzlich zu dieser Funktion rufen wir dann auch noch die Funktion Create3DListener auf, um zusätzlich zu dem SoundBuffer noch das Listener-Objekt zu initialisieren. Diese beiden wichtigen Methoden wollen wir uns deshalb jetzt einmal im Detail ansehen. Mit der Funktion Create3DSound wollen wir ein SecondaryBuffer-Objekt mit der eingestellten Control3D-Eigenschaft für die drei dimensionale Wiedergabe des Sounds erstellen. 1

2 3 4 5

Public Function Create3DSound(ByVal Handle As_ System.Windows.Forms.Control, ByVal _ SoundFileAndPath As String) As Boolean Try If DirectSoundDevice Is Nothing Then Return False End If

Als Erstes wird wieder überprüft, ob das SoundDevice, mit dem der SecondaryBuffer erstellt werden soll, auch ordnungsgemäß initialisiert wurde. Sollte dieses nicht der Fall sein, wird die Funktion sofort wieder mit der Rückgabe des Wertes False beendet. 6 7 8 9 10 11 12

Dim BDesc As New BufferDescription With BDesc .ControlVolume = True .ControlFrequency = True .ControlEffects = True .Control3D = True End With

Danach legen wir die Eigenschaften fest, mit dem der SecondaryBuffer erstellt werden soll. Wir geben an, dass neben der Möglichkeit, die

348

3DSound-Demo

Lautstärke, die Frequenz und die Effekte zu verändern, der Buffer auch die Control3D-Eigenschaft besitzen soll. 13

DirectSoundDevice.SetCooperativeLevel(Handle,_ DirectSound.CooperativeLevel.Normal)

Als Nächstes legen wir wieder fest, wie unser SoundBuffer mit anderen Applikationen beim Zugriff auf die Soundhardware agieren soll. 14

15

16 17

SecBuffer = New SecondaryBuffer(SoundFileAndPath,_ BDesc, DirectSoundDevice) Buf3D = New Microsoft.DirectX_ .DirectSound.Buffer3D(SecBuffer) Buf3D.Mode = DirectSound.Mode3D.Normal Buf3D.Position = New Vector3(0, 0, 0)

Jetzt können wir in Zeile 14 unseren SecondaryBuffer erstellen und gleichzeitig die Sounddatei in den Buffer laden. Dieses alleine reicht für die 3D-Wiedergabe der Sounddatei noch nicht aus. Wir müssen den erstellten SecondaryBuffer nun einem Buffer3D-Objekt zu weisen. Mit Hilfe der Buffer3D-Klasse können wir das Verhalten des SoundBuffers im dreidimensionalen Raum festlegen. Als Erstes legen wir den Modus des Buffers fest. Mit dem Mode3D.Normal-Flag stellen wir sicher, dass die Position des Buffers absolut ist. Mit dem Flag Mode3D.HeadRelative könnten wir an dieser Stelle festlegen, dass die Position des Buffers immer relativ zum 3DListener-Objekt gesehen wird und angepasst wird, wenn dieses seine Position verändert. Anschließend initialisieren wir die Position des Buffers auf den Nullpunkt des Koordinatensystems. 18 19 20 21 22 23 24 25

Dim speak As DirectSound.Speakers speak.Stereo = True DirectSoundDevice.SpeakerConfig = speak Catch ex As Exception Return False End Try Return True End Function

Zum Schluss der Funktion stellen wir noch die Lautsprecherkonfiguration des Sound-Devices auf einen Standard-Stereolautsprecher ein. Damit haben wir nun unsere erste 3D-Soundquelle erstellt. Wir möchten an dieser Stelle noch einmal erwähnen, dass es sich bei Sounddateien für eine 3DSoundwiedergabe um Mono-Sound handeln muss, da es bei Erstellung des Soundbuffers ansonsten zu einem Fehler kommt.


349

Nachdem wir nun eine dreidimensionale Soundquelle in unserem Projekt initialisiert haben, benötigen wir auch einen Zuhörer. Diesen 3DListener wollen wir jetzt erstellen. 1

2 3

Public Function Create3DListener(ByVal Handle As _ System.Windows.Forms.Control) As Boolean Try Dim buff As Microsoft.DirectX.DirectSound_ .Buffer = Nothing

Da der 3DListener in unserem Fall auch die Funktionen des PrimaryBuffers übernimmt, erstellen wir als Erstes eine Instanz der DirectSound.Buffer-Klasse. 4 5 6 7 8

Dim BDesc As New BufferDescription With BDesc .PrimaryBuffer = True .Control3D = True End With

Danach bestimmen wir die Eigenschaften, die der neu zu erstellende Buffer haben soll, für unseren Fall ist das die Eigenschaft PrimaryBuffer und Control3D. 9

10

11 12 13 14 15 16

buff = New Microsoft.DirectX.DirectSound.Buffer_ (BDesc, DirectSoundDevice) List3D = New Microsoft.DirectX.DirectSound_ .Listener3D(buff) List3D.Position = New Vector3(0, 0, 0) Dim Orientation As Listener3DOrientation Orientation.Front = New Vector3(0, 0, 1) Orientation.Top = New Vector3(0, 1, 0) List3D.Orientation = Orientation List3D.DistanceFactor = 0.01

Wir erstellen den neuen Buffer in Zeile 9 mit den vorher ausgewählten Eigenschaften und weisen ihn in Zeile 10 direkt der Listener3D-Instanz zu. Danach stellen wir die Eigenschaften des 3DListener-Objektes ein. Wir weisen ihm eine Position zu (Zeile 11). Danach weisen wir der Klasse noch die Orientation zu. Am Ende bestimmen wir noch die Maßeinheit des 3DListeners, nämlich 0.01. Dieses entspricht einem Wert von einem Zentimeter in der Wirklichkeit. Wir haben nun beide Objekte erstellt, die wir zur Wiedergabe von drei dimensionalen Sounds brauchen. Wie wir diese einsetzen, können wir in der

350

3DSound-Demo

Funktion DrawPicture sehen, mit deren Hilfe wir die Position der beiden Objekte im Raum bestimmen. Da wir uns bei diesem Projekt auf die Erstellung von 3DSound-Objekten beschränken wollten, haben wir dieses Projekt komplett ohne 3D-Interface erstellt. Wir gehen davon aus, dass die Kombination der Grafik und des Sounds im Anschluss an die Lektüre dieses Buches kein Problem mehr bereiten sollte. Wir beschränken uns bei der Ausgabe also auf 2D-Grafik, welche die Position der Soundquelle darstellen soll. 1 2 3

Private Sub DrawPicture(ByVal intGrad As Integer) Dim x, y, radius As Integer x = 170 : y = 170 : radius = 150

Für die Bewegung der Soundquelle begnügen wir uns mit einer einfachen Kreisbahn rund um den Listener. Dazu benötigen wir die Position des Listeners und den Radius der Kreisbahn, diese Werte legen wir in Zeile 3 fest. 4 5

Dim objGraphics As System.Drawing.Graphics objGraphics = PictureBox_Ausgabe.CreateGraphics()

Zur Darstellung der PictureBox arbeiten wir mit dem GraphicsObjekt der PictureBox. Diese weisen wir in Zeile 5 der Variablen objGraphics zur weiteren Bearbeitung zu. 6

7

Dim xPos As Single = radius * _ (Math.Cos(intGrad * (Math.PI / 180))) + x Dim yPos As Single = radius * _ (Math.Sin(intGrad * (Math.PI / 180))) + y

Danach berechnen wir die aktuelle Position der Soundquelle mit Hilfe der eingestellten Position des Listeners und dem vorausgewählten Radius. Der aktuelle Gradwert zur Berechnung der Position der Soundquelle wird dabei der Funktion beim Aufruf übergeben. 8

9

PlaySound.ListenerPosition(New DirectX.Vector3_ (x / 100, 0, y / 100)) PlaySound.BufferPosition(New DirectX.Vector3_ ((xPos / 100), 0, (yPos / 100)))

Die berechneten Positionen übergeben wir anschließend an unsere beiden 3D-Objekte. Damit die Soundwiedergabe in unserem Projekt klarer wird, haben wir die Werte vor der Übergabe an die Objekte noch um das 100fache verkleinert.

DirectSound-CaptureBuffer 10 11 12 13 14 15 16

351

objGraphics.DrawIcon(icoSateliteIcon, xPos, yPos) objGraphics.DrawIcon(icoListener, x - 10, y - 10) objGraphics.DrawIcon(icoBoxVL, x - 60, y - 75) objGraphics.DrawIcon(icoBoxVR, x + 60, y - 75) objGraphics.DrawIcon(icoBoxHL, x - 60, y + 75) objGraphics.DrawIcon(icoBoxHR, x + 60, y + 75) End Sub

Zum Schluss zeichnen wir mit Hilfe der Graphics-Klasse noch die einzelnen Bilder in die PictureBox zur Darstellung der Soundobjekte. Damit haben wir alle Einstellungen getätigt, die wir zur Wiedergabe eines 3D-Sounds benötigen. Beim Start des Projektes können wir nun wie gehabt eine Sounddatei laden und diese wiedergeben. Mit den drei Buttons unterhalb der PictureBox können wir jetzt die Position der Soundquelle bestimmen und mit dem Start- und Stop-Button die Wiedergabe starten bzw. beenden (siehe Abbildung 90). Dieses waren nun die beiden Möglichkeiten, um Sounds und Effekte in unsere Projekte einzubinden. Leider sind wir dabei auf das WAVFileformat beschränkt. Wir können also nur Sounddateien in diesem Format laden. Andere Soundformate können wir mit der DirectAudioVideoKlasse in unsere Projekte mit einbringen. Um die Arbeit mit dieser Klasse wollen wir uns im nächsten Kapitel kümmern.

34 AudioVideoPlayback

34.1 Ein Wort zu DirectMusic Mit DirectMusic hat Microsoft eine weitere umfangreiche Programmierschnittstelle für das Thema Soundwiedergabe geschaffen. Diese API Funktionen und Methoden bietet zur professionellen Erstellung von Sounds und Soundeffekten. Da diese Schnittstelle auf den professionellen Anwender ausgerichtet ist, hat Microsoft darauf verzichtet, diese Funktionen auch den Visual Basic.NET-Programmierern mit Hilfe der Managed DirectX-Schnittstelle zur Verfügung zu stellen. Ein Beispiel zu diesem Thema passt nicht in dieses Buch, da man hier ausschließlich mit C++ Mitteln arbeiten müsste. Da wir uns aber vorwiegend mit Visual Basic.NET beschäftigen wollen, werden wir dieses Thema ausschließlich auf unseren Webseiten behandeln. An dieser Stelle kümmern wir uns um die beiden Objekte, die Microsoft auch für den Visual Basic.NET-Programmierer vorgesehen hat.

34.2 AudioVideoPlayback generell Mit der AudioVideoPlayback-Programmierschnittstelle hat Microsoft für Visual Basic.NET eine einfache Möglichkeit geschaffen, Multimediadateien abzuspielen. Dabei kann man das Wort „einfach“ aus zwei Perspektiven betrachten. Die erste ist, dass die Erfinder von DirectX es mit dieser Schnittstelle dem Programmierer ermöglicht haben, mit wenigen Befehlen Sounds und Videos darzustellen. Die zweite Bedeutung von „einfach“ ist darin zu sehen, dass Microsoft in der AudioVideoPlaybackAPI nur minimale Funktionen zur Verfügung stellt, um die Dateien wiederzugeben. Für unsere Zwecke reichen diese Funktionen aber vollkommen aus, deshalb wollen wir uns in den nächsten beiden Projekten einmal ansehen, wie man mit dem AudioVideoPlayback-Objekt eine MediaPlayer-Variante auf einfache Art realisieren kann.

354

AudioVideoPlayback

34.3 Audio

Abb. 91. Medienwiedergeber (Audio)

Generell müssen wir beim Einsatz der AudioVideoPlayback-Schnittstelle im Projekt-Explorer von Visual Studio den Verweis zu dem Objekt hinzufügen. Danach können wir die Schnittstelle wie gewohnt zu unserem Projekt hinzufügen. Imports DXAudioVideo = Microsoft_ .DirectX.AudioVideoPlayback

In unserem ersten Projekt wollen wir nur Audiodateien wiedergeben, deshalb beschränken wir uns auch darauf, die Audio-Klasse im Deklarationsbereich der frmStart-Klasse zu instanzieren. Private MyAudio As DXAudioVideo.Audio = Nothing

Für dieses Projekt haben wir einen dynamischen Aufbau der Steuerelemente vorgesehen. Die Umsetzung dazu haben wir in der Paint-Methode der frmStart-Klasse integriert. Hier werden die aktuellen Größen der Steuerelemente abhängig von der aktuellen Größe der Hauptform berechnet und festgelegt. 1

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Private Sub frmStart_Paint(ByVal sender As Object,_ ByVal e As System.Windows.Forms.PaintEventArgs)_ Handles MyBase.Paint Dim cliSize As Size = Me.ClientSize() Dim MaxBreite As Integer = cliSize.Width - 10 Dim LinkerRand As Integer = 5 With MyProgressBar .Top = 5 .Height = 20 .Left = LinkerRand .Width = MaxBreite End With With MyToolBar .Left = LinkerRand .Top = MyProgressBar.Height + 15 .Width = MaxBreite End With End Sub

Audio

355

Nach dieser kleinen Funktion, um die Optik des Programms dynamisch anzupassen, kommen wir jetzt zu den Funktionen, die wir benötigen, um die Audiodateien wiederzugeben. Alle wichtigen Befehle sind in der ButtonClick-Methode des ToolBar-Controls zusammengefasst. 1

2 3 4 5 6 7 8

Private Sub MyToolBar_ButtonClick(ByVal sender As_ System.Object, ByVal e As System.Windows.Forms_ .ToolBarButtonClickEventArgs)_ Handles MyToolBar.ButtonClick Select Case e.Button.Tag Case "open" If Not (MyAudio Is Nothing) Then MyAudio.Stop() MyAudio = Nothing MyStatusBar.Text = "" End If

Die erste Option in unserem ToolBar ist das Öffnen einer Datei. Ist diese Option gewählt worden, müssen wir erst einmal sicherstellen, dass unsere Audioklasse MyAudio in diesem Moment keine Datei wiedergibt. Ist die Klasse beim Aufruf der Open-Funktion initialisiert, wird eine eventuelle Wiedergabe angehalten (Zeile 5) und anschließend auf Nothing gesetzt. Wir löschen anschließend noch den Text in der Statusleiste, um anzuzeigen, dass keine Datei mehr geladen ist. 9 10 11 12 13 14 15 16 17

18 19 20

With MyOpenFileDialog .InitialDirectory = "C:\" .CheckFileExists = True .CheckPathExists = True .Filter = "Audio|*.wav;*.mid;*.mp3" .ShowDialog(Me) If .FileName "" Then MyAudio = New DXAudioVideo.Audio(.FileName) AddHandler MyAudio.Ending,_ AddressOf PlayEnding MyStatusBar.Text = .FileName End If End With

Zum Öffnen der Datei benutzen wir eine Instanz der OpenFileDialogKlasse. Wir initialisieren das Objekt mit der Root des C-Laufwerks als Startverzeichnis, von dem die Suche nach Dateien starten soll. In Zeile 13 legen wir dann noch die Dateiendungen fest, die wir in unsere Suche einbeziehen wollen. Mit dem Befehl ShowDialog starten wir den Suchdialog für die Mediendateien. Nach dem Schließen des Dialogs überprüfen wir in Zeile 15, ob ein gültiger Dateiname von dem Objekt

356

AudioVideoPlayback

zurückgeliefert wurde. Ist dies der Fall, dann wird die Audio-Klasse direkt im Anschluss unter zuhilfenahme des Dateinamens erstellt. Danach weisen wir dem Ending-Event der Klasse noch den Eventhandler PlayEnding hinzu. 21 22 23 24 25

Case "play" If Not (MyAudio Is Nothing) Then MyAudio.Play() MyTimer.Enabled = True End If

Den nächsten Befehl, den wir besprechen wollen, ist der Play-Befehl. Dieser Befehl wird ausgeführt, wenn der Button mit dem Tag play angeklickt wird, und ist ausgesprochen einfach zu realisieren. Wir brauchen an dieser Stelle nämlich nur zu überprüfen, ob die Audio-Klasse initialisiert ist, und danach mit dem Play-Befehl der Klasse die Wiedergabe der Sounddatei starten. Zusätzlich starten wir noch den Timer unseres Projektes, um die Statusanzeige des Medienwiedergebers zu starten. 26 27

28 29 30 31

Case "stop" If Not (MyAudio Is Nothing) And _ (MyAudio.Playing = True) Then MyAudio.Stop() MyProgressBar.Refresh() MyTimer.Enabled = False End If

Genauso einfach wie das Starten der Wiedergabe ist das Anhalten. Auch hier müssen wir zunächst den aktuellen Status der Audio -Klasse überprüfen. Wenn die Audio-Klasse initialisiert und der Status der PlayingEigenschaft auf True gesetzt ist, können wir die Wiedergabe stoppen. Anschließend lassen wir unsere Statusanzeige neu zeichnen und halten das automatische Updaten der Anzeige an. 32 33

34 35 36 37 38

Case "pause" If Not (MyAudio Is Nothing) And _ (MyAudio.Playing = True) Then MyAudio.Pause() MyTimer.Enabled = False End If End Select End Sub

Der Pause-Befehl unserer Funktion ist genauso aufgebaut wie der StopBefehl, mit dem einen Unterschied, dass beim Aufrufen der Pause-

Audio

357

Funktion der Klasse die aktuelle Abspielposition nicht wieder auf den Anfang der Datei gesetzt wird. Damit hätten wir alle Funktionen, die wir zur Wiedergabe einer Datei benötigen, in einer Funktion untergebracht. Zur Steuerung unseres Programms müssen wir jetzt noch eine weitere Funktion unserem Projekt hinzufügen. Diese Funktion benötigen wir, um eine Loop-Funktion in unserem Projekt zu integrieren. Wenn derLoop-Button gedrückt ist, (siehe Abbildung 91) wollen wir, dass der Sound am Ende der Wiedergabe wieder von vorn beginnt. Dazu haben wir den Eventhandler PlayEnding in unser Projekt eingefügt. Dieses Ereignis wird aufgerufen, wenn die Wiedergabe der Audio-Klasse am Ende angelangt ist. 1

2 3 4 5 6

Private Sub PlayEnding(ByVal sender As Object,_ ByVal e As System.EventArgs) MyAudio.CurrentPosition = 0 If TBLoop.Pushed = False Then MyAudio.Stop() End If End Sub

Am Ende der Wiedergabe setzen wir die aktuelle Position der Wiedergabe wieder auf den Anfang und überprüfen ob der Loop-Button gedrückt wurde. Ist dies nicht der Fall, halten wir die Wiedergabe an. Damit haben wir das erste Projekt zur Wiedergabe von Audiodateien abgeschlossen und wir haben gesehen, dass wir mit Hilfe der AudioVideoPlayback-Schnittstelle sehr schnell Ergebnisse erzielen können. Genauso einfach wie die Audiowiedergabe ist dabei der Videoteil der API zu programmieren.

358

AudioVideoPlayback

34.4 Video

Abb. 92. Medienwiedergeber (Video)

Im Vergleich zur Programmierung der Audio-Schnittstelle gibt es bei der Programmierung des Videoteiles der AudioVideoPlaybackSchnittstelle nur an zwei Stellen unseres Projektes eine Veränderung. Die erste Änderung ist zwangsläufig, denn anstatt einer Audioklasse müssen wir zum Arbeiten mit Videodateien, die Video-Klasse der API instanzieren. Private MyVideo As DXAudioVideo.Video = Nothing

Die zweite Änderung in unserem Projekt haben wir im Open-Bereich der ToolBar-ButtonClick-Methode. Anstatt den Filter des OpenFileDialogs mit Endungen von Audiodateien zu initialisieren, verwenden wir dieses Mal die Dateiendungen von Videoformaten (Zeile 3). Mit dem Dateinamen, der vom OpenFileDialog zurückgeliefert wird, erstellen wir dann in Zeile 6 eine Instanz der Video-Klasse. In Zeile 7 müssen wir dann der Video-Klasse das Steuerelement übergeben, auf dem das Video dargestellt werden soll. 1 2 3 4 5

Case "open" … .Filter = "Video|*.mpg;*.avi;*.wmv" .ShowDialog(Me) If .FileName "" Then

Video 6 7 8 9 10 11

359

MyVideo = New DXAudioVideo.Video(.FileName) MyVideo.Owner = MyPictureBox AddHandler MyVideo.Ending, AddressOf PlayEnding MyStatusBar.Text = .FileName End If End With

Dieses waren schon alle Unterschiede, die wir bei den beiden Projekten beachten müssen. Dabei ist anzumerken, dass wir uns bei beiden Projekten auf die reine Wiedergabe von Dateien beschränkt haben. Die beiden verwendeten Klassen haben darüber hinaus aber noch anderer Eigenschaften, auf die wir aber an dieser Stelle verzichtet haben.

35 DirectInput

Wenn Sie ein Spiel programmieren wollen, gibt es keine wichtigere Komponente von DirectX als DirectInput. Selbst ohne Grafik können Sie immerhin noch ein Textadventure erstellen. Natürlich ist das nicht mehr zeitgemäß, aber dennoch ist diesem ein eigenes Genre gewidmet. Alle Spiele haben eine Gemeinsamkeit: Sie fordern den Spieler zur Interaktion auf. Interagieren kann der Spieler über Eingabegeräte wie Tastatur, Maus oder Joystick. DirectInput ist eine Komponente von DirectX, mit der die Eingabegeräte abgefragt werden können. Hierbei unterscheidet DirectInput drei Gerätekategorien: • Standard-Systemtastatur • Maus oder mausähnliche Geräte (Maus, Trackball, Touchpad usw.) • Joystick (Joystick, Gamepad, Datenhandschuh, Lenkräder usw.)

35.1 Objekthierarchie Die Hersteller von Eingabegeräten lassen sich immer wieder neue Features einfallen, um besser, schneller oder einfach ein bisschen anders als die Konkurrenz zu sein. Dennoch muss DirectX in der Lage sein, diese Geräte zu managen. Als Schnittstelle zwischen DirectX und dem Eingabegerät dient der Treiber. Dieser interpretiert die Daten in eine für DirectX verständliche Form. Diese Kommunikation wollen wir nicht im Detail untersuchen, aber eine grobe Strukturierung vornehmen.

362

DirectInput

Abb. 93. Objekthierarchie

An der Spitze steht ein Interface (GUI). Das Interface nutzt DirectInput, um die Geräte (Devices) zu ermitteln und anzusprechen. Das Gerät liefert die notwendigen Daten in Bezug auf Eigenschaften und Fähigkeiten und vermittelt die Informationen über Sonderfunktionen wie beim ForceFeedback. Hieran wird auch deutlich, warum DirectInput eine ideale Eingabe-API ist. Es spielt keine Rolle, wie die Daten ermittelt wurden. Ob eine Maus die Daten mechanisch per Kugel oder optisch erfasst, ist bedeutungslos. Das können wir uns am Beispiel einer Standardmaus nochmals verdeutlichen: Device Objekte Effekte

--> Maus --> zwei Tasten, ein Rad zwei Achsen (X-Achse, Y-Achse) --> keine

35.2 Geräteauflistung Bevor wir auf ein Eingabegerät zugreifen können, müssen wir wissen, ob dieses Gerät überhaupt verfügbar ist. Bei einigen Geräten, wie der Tastatur oder der Maus, können wir davon ausgehen, dass diese zur Verfügung stehen. Dennoch bleibt auch bei den Standardgeräten die Frage, welche Fähigkeiten haben die Geräte? Denken Sie einmal an die Vielfalt unterschiedlicher Mäuse. Mäuse mit nur zwei Tasten oder fünf, mit und ohne Mittelrad. Die Gerätehersteller werden hier immer einfallsreicher und wir stehen vor dem Problem, nicht zu wissen, mit welcher Hardware wir es zu tun bekommen. Uns bleibt nichts anderes übrig, als zu prüfen, welche Hardware verwendet wird. Überlegen wir uns einmal, welche Informationen wir benötigen. Zum einen müssen wir wissen, welche Hardware zur Verfügung steht, zum anderen, welche Fähigkeiten die einzelnen Geräte besitzen.

Geräteauflistung

363

35.2.1 Beispielprogramm Unser Beispielprogramm ermittelt die verfügbaren Eingabegeräte sowie deren Fähigkeiten. In der oberen Listbox werden die Eingabegeräte aufgelistet. Gleichzeitig erhalten Sie einige Basisinformation (Name, Guid, Device-Typ usw.) über das selektierte Gerät. Wenn Sie ein Eingabegerät anklicken, werden die zu dem Gerät gehörenden Objekte in der unteren Listbox dargestellt.

Abb. 94. Screenshot Beispielprogramm DirectInputEnum

35.2.2 Eingabegeräte ermitteln Das Programm ist in zwei Routinen unterteilt. Die erste Routine ist in der Form1_Load untergebracht. Hier werden die Eingabegeräte ermittelt. 1 2 3 4

ListBox1.Items.Clear() Dim i As Integer = 0 Dim f As DirectInput.DeviceInstance ReDim DIDeviceArray(DirectInput.Manager.Devices.Count)

364 5 6

7 8 9 10 11

DirectInput

Dim instance As DirectInput.SemanticsInstance For Each f In _ DirecInput.Manager.GetDevices__ (DirectInput.DeviceClass.All, _ DirectInput.EnumDevicesFlags.AllDevices) ListBox1.Items.Add(f.ProductName) DIDeviceArray(i) = f i += 1 Next ListBox1.SelectedIndex = 0

Den Schlüssel zum Ermitteln der Eingabegeräte finden wir in Zeile 6. Die Methode DirectInput.Manager.GetDevices() erstellt ein Array, welches mit den Eingabegeräten gefüllt ist. Diese Methode benötigt die Angabe von zwei Parametern. Der erste Parameter ist die DeviceClass. Tabelle 13. DeviceClass Enumeration Konstante Pointer Keyboard

GameControl Other

All

Beschreibung Hiermit werden alle Zeigegeräte wie Maus oder Lichtstift angezeigt. Die angeschlossenen Tastaturen werden angezeigt. Es ist eine irrtümliche Annahme, dass nur eine Tastatur angeschlossen sein kann. Es gibt besondere Eingabetastaturen (10 Block, Inventurtastaturen), welche z.B. über USB oder seriell angeschlossen werden können. Hiermit sind Joysticks, Gamepads, Lenkräder usw. gemeint. Das sind alle Eingabegeräte, welche nicht in die aufgeführten Kategorien passen. Manchmal kommt es auch vor, dass ein Gerät sich nicht ordentlich identifiziert. Es ist zwar selten der Fall, aber dann findet man das Gerät hier. Falls Sie eine komplette Liste benötigen, dann können Sie diesen Parameter wählen. Hierbei wird nicht mehr in verschiedene Klassen unterschieden.

Der zweite Parameter sind die Konstanten EnumDeviceFlags. Tabelle 14. EnumDeviceFlags Konstante AllDevices AttachedOnly

Beschreibung Alle installierten Eingabegeräte werden aufgelistet. Hierunter fallen auch installierte, aber nicht angeschlossene Geräte. Das ist der Defaultwert. Alle installierten und angeschlossenen Eingabegeräte werden aufgelistet.

Geräteauflistung ForceFeedback IncludeHidden IncludePhantoms IncludeAliases

365

Nur Geräte mit Force-Feedback-Unterstützung werden aufgelistet. Versteckte Geräte. Diese Geräte werden im Regelfall durch einen Treiber generiert. So können z.B. Keyboard- und Mausereignisse ausgelöst werden. Hiermit sind Platzhalter gemeint. Das Gerät ist ein Duplikat eines anderen.

Die Konstanten sind kombinierbar. So ist es möglich, eine spezifische Gruppe zu ermitteln. Falls Sie die Konstanten kombinieren möchten, sollten Sie genau auf den Sinn der Kombination achten. Wenn Sie AllDevices mit ForceFeedback kombinierten, wäre das unsinnig, denn ForceFeedback ist in AllDevices enthalten. Sie können ForceFeedback mit AttachedOnly kombinieren, so erhalten Sie eine Auflistung aller angeschlossenen Force-Feedback-Geräte. 35.2.3 Objekte ermitteln Zum Ermitteln der Device-Objekte benötigen wir eine GUID (Global Unique Identifier). Diese haben wir bereits bei der Auflistung der zur Verfügung stehenden Geräte ermittelt. Mit der GUID deklarieren wir die Variable DIDevice. 1

Dim DIDevice As New DirectInput.Device _ (DIDeviceInstance.InstanceGuid)

Anschließend können wir uns für dieses Eingabegerät die verfügbaren Objekte auflisten lassen. 1 2 3

4 5

Dim DIObject As New DirectInput.DeviceObjectInstance Dim DIObjectList As DirectInput.DeviceObjectList For Each DIObject In DIDevice.GetObjects_ (DirectInput.DeviceObjectTypeFlags.All) ListBox2.Items.Add(DIObject.Name) Next

In Zeile 3 nutzen wir die Methode GetObjects(). Sie liefert ein Array vom Typ DirectInput.DeviceObjectList(). Je nachdem, welchen Parameter wir der GetObject()-Methode übergeben, erhalten wir entweder eine Auswahl oder eine komplette Liste der Objekte.

366

DirectInput

Tabelle 15. DeviceObjectTypFlag) Konstante AbsAxis Alias All Axis Button Collection EnumCollection(n) FFactuator NoData Output Pov PSHButton

Relaxis TGLButton

VendorDefined

Beschreibung Absolute Achsen werden aufgelistet Kontrollen von einem Human Interface Device (HID), welches ein Alias verwenden. Alle Objekte Absolute und relative Achsen werden aufgelistet. Alle Tasten werden aufgelistet Eine Gruppierung eines HID-Devices Eine Auflistung einer Gruppierung eines HIDDevices. Der Parameter n identifiziert die Gruppierung. Objekte, welche als Auslöser für einen ForceFeedback-Effekt genutzt werden können. Objekte, welche keine Daten generieren. Objekte, welche Output unterstützen. Point-of-View-Controller Hiermit werden Taster gekennzeichnet. Taster sind Tasten, welche ein Ereignis melden, wenn sie gedrückt werden, und ein neues Ereignis melden, wenn sie losgelassen werden. Relative Achsen werden aufgelistet Eine Toggle-Taste löst ein Ereignis aus, wenn sie gedrückt wird. Dann ist sie als gedrückt gekennzeichnet und behält diesen Status, bis die Taste ein zweites Mal gedrückt wird. Ein Objekt, dessen Typ vom Hersteller spezifiziert wird. Solch ein Objekt ist in der Regel nicht in eine Standardkategorie einzuordnen.

Natürlich ist es für uns wichtig, zu wissen, mit welchen Geräten wir es zu tun haben. Dennoch ist es legitim, gewisse Annahmen zu treffen und diese nicht explizit zu überprüfen. Wenn z.B. eine Maus vorhanden ist, dann können wir annehmen, dass zumindest zwei Tasten und zwei Achsen vorhanden sind. Je mehr wir uns aber in die exotischen Bereiche vorwagen, desto genauer müssen wir die Fähigkeiten der Eingabegeräte prüfen. Sollten Sie solche Geräte unterstützen wollen, dann muss Ihnen bewusst sein, dass Sie zusätzlichen Sourcecode erstellen müssen: Sourcecode für ein Standardgerät und für das exotische Gerät.

Kooperationsebene

367

35.3 Kooperationsebene Mit der Kooperationsebene (CooperativeLevel) ist das Nutzungsrecht des Eingabegerätes gemeint. Hier entscheidet man hauptsächlich darüber, ob das Eingabegerät exklusiv für die eigene Anwendung zur Verfügung stehen soll oder ob es mit anderen Anwendungen geteilt wird. Mit der Exklusivität in einer Multitasking-Umgebung ist das so eine Sache. Einerseits ist es vorteilhaft, wenn wir das Eingabegerät für uns allein haben. Andererseits blockieren wir das Arbeiten an unterschiedlichen Applikationen. Tabelle 16. CooperativeLevelFlag Konstante Foreground Background

Exclusive NonExclusive NoWindowsKey

Beschreibung Die Applikation empfängt nur Daten vom Eingabegerät, wenn die Applikation den Focus hat. Unabhängig davon, welche Applikation den Focus hat, empfängt das Programm Eingabedaten. So kann es passieren, dass im Vordergrund an der Textverarbeitung gearbeitet wird und im Hintergrund die DirectX-Anwendung gesteuert wird. Die Applikation besitzt die exklusive Kontrolle über das Eingabegerät. Die Applikation besitzt keine exklusive Kontrolle über das Eingabegerät. Die Applikation reagiert nicht auf die Windowstaste. Dies ist eine hilfreiche Erweiterung für den Spieleprogrammierer. Immerhin kann das zufällige Drücken der Windowstaste ignoriert werde. Die Deaktivierung der Windowstaste ist nur in der Kombination mit Foreground und NonExclusive erlaubt.

Die Kooperationsebene wird an das Applikationshandle gebunden. Hierzu nutzen wir die Methode SetCooperativeLevel(). Die Methode beinhaltet zwei Parameter: das besagte Ausgabehandle der Applikation. und das CooperativeLevelFlag. 1

2 3

4

Dim DIDevice As New DirectInput.Device _ (DIDeviceInstance.InstanceGuid) Dim CoopFlags As CooperativeLevelFlags CoopFlags = CooperativeLevelFlags.NonExclusive Or _ CooperativeLevelFlags.Foreground Or _ CooperativeLevelFlags.NoWindowsKey DIDevice.SetCooperativLevel(Me, CoopFlags)

368

DirectInput

In Zeile 1 erstellen wir das DirectInput.Device. In Zeile 2 wird die Variable CoopFlags deklariert und in Zeile 3 wird die Kooperationsebene kombiniert. Zum Abschluss wird in Zeile 4 mit Hilfe der SetCooperativLevel()-Methode die Kooperationsebene zugewiesen.

35.4 Datenformat Daten zu empfangen ist eine Sache, diese Daten zu interpretieren, eine andere. Was nutzen einem viele Daten, wenn man nichts damit anfangen kann. Auf dem Markt sind eine Vielzahl unterschiedlichster Eingabegeräte zu erwerben. Theoretisch können diese auch unterschiedlichste Datenblöcke senden. Hierzu bietet DirectX die Möglichkeit, selbst definierte Datenformate zu integrieren. Die Praxis sieht so aus, dass die gängigen Eingabegeräte sich an festen Regeln orientieren. Hierzu bietet DirectX vordefinierte Datenformate an. Zur Auswahl stehen: • DeviceDataFormat.Joystick • DeviceDataFormat.Keyboard • DeviceDataFormat.Mouse Über die SetDataFormat()-Methode weisen wir das gewünschte Datenformat zu. 1

DIDevice.SetDataFormat(DeviceDataFormat.Keyboard)

Der einzige Parameter der SetDataFormat()-Methode ist eine Konstante aus der DeviceDataFormat-Auflistung.

35.5 Daten empfangen Nun ist es soweit. Wir wollen versuchen Daten von einem Eingabegerät zu empfangen. Hierzu müssen wir dem Eingabegerät mitteilen, dass wir es nun als Datenquelle benötigen. Hierzu können wir die Acquire() Methode verwenden. Die Methode besitzt keine Parameter. 1

DIDevice.Acquire()

Nun können wir Daten des Eingabegerätes abfragen. An dieser Stelle werden wir das am Beispiel des Keyboards tun. Weitere Methoden können Sie

Keyboard (Beispielprogramm)

369

den Beispielen entnehmen. Hierzu bevorzugen wir die GetCurrentKeyboardState()-Methode. Sie ist unkompliziert und fragt den aktuellen Keyboardstatus ab. 1

DIDevice.GetCurrentKeyboardState.Item(Key.A)

Mit dieser Befehlszeile wird geprüft, ob die Taste A in diesem Moment gedrückt ist. Ist das der Fall, können Sie als Programmierer entsprechend reagieren, z.B. den Autopiloten aktivieren.

35.6 Keyboard (Beispielprogramm) Im Folgenden werden wir Ihnen ein und dieselbe Technik mit zwei unterschiedlichen Sourcecodes präsentieren. Unser Ziel ist es, die Tastatur abzufragen. In der Theorie ist das eine absolut simple Angelegenheit. Hierzu benötigen wir nur wenige Zeilen. Sehen wir uns dazu das Sourcecode-Beispiel 1 an:

35.6.1 Sourcecode-Beispiel 1 1 2

3

4 5 6 7 8

Private DIDevice as DirectInput.Device DiDevice = New DirecInput.Device _ (DirectInput.SystemGuid.Keyboard) DIDevice.SetCooperativeLevel(Me, _ CooperativeLevelFlags.Foreground or _ CooperativeLevelFlags.NonExclusive) DIDevice.SetDataFormat(DeviceDataFormat.Keyboard) DiDevice.Acquire() If DIDevice.GetCurrentKeyboardState.Item(Key.A) Then ‘*** activate autopilot End If

Wie Sie sehen, benötigen wir nur wenige Programmzeilen, um die Tastatur abzufragen. Die Sache hat einen Haken. Dieser Sourcecode ist fehleranfällig. Es fehlt leider die Fehlerbehandlung. Deshalb haben wir den Sourcecode erweitert. Dadurch ist er weniger übersichtlich.

370

DirectInput

35.6.2 Sourcecode-Beispiel 2

Abb. 95. Beispielprogramm für Keyboard

Die To-do-Liste für dieses Demoprogramm umfasset: • • • • •

Variablen deklarieren Kooperationsebene festlegen Device erzeugen Daten empfangen Device zerstören und den Speicher frei geben

34.6.2.1 Variablen deklarieren Wir wollen lediglich die Tastatur abfragen. Hierzu treffen wir die Annahme, dass nur eine Tastatur angeschlossen ist. Wenn Sie zusätzliche Tastaturen wie einen extra 10er Block oder spezielle Tastaturen für spezielle Anwendungen angeschlossen haben, sollten Sie auf eine Standardtastatur umstellen. Betrachten wir nun die benötigten Variablen:

Keyboard (Beispielprogramm) 1 2 3

4

371

Public DIDevice As DirectInput.Device Public CoopFlags As DirectInput.CooperativeLevelFlags Public KeyboardState As _ DirectInput.KeyboardState = Nothing Public k As DirectInput.Key

Natürlich benötigen wir eine Variable vom Typ DirectInput.Device. Diese nimmt die Tastatur auf und wir können mit dem Gerät arbeiten. Des Weiteren benötigen wir die Variable CoopFlags. Diese ist vom Datentyp CopperativeLevelFlags und legt die Kooperationsebene fest. Die Variable KeyboardState erfasst den aktuellen Keyboardstatus. Das heißt, sie erfasst, welche Tasten gedrückt sind. Da wir den Status jeder Taste einzeln abfragen müssen, benötigen wir die Variable k. Diese steht für jede einzelne Taste. 34.6.2.2 Kooperationsebene festlegen Die Kooperationsebene soll dynamisch erstellt werden. Hierzu sind Benutzereingaben notwendig. Betrachten Sie die GUI des Beispielprogramms und Sie erkennen die Auswahlmöglichkeiten im oberen Teil der GUI. 1 2

3

4

5

6

CoopFlags = Nothing If radForeground.Checked Then CoopFlags = CoopFlags Or DirectInput. CooperativeLevelFlags.Foreground If radBackground.Checked Then CoopFlags = _ CoopFlags Or DirectInput._ CooperativeLevelFlags.Background If radExclusive.Checked Then CoopFlags = _ CoopFlags Or DirectInput. _ CooperativeLevelFlags.Exclusive If radNoneExclusive.Checked Then CoopFlags = _ CoopFlags Or DirecInput. _ CooperativeLevelFlags.NonExclusive If chkNoneWindowsKey.Checked Then CoopFlags = _ CoopFlags Or DirectInput. _ CooperativeLevelFlags.NoWindowsKey

Zuerst löschen wir die Variable CoopFlags. Anschließend prüfen wir, ob eine spezifische Kooperationseigenschaft gesetzt ist. Ist das der Fall, verknüpfen wir den neuen Wert mit dem vorhandenen CoopFlags. An dieser Stelle machen wir einen kleinen Exkurs zur binären ORVerknüpfung. Den einzelnen Konstanten aus der CooperativeLevelFlags-Auflistung sind feste Werte zugewiesen (siehe Tabelle 17).

372

DirectInput

Tabelle 17. CooperativeLevelFlags Konstante Exclusive NonExclusive Foreground Background NoWindowsKey

Dezimal 1 2 4 8 16

Binär 00001 00010 00100 01000 10000

Betrachten wir nun, was passiert, wenn wir z.B. NonExclusive und Foreground miteinander verknüpfen. NonExclusive 2 010 Foreground 4 100 Ergebnis 6 110

Wir erhalten das Ergebnis 6 (110). Durch die Zuweisung der festen Werte kann das Ergebnis niemals mit dem Wert eines der Mitglieder identisch sein. Egal welche Mitglieder der CooperativeLevelFlags-Auflistung Sie verknüpfen, das Ergebnis wird immer ein anderes sein. Dementsprechend beinhaltet das Ergebnis auch eine starke Aussagekraft. In unserem Fall besagt es, dass wir NonExclusive und Foreground verwenden wollen. Diese Kombination mit dem Wert 6 ist einzigartig und dieser Wert kann durch keine andere Kombination erreicht werden. 34.6.2.3 Device erzeugen Nachdem wir die Zusammenarbeit geregelt haben, können wir das Eingabegerät als DirectInput.Device erzeugen. 1

2 3

DIDevice = _New DirectInput.Device _ (DirectInput.SystemGuid.Keyboard) DIDevice.SetCooperativeLevel(Me, CoopFlags) DIDevice.SetDataFormat _ (DirectInput.DeviceDataFormat.Keyboard)

Um das Device zu erzeugen, benötigen wir die GUID (Gloabal Unique Identifier)des gewünschten Gerätes. Diese haben wir aber nicht ermittelt. Eigentlich können wir das Device jetzt nicht erstellen. Dennoch bietet DirectX eine Lösung an. Wir haben erklärt, dass es legitim sei, gewisse Annahmen zu treffen. Solch eine Annahme trifft auch DirectX. Es wird uns über die SystemGuid-Auflistung die GUID für das Defaultkeyboard angeboten. Damit dieses funktioniert, nimmt man an, dass es nur ein Keyboard gibt. Nachdem wir das Device erstellt haben, regeln wir die

Keyboard (Beispielprogramm)

373

Kooperationsebene mit der SetCooperativeLevel()-Methode. Die benötigten Flags haben wir bereits festgelegt. Anschließend setzen wir das voreingestellte Datenformat für ein Keyboard. Das ist ein Standardformat aus der DeviceDataFormat-Auflistung. 34.6.2.4 Daten empfangen Im Sourcecode-Beispiel 1 haben wir demonstriert, wie einfach der Datenempfang sein kann. Leider war diese Technik nicht auf alle Eventualitäten der Programmierung gewappnet. Die neue Technik ist wesentlich besser vorbereitet. 1 2 3 4 5 6

7 8 9 10 11 12 13 14 15 16 17 18 19

20 21

22 23 24

25 26 27 28 29

Sub GetData() Dim ie As DirectInput.InputException = Nothing Try KeyboardState = DIDevice.GetCurrentKeyboardState() ListBox1.Items.Clear() For k = DirectInput.Key.Escape To _ DirectInput.Key.MediaSelect If KeyboardState(k) Then ListBox1.Items.Add(k.ToString) End If Select Case k Case DirectInput.Key.Escape If KeyboardState(k) Then Run = False End Select Next Catch Try DIDevice.Acquire() Label2.Text = "Acquired" Catch inputException As _ DirectInput.InputException ie = inputException If TypeOf ie Is _ DirectInput.OtherApplicationHasPriorityException _ Or TypeOf ie Is _ DirectInput.NotAcquiredException Then Label2.Text = "UnAcquired" ElseIf Not ie Is Nothing Then MessageBox.Show("Unable to acquire the _ device. Application will now exit.") End End If End Try End Try End Sub

374

DirectInput

Es ist nicht notwendig, die Routine im Detail zu besprechen. Uns ist wichtiger, auf die grundsätzliche Struktur hinzuweisen. Wir haben zwei ineinander verschachteltete Try-Catch-Anweisungen. Im ersten TryAbschnitt versuchen wir, Daten zu empfangen. Sollte dies scheitern, versuchen wir, das Gerät erneut zu akquirieren. Ist auch dies nicht möglich, wird das Programm beendet. Hierbei unterscheiden wir aber die Ursache. Sollte das erneute Akquirieren des Eingabegerätes scheitern, weil das Programm den Focus verlor, belassen wir es bei einem einfachen Hinweis. Alle anderen Gründe veranlassen die Beendigung des Programms. 34.6.2.5 Device zerstören und den Speicher freigeben Wir sind ordentliche Programmierer und räumen nach erfolgter Arbeit auf. Hierbei wollen wir die Eingabegeräte aus unseren Diensten entbinden. Dies geschieht mit einem kleinen Dreireiher. In der Routine UnAcquire(), welche unter anderem beim Schließen des Fensters aufgerufen wird, finden wir folgende Befehle: 1 2 3

DIDevice.Unacquire() DIDevice.Dispose() DIDevice = Nothing

Hiermit ist das Eingabegerät wieder frei.

35.7 Maus Das Abfragen der Maus wollen wir im Schnelldurchgang betreiben. Es kommen hauptsächlich die gleichen Techniken zum Einsatz, welche uns aus dem Keyboard-Beispielprogramm bekannt sind. Bei der Maus begnügen wir uns mit einer Standardmaus mit drei Tasten und drei Achsen, also eine Standardmaus mit Rad. Falls Sie eine andere Maus verwenden, müssen Sie das Beispielprogramm gegebenenfalls anpassen.

Maus

375

Abb. 96. Beispielprogramm für Maus

Wie DirectX mit dem Eingabegerät Maus umgeht, wollen wir uns direkt an einem Beispielprogramm ansehen. Den Sourcecode finden Sie auf der CD. Er ist klein und übersichtlich gestaltet und kann leicht erweitert werden. Wir brauchen folgende Voraussetzungen für das Mausdemo: • Kooperationsebene anlegen und das Device erzeugen • Daten abfragen

35.7.1 Kooperationsebene anlegen und das Device erzeugen In der Subroutine Acquire() bestimmen wir die Kooperationsebene und erzeugen das DirectInput-Device. 1 2 3

4

5 6

7 8

Sub Acquire() CoopFlags = Nothing CoopFlags = _ DirectInput.CooperativeLevelFlags.Foreground Or _ DirectInput.CooperativeLevelFlags.NonExclusive DIDevice = _ New DirectInput.Device(DirectInput.SystemGuid.Mouse) DIDevice.SetCooperativeLevel(Me, CoopFlags) DIDevice.SetDataFormat _ (DirectInput.DeviceDataFormat.Mouse) DIDevice.Acquire() End Sub

376

DirectInput

Diesmal darf der Anwender die Kooperationsebene nicht auswählen und wir bestimmen die Werte CooperativeLevelFlags.Foreground und CooperativeLevelFlags.NonExclusive. Selbstverständlich dürfen Sie als Programmierer diese Werte modifizieren, aber dies sollten Sie mit Bedacht tun. Berücksichtigen Sie, dass, wenn Sie den Wert NonExclusive auf Exclusive ändern, die Maus nur noch Ihrer Applikation zur Verfügung steht. Sie dürfen dann nicht einmal mehr den Schließen-Butten des Fensters anklicken. Falls Sie keine anderen Vorkehrungen (z.B. Tastatureingaben) zum Beenden des Programms getroffen haben, bleibt Ihnen nur noch der Weg über den Taskmanager. Genau wie beim Keyboard-Beispielprogramm können wir eine System.Guid zum Erstellen des DirectInput-Device verwenden. Das benötigte Datenformat ziehen wir ebenfalls aus einer vordefinierten Konstante. 35.7.2 Daten abfragen Das Abfragen bzw. das Empfangen der Mausdaten gestaltet sich ein wenig anders als beim Keyboard-Beispielprogramm. Der Hauptunterschied liegt darin, dass wir diesmal zwei Objekte haben, welche die geforderten Daten liefern. Zum einen benötigen wir den Status der Maustasten und zum anderen wollen wir Informationen über die Achsen. 1 2 3 4 5 6

7

8

9

10

11

12 13 14 15

Sub GetData() Dim ie As DirectInput.InputException = Nothing Try Dim MouseState As New DirectInput.MouseState MouseState = DIDevice.CurrentMouseState Dim MouseButtons() As Byte = _ DIDevice.CurrentMouseState.GetMouseButtons() If MouseButtons(0) Then Label4.Text = _ "pressed" Else Label4.Text = "not pressed" If MouseButtons(1) Then Label5.Text = _ "pressed" Else Label5.Text = "not pressed" If MouseButtons(2) Then Label6.Text = _ "pressed" Else Label6.Text = "not pressed" If 0 (MouseState.X Or MouseState.Y Or _ MouseState.Z) Then ListBox1.Items.Add _ (MouseState.X.ToString() + ", " + _ MouseState.Y.ToString() + ", " + _ MouseState.Z.ToString()) If ListBox1.Items.Count > 8 Then ListBox1.Items.RemoveAt(0) End If ListBox1.SelectedIndex = ListBox1.Items.Count - 1

Joystick 16 17 18 19 20 21 22 23

24 25 26

27 28 29 30 31

377

End If Label9.Text = "Acquire" Catch Try DIDevice.Acquire() Catch inputException As DirectInput.InputException ie = inputException If TypeOf ie Is _ DirectInput.OtherApplicationHasPriorityException _ Or TypeOf ie Is _ DirectInput.NotAcquiredException Then Label9.Text = "UnAcquire" ElseIf Not ie Is Nothing Then MessageBox.Show("Unable to acquire the _ device.Application will now exit.") End End If End Try End Try End Sub

Um eine sichere Handhabung zu gewährleisten, haben wir wieder eine verschachtelte Try-Catch-Anweisung verwendet. In Zeile 6 füllen wir das Array MouseButtons() mit den Statusinformationen der Maustasten. Diese werden in den Zeilen 7 - 9 ausgewertet. Je nachdem, welcher Status ermittelt wird, ist in der GUI entweder pressed oder not pressed zu lesen. Die Informationen über die Mausachsen ermitteln wir aus der Variablen MouseState. Diese haben wir in Zeile 5 initialisiert. Die Auswertung erfolgt in der Zeile 11. Über MouseState.X, MouseState.Y und MouseState.Z erhalten wir die relative Veränderung angezeigt. Das scheint anfangs etwas seltsam. Könnten wir nicht viel besser mit absoluten Koordinaten arbeiten? Die Antwort lautet ganz klar „Nein“. Nehmen wir ein normales Spiel. Sie wollen die Laufrichtung des Spielers mit der Maus bestimmen. Hierzu benötigen Sie die Information, um wie viel Grad sich der Spieler drehen soll. Hier helfen nur Informationen, welche relativ zur alten Position Auskunft geben.

35.8 Joystick Für die Maus und für die Tastatur konnten wir jeweils eine System.Guid beziehen. Wenn wir einen Joystick verwenden wollen, müssen wir die entsprechende Joystick.Guid selber ermitteln. Das liegt zum einen daran, dass ein Joystick nicht zur den zwingend benötigten Eingabegeräten gehört, und zum anderen, dass eine große Vielfalt unterschied-

378

DirectInput

lichster Joysticks existiert. Auch bei diesem Beispielprogramm wollen wir nicht ins Detail gehen. Im Grunde funktioniert der Zugriff auf einen Joystick wie der Zugriff auf die Maus oder Tastatur. Dennoch gibt es feine Unterschiede und diese wollen wir erläutern.

Abb. 97. Beispielprogramm für Joystick

To-do-Liste: • Angeschlossene Joysticks ermitteln • Akquirieren und Achseneigenschaften festlegen • Daten abfragen

Joystick

379

35.8.1 Angeschlossene Joysticks ermitteln Wir wissen nicht, ob oder wie viele Joysticks angeschlossen sind. Deshalb ist es zwingend erforderlich, die angeschlossenen Geräte zu ermitteln. Das Prinzip haben Sie im Abschnitt der Geräteauflistung kennen gelernt. Jetzt wollen wir uns auf das Ermitteln der Joysticks konzentrieren. 1 2 3 4 5 6

7 8 9 10 11 12

Sub EnumDevice() Dim i As Integer = 0 Dim f As DirectInput.DeviceInstance ReDim DIDeviceArray(DirectInput.Manager.Devices.Count) Dim instance As DirectInput.SemanticsInstance For Each f In DirectInput.Manager.GetDevices _ (DirectInput.DeviceClass.GameControl, _ DirectInput.EnumDevicesFlags.AttachedOnly) DIDeviceArray(i) = f ComboBox1.Items.Add(f.ProductName) i += 1 Next ComboBox1.Text = DIDeviceArray(0).ProductName End Sub

In Zeile 6 verwenden wir die GetDevices()-Methode. Diese ist uns zwar bekannt, dennoch sind die verwendeten Parameter neu. Wie wir wissen, benötigt diese Methode zwei Parameter. Der erste Parameter legt die Geräteklasse (Gerätetyp) fest. Da wir nur die Joysticks (Game-Controller) abfragen wollen, verwenden wir den Wert DeviceClass.GameControl. Allein an der Namensgebung erkennen Sie, welche Art von Eingabegeräten gemeint ist. Der zweite Parameter ist das so genannte DeviceFlag. DirectInput.EnumDevicesFlags.AttachedOnly garantiert uns, dass wir nur Geräte angezeigt bekommen, welche auch angeschlossen sind. Das ist wichtig, denn DirectX unterscheidet sehr wohl, ob ein Gerät lediglich installiert ist oder ob ein Gerät wirklich mit dem Computer verbunden ist. Aber wir dürfen nicht den eigentlichen Zweck vergessen, warum wir die Geräte überhaupt ermitteln. Wenn wir im nächsten Schritt das Eingabegerät erstellen wollen, benötigen wir die GUID von diesem Gerät. Damit diese nicht verloren geht, speichern wir sie in Zeile 7 im Array DeviceArray().

380

DirectInput

35.8.2 Akquirieren und Achseneigenschaften festlegen 1 2 3

4

5 6

7

8 9

10

11 12 13 14

Sub Acquire(ByVal Index As Integer) CoopFlags = Nothing CoopFlags = DirectInput.CooperativeLevelFlags.Foreground Or DirectInput.CooperativeLevelFlags.NonExclusive DIDevice = New _ DirectInput.Device(DIDeviceArray(Index).InstanceGuid) DIDevice.SetCooperativeLevel(Me, CoopFlags) DIDevice.SetDataFormat _ (DirectInput.DeviceDataFormat.Joystick) Dim DIDeviceObjectList As _ DirectInput.DeviceObjectInstance For Each DIDeviceObjectList In DIDevice.Objects If 0 (DIDeviceObjectList.ObjectId And _ CInt(DirectInput.DeviceObjectTypeFlags.Axis)) _ Then DIDevice.Properties.SetRange _ (DirectInput.ParameterHow.ById, DIDeviceObject List.ObjectId, New _ DirectInput.InputRange(-1000, +1000)) End If Next DIDeviceObjectList DIDevice.Acquire() End Sub

Die Kooperationsebene und das Zuweisen des passenden Datenformats sind für uns keine Unbekannten mehr. In Zeile 6 setzen wir das passende Datenformat. Hierzu können wir auf eine Systemkomponente zurückgreifen. Mit DirectInput.DeviceDataFormat.Joystick kann DirectX die empfangenen Daten richtig interpretieren. In den Zeilen 8 – 12 finden wir eine interessante Sache. Wir begrenzen den Wertebereich der Joystickachsen auf –1000 bis +1000. Dies ist eine wirklich hilfreiche Funktion. Wenn wir ein Programm entwickeln, dann müssen wir uns keine Gedanken darüber machen, welchen Wertebereich irgendein Joystick beim User hat. Egal welcher Joystick zum Einsatz kommt, wir können ihn perfekt auswerten und sein Wertebereich wird auf den von uns festgelegten Bereich skaliert. Bei einer Joysticktaste sind solche Vorgaben nicht notwendig. Entweder ist eine Taste gedrückt oder nicht. 35.8.3 Daten abfragen Das Abfragen der Joystickdaten ist in der Subroutine GetData() untergebracht. Diese ist recht lang, aber nicht sonderlich kompliziert. Auf eine komplette Darstellung verzichten wir hier im Buch. Natürlich finden Sie

Joystick

381

den kompletten Sourcecode auf unserer Buch-CD. Wichtig ist es, wie die einzelnen Objekte abgefragt werden können. Abfragen der Achsen Die Achsen müssen wir in zwei Kategorien unterteilen. Die eine Kategorie sind die Bewegungsachsen. Damit sind die X-, Y- und Z-Achse gemeint. Wenn diese Achsen betätigt werden, wird normalerweise die Spielfigur, das Auto oder das Flugzeug bewegt. 1

JoystickState = DIDevice.CurrentJoystickState

2

Label4.Text = JoystickState.X Label5.Text = JoystickState.Y Label6.Text = JoystickState.Z

3 4

Des Weiteren müssen wir die Rotationsachsen berücksichtigen. Es gibt nicht viele Joysticks, welche Rotationsachsen verwenden. Wenn eine Achse unterstützt wird, dann oftmals die Z-Achse. Diese wird z.B. zum Rollen bei Flugzeugen verwendet. 1 2 3

Label15.Text = JoystickState.Rx Label18.Text = JoystickState.Ry Label21.Text = JoystickState.Rz

Abfragen des Point of View Sollten Sie einen Joystick mit einem Point of View verwenden, dann werden Sie sich über die gelieferten Werte wundern. Ein Point of View liefert den eigenen Zustand anhand einer Zahl wieder. Wobei eine Ausrichtung nach Norden den Wert 0 hat. Eine Ausrichtung nach Osten würde durch den Wert 9000 wiedergegeben.

Abb. 98. Point of View

382

DirectInput

Der Sourcecode für die Abfrage des Point of View lautet folgendermaßen: 1

Dim pov As Integer() = JoystickState.GetPointOfView()

2

Label10.Text Label11.Text Label12.Text Label13.Text

3 4 5

= = = =

pov(0).ToString() pov(1).ToString() pov(2).ToString() pov(3).ToString()

Abfragen von Slidern / Schiebereglern Slider liefern analoge Wert und unterliegen einer möglichen Achsenbeschränkung. Sie verhalten sich wie normale Achsen und sind einfach abzufragen. 1

Dim slider As Integer() = JoystickState.GetSlider()

2

Label16.Text = slider(0).ToString() Label17.Text = slider(1).ToString()

3

Buttons Beim Auswerten der Joysticktasten besteht die Schwierigkeit, dass wir nicht wissen, wie viele Tasten der Joystick hat. Leider können wir auch nicht auf eine Joysticktaste direkt zugreifen, sondern müssen immer den gesamten Tastenblock abfragen. Um festzustellen, welche Tasten gedrückt sind, müssen wir den gesamten Tastenblock durchforsten. 1 2 3 4 5 6 7 8 9 10 11 12 13

Dim buttons As Byte() = JoystickState.GetButtons() Dim button As Integer = 0 Dim b As Byte For Each b In buttons If 0 (b And &H80) Then Select Case button Case 0 CheckBox1.Checked = True Case 1 CheckBox2.Checked = True . . .

Die Abfrage der Joysticktasten haben wir hier nur angedeutet. Das komplette Listing entnehmen Sie dem Beispielprogramm auf der CD.

First-Person-Camera

383

35.9 First-Person-Camera Eine der beliebtesten Kameraperspektiven ist die First-Person-Camera. Diese ist auch als Ich- oder Ego-Perspektive bekannt. Bei dieser Perspektive betrachtet der Spieler die 3D-Szene aus Sicht der Spielfigur. Hierdurch wird der Spieler in das Geschehen des Spiels gezogen. Die First-PersonCamera wird bei Ego-Shootern genauso verwendet wie bei rasanten Rennsimulationen. Sie ist immer geeignet, wenn der Spieler noch vor der ersten Reihe sitzen soll – also mitten im Geschehen. Üblicherweise werden die Laufbewegungen mit den Tasten W, A, S und D gesteuert und die Blickrichtung oder Laufrichtung per Maus koordiniert. In unserem Beispielprogramm werden wir sowohl eine Tastatur als auche eine Maus einrichten. Mit der Maus bestimmen wir die Laufrichtung sowie die Blickhöhe. Mit den Tasten „W“ und „S“ können wir uns vorwärts bzw. rückwärts bewegen. Mit den Tasten „A“ und „D“ bewegen wir uns seitwärts.

Abb. 99. First-Person-Camera-Screenshot

To-do-Liste: • Variablen und Strukturen definieren • Erzeugen der DirectInput-Devices

384

DirectInput

• Maus- und Tastaturdaten empfangen • Maus- und Tastaturdaten auswerten 35.9.1 Variablen und Strukturen definieren Mit der First-Person-Camera betrachten wir die 3D-Welt aus der EgoPerspektive. Das bedeutet, dass wir mit Hilfe der Maus oder Tastatur eine Spielfigur bewegen. Außerdem können wir noch den Kopf der Spielfigur steuern. Hierzu haben wir zwei Strukturen erstellt, welche alle relevanten Daten aufnehmen werden.

7

Structure cSpeed Dim Forward As Double Dim Backward As Double Dim Left_Right As Double Dim TurnHor As Double Dim TurnVer As Double End Structure

8

Public Speed As cSpeed

1 2 3 4 5 6

Bei diesem Demo ist die Geschwindigkeit ein entscheidender Faktor. Es ist unabdingbar, dass die Spielfigur auf unterschiedlichen Computersystemen immer gleich schnell läuft. Auf leistungsstarken Systemen wird die Bewegung sehr sauber und ruckelfrei sein. Langsame Systeme werden dagegen das Bild nur stockend darstellen können. Beide Fälle sind für uns nicht weiter von Bedeutung. Wichtig ist, dass die Spielfigur immer gleich schnell ist. Die einzelnen Geschwindigkeiten für die verschiedenen Bewegungsmöglichkeiten werden in der Variablen Speed gespeichert. Diese ist vom Datentyp cSpeed. Die Zuweisung der Geschwindigkeit ist von der benötigten Zeit pro Frame (Render-Zyklus) abhängig. Sehen Sie selbst: 1 2

3 4 5 6

Sub CalcSpeed() ElapsedTime = _ DXTimer.Timer(DXTimer.DirectXTimer.GetElapsedTime) Speed.Forward = 100 * ElapsedTime Speed.Backward = 100 * ElapsedTime Speed.Left_Right = 100 * ElapsedTime End Sub

Wenn Sie wollen, können Sie den Bewegungen unterschiedliche Geschwindigkeiten zuweisen. Realistischer wäre es, wenn die Rückwärtsbewegung langsamer als die Vorwärtsbewegung wäre. Leider verliert die Bewegung dann an Dynamik. Jetzt fehlen nur noch die Geschwindigkeit

First-Person-Camera

385

für die Drehbewegung des Spielers und die Geschwindigkeit zum Neigen bzw. Heben des Kopfes. Beide Geschwindigkeiten werden mit der Maus gesteuert. Das vereinfacht die Angelegenheit, denn die Bewegungsgeschwindigkeit der Maus ist nicht von der Computergeschwindigkeit abhängig. Je nachdem, wie schnell der Anwender die Maus bewegt, dreht sich die Spielfigur schnell oder langsam. Wir müssen lediglich noch für eine passende Mausempfindlichkeit sorgen. 1 2

Speed.TurnHor = 7 Speed.TurnVer = 7

Sieben hat sich als ein angenehmer Wert herausgestellt. Dieser Wert wird später als Teiler verwendet und reduziert die von der Maus gelieferten Werte. Ohne diese kleine Anpassung wäre eine vernünftige Steuerung schier unmöglich. Kleinere Werte beschleunigen die Bewegung und entsprechend wird die Bewegung bei größeren Werten langsamer. Nun schauen wir uns die cFirstPerson-Struktur an. Sie bildet das Grundgerüst des gesamten Programms.

7

Structure cFirstPerson Dim Position As DirectX.Vector3 Dim View As DirectX.Vector3 Dim TurnHor As Double Dim TurnVer As Double Dim Direction As Integer End Structure

8

Public FP As cFirstPerson

1 2 3 4 5 6

Die eigentlich Steuerung der Spielfigur übernimmt die Variable FP (FirstPerson). Diese ist vom Datentyp cFirstPerson. Die Variable Position nimmt die aktuelle Position des Spielers auf. Unter View wird die Blickrichtung und Kopfneigung gespeichert. TurnHor und TurnVer enthalten die aktuellen Winkel der horizontalen und vertikalen Achse. Direction speichert die Laufrichtung des Spielers. Genau genommen wird gespeichert, welche Taste gedrückt wurde. Diese Variable ist kombinierbar. Es ist also erlaubt, den Wert für Vorwärts zu dem Wert für Links zu addieren. Dies würde eine Diagonale ergeben. 35.9.2 Erzeugen der DirectInput-Devices Wir benötigen zwei Eingabegeräte. Diese können wir nach altbekanntem Schema erstellen.

386 1 2 3

4

5

6

7 8

9 10 11

12

13

14

15 16

DirectInput

Public Sub AcquireMouse(ByVal Handle As Object) CoopFlagsMouse = Nothing CoopFlagsMouse =_ DirectInput.CooperativeLevelFlags.Foreground Or_ DirectInput.CooperativeLevelFlags.Exclusive DIMouseDevice = New _DirectInput.Device _ (DirectInput.SystemGuid.Mouse) DIMouseDevice.SetCooperativeLevel _ (Handle, CoopFlagsMouse) DIMouseDevice.SetDataFormat _ (DirectInput.DeviceDataFormat.Mouse) DIMouseDevice.Acquire() End Sub Public Sub AcquireKeyboard(ByVal Handle As Object) CoopFlagsKeyboard = Nothing CoopFlagsKeyboard = _ DirectInput.CooperativeLevelFlags.Foreground Or _ DirectInput.CooperativeLevelFlags.NonExclusive DIKeyboardDevice = New _ DirectInput.Device(DirectInput.SystemGuid.Keyboard) DIKeyboardDevice.SetCooperativeLevel(Handle, _ CoopFlagsKeyboard) DIKeyboardDevice.SetDataFormat _ (DirectInput.DeviceDataFormat.Keyboard) DIKeyboardDevice.Acquire() End Sub

Wenn es hier etwas Erwähnenswertes gibt, dann die Kooperationsebene der Maus. Diesmal gewähren wir DirectX einen exklusiven Zugriff auf die Maus. Infolgedessen steht die Maus dem restlichen System nach Programmstart nicht mehr zur Verfügung. Der Vorteil ist offensichtlich. Die Maus stört nicht im Bild. Sie ist unsichtbar. Außerdem werden keine Ereignisse ausgelöst, wenn die Maus z.B. den Bildschirmrand berührt. 35.9.3 Maus- und Tastaturdaten empfangen Wir wollen nicht die gesamte Routine erläutern. Wir interessieren uns lediglich für die direkte Zuweisung der Werte. Beginnen wir mit der Tastatur. Der folgende Sourcecode stammt aus der Routine GetKeyboardData(). 1 2 3 4 5

Select Case k Case DirectInput.Key.Escape If KeyboardState(k) Then Run = False Case DirectInput.Key.W If KeyboardState(k) Then _ FP.Direction += eDirection.Foreward

First-Person-Camera 6 7

8 9

10 11

12

387

Case DirectInput.Key.S If KeyboardState(k) Then _ FP.Direction += eDirection.Backward Case DirectInput.Key.A If KeyboardState(k) Then _ FP.Direction += eDirection.Left Case DirectInput.Key.D If KeyboardState(k) Then _ FP.Direction += eDirection.Right End Select

Vorhin haben wir behauptet, dass die Variable FP.Direction kombinierbar ist. Hier erkennen Sie, was wir damit meinen. Je nachdem, welche Taste gedrückt wird, wird der Wert für die entsprechende Laufrichtung hinzuaddiert. Daraus ergibt sich ein Gesamtergebnis, welches später ausgewertet wird. Als Nächstes müssen wir die Mausdaten empfangen. Hier werden wir ebenfalls nur einen Ausschnitt aus der Sub GetMouseData() vorstellen. 1

2 3

If 0 (MouseState.X Or MouseState.Y Or_ MouseState.Z) Then FP.TurnVer += MouseState.X / Speed.TurnVer FP.TurnHor += (MouseState.Y / Speed.TurnHor)

6

If FP.TurnHor > 50 Then FP.TurnHor = 50 If FP.TurnHor < -50 Then FP.TurnHor = -50 End If

7

CalculateView()

4 5

Eigentlich müssen wir nur die beiden Achsen der Maus auswerten. Das Delta der Achsen wird mit der zuvor berechneten Geschwindigkeit multipliziert. Hierdurch erreichen wir eine einheitliche Geschwindigkeit auf unterschiedlichen Systemen. Da die Kopfneigung nur in einem bestimmten Bereich möglich ist, begrenzen wir den Wertebereich auf –50 bis +50. Mit CalculateView() rufen wir die Berechnung der neuen Spielerperspektive auf. 35.9.4 Maus- und Tastaturdaten auswerten Bisher haben wir nur Daten gesammelt. Nun müssen wir die Daten in eine Bewegung bzw. in eine Kopfbewegung umsetzen. Hierzu verwenden wir zwei Routinen. Mit der Routine CalculateMove() berechnen wir die neue Position der Spielfigur, mit CalculateView()die neue Blickrich-

388

DirectInput

tung. Damit wir die korrekte Position der Spielfigur berechnen können, müssen wir zuvor die Position ermitteln. Folglich rufen wir CalculateMove() vor CalculateView() auf. Zuerst schauen wir uns die Subroutine CalculateMove() an. 1 2 3 4

5

6

7 8 9 10

11

12

13 14 15 16

17

18

19 20 21 22

23

24

25 26 27 28

Sub CalculateMove() Dim px As Double Dim pz As Double If FP.Direction = _ (FP.Direction Or eDirection.Foreward) Then px = Math.Sin((FP.TurnVer * (Math.PI / 180))) _ * Speed.Forward pz = Math.Cos((FP.TurnVer * (Math.PI / 180))) _ * Speed.Forward FP.Position.X += px FP.Position.Z += pz End If If FP.Direction = _ (FP.Direction Or eDirection.Backward) Then px = -Math.Sin((FP.TurnVer * (Math.PI / 180))) _ * Speed.Backward pz = -Math.Cos((FP.TurnVer * (Math.PI / 180))) _ * Speed.Backward FP.Position.X += px FP.Position.Z += pz End If If FP.Direction = _ (FP.Direction Or eDirection.Left) Then px = Math.Sin((FP.TurnVer * (Math.PI / 180))) _ * Speed.Left_Right pz = -Math.Cos((FP.TurnVer * (Math.PI / 180))) _ * Speed.Left_Right FP.Position.X -= pz * -1 FP.Position.Z -= px * -1 End If If FP.Direction = _ (FP.Direction Or eDirection.Right) Then px = Math.Sin((FP.TurnVer * (Math.PI / 180))) _ * Speed.Left_Right pz = -Math.Cos((FP.TurnVer * (Math.PI / 180))) _ * Speed.Left_Right FP.Position.X += pz * -1 FP.Position.Z += px * -1 End If End Sub

Mit unserer Tastaturabfrage unterstützen wir die Tasten W, A, S und D. Diese stehen für die gewünschte Bewegungsrichtung.

First-Person-Camera W S A D

--> --> --> -->

Vorwärts Rückwärts Links Rechts

389

Zeilen: 04 - 09 Zeilen: 10 - 15 Zeilen: 16 - 21 Zeilen: 22 - 27

Je nachdem, welche Tasten gedrückt werden, fließt die entsprechende Berechnung in die neue Position ein. Um die Bewegung zu berechnen, muss die Bewegungsrichtung bekannt sein. Immer von der aktuellen Position ausgehend, gibt die Variable FP.TurnVer den Winkel vor, zu dem die Bewegung gehen soll. Der Winkel wird durch die Blickrichtung (alte Blickrichtung) bestimmt. Nachdem wir die neue Position ermittelt haben, können wir nun die neue Blickrichtung berechnen. 1

2

3

4 5 6

7

8

9

Sub CalculateView() CalculateMove() myTranslateMatrix.Translate _ (FP.Position.X * -1, FP.Position.Y * -1, _ FP.Position.Z * -1) myYMatrix.RotateY((FP.TurnVer * Math.PI / 180) * -1) myXMatrix.RotateX((FP.TurnHor * Math.PI / 180) * -1) myNewMatrix = _ DirectX.Matrix.Multiply(myTranslateMatrix, myYMatrix) View3DMatrix = _ DirectX.Matrix.Multiply(myNewMatrix, myXMatrix) D3DDevice.SetTransform _ (DirectX.Direct3D.TransformType.View, View3DMatrix) End Sub

In Zeile 2 rufen wir die Subroutine CalculateMove() auf. Diese haben wir bereits besprochen. Sie berechnet die neue Position der Spielfigur. In Zeile 3 setzen wir die neue Spielerposition. Sie ist die Ausgangsbasis, um die neue Blickrichtung des Spielers zu ermitteln. In den Zeilen 4 - 7 berechnen wir eine neue Viewm3DMatrix. Diese wird dann in Zeile 8 an DirectX übergeben.

36 DirectPlay

Ein Spiel macht am meisten Spaß, wenn man es mit Freunden spielt. Zu Hause sitzt man gemütlich in einer Runde und kann mit seinen Mitspielern reden. Es wird gelacht, diskutiert, gewürfelt oder eine Karte gespielt. Das sind für uns selbstverständliche Tätigkeiten, über die wir nicht weiter nachdenken. Schwieriger wird es, wenn sich die Mitspieler im Nebenraum oder in einer anderen Stadt befinden. Das Miteinanderreden ist unterbrochen und wir können nicht mehr zusammen spielen. Das Spiel ist aus. Das kann doch nicht sein, dass ein paar Kilometer Distanz uns vom Spielen abhalten. Immerhin leben wir in einer Zeit von Telefon, E-Mail und Internet. Wir benötigen eine Technik, mit deren Hilfe wir mit unseren Mitspielern kommunizieren können. DirectPlay ermöglicht es, auf einfache Art und Weise eine Verbindung zu seinen Mitspielern herzustellen. Wenn DirectPlay von Mitspielern (Playern) spricht, dann sind Computer gemeint. Demnach baut DirectPlay Verbindungen zwischen mehreren Computern auf. Für den Verbindungsaufbau, werden die Dienste eines Service-Providers beansprucht. Mit Hilfe des Service-Providers erstellt der Hauptcomputer (Host) eine neue Sitzung (Session). Dieser Session können sich mehrere Player anschließen. Dieses Verbindungskonzept wird als Peer-to-Peer-Verbindung bezeichnet. Nun könnte man meinen, dass es äußerst kompliziert wird, die unterschiedlichen Service-Provider anzusprechen. Jeder Service-Provider verwendet sein eigenes Protokoll und diese sind untereinander inkompatibel. DirectX verwendet dafür eine API, welche eine Art Vermittlerrolle übernimmt. Das erleichtert die Arbeit eines Programmierers ungemein, denn er muss sich nicht mehr um die Details des eingesetzten ServiceProvider-Protokolls kümmern.

392

DirectPlay

Abb. 100. Service-Provider und DirectPlay

36.1 Service-Provider Wie wir bereits wissen, müssen wir einen ServiceProvider nutzen, um eine DirectPlay-Verbindung herzustellen mit unterschiedliechen Netzwerkprotokollen. Grundsätzlich ist es möglich, mehrere Service-Provider, gleichzeitig auf einem System zu installieren. Dies ist sogar der Normalfall. So wird eine TCP/IP-Verbindung hauptsächlich für Internetverbindungen eingesetzt. Parallel hierzu können natürlich weitere ServiceProvider ihre Dienste zur Verfügung stellen. Für uns ist es wichtig, zu wissen, welche ServiceProvider auf dem aktuellen System installiert sind. Dementsprechend können wir uns dann entscheiden, welchen wir bevorzugen wollen. Betrachten wir hierzu den folgenden Sourcecode. Dieser ermittelt die verfügbaren ServiceProvider und trägt diese in eine Listbox ein. 1

2 3 4 5

Public SPInfoArray As DirectPlay.ServiceProviderInformation() = Nothing myPeer = New DirectPlay.Peer Public Sub ListServiceProvider() Try SPInfoArray = myPeer.GetServiceProviders(False)

Wie ist eine Peer-to-Peer Verbindung aufgebaut? 6 7 8 9 10 11 12 13 14 15 16 17

393

Catch ex As Exception ShowException(ex, "GetServiceProviders", True) myForm.Dispose() Return End Try Dim info As DirectPlay.ServiceProviderInformation myForm.lstServiceProvider.Items.Clear() For Each info In SPInfoArray myForm.lstServiceProvider.Items.Add(info.Name) Next info myForm.lstServiceProvider.SelectedIndex = 0 End Sub

In Zeile 2 erstellen wir ein neues DirectPlay.Peer-Objekt. Dies könnte man als Anfang von jedem DirectPlay-Programm bezeichnen, welches auf eine Peer-to-Peer-Verbindung aufbauen möchte. Mit Hilfe des Peer-Objektes können wir in Zeile 5 die verfügbaren ServiceProvider an das Array SPInfoArray übergeben. Die Methode GetServiceProviders() benötigt lediglich einen Parameter. Wenn Sie diesen Parameter auf True setzen, dann werden alle installierten ServiceProvider aufgelistet. Mit False werden nur die wirklich verfügbaren angezeigt. In den Zeilen 11 - 16 übertragen wir die erhaltenen Informationen in eine Listbox.

36.2 Wie ist eine Peer-to-Peer Verbindung aufgebaut? Um eine Peer-to-Peer-Verbindung aufzubauen, benötigen wir mindestens zwei Computer. Hiervon übernimmt ein Computer die Rolle des Hausherren (Host) und der zweite Computer übernimmt die Gastrolle. DirectPlay bezeichnet die Gäste als Player. Hausherr und Gäste treffen sich in einer Session. Eine Session kann man sich als Gruppenraum vorstellen, zu dem hat aber nicht jeder Zutritt hat. Nur wer eine gültige Eintrittskarte besitzt, kommt hinein. Die Eintrittskarte wird in Form einer GUID übermittelt. So ist es sichergestellt, dass man nicht zufällig in einer anderen Session landet, nur weil diese den gleichen Namen trägt. Es wäre schon unangenehm, wenn wir uns plötzlich in einem populären Internetspiel wiederfinden würden. Aber das kann ja nicht passieren, weil wir keine gültige GUID (Eintrittskarte) besitzen. Abbildung 101 zeigt eine schematische Darstellung einer Peer-to-Peer-Verbindung.

394

DirectPlay

Abb. 101. Peer-to-Peer-Verbindung

Wie Sie an der Grafik erkennen können, ist es nicht wichtig, welcher Computer als Host dient. Wichtig ist, dass alle Computer die gleiche GUID melden. Ohne die richtige GUID kommt keine Verbindung zustande.

36.3 Erstellen einer GUID Falls Sie sich gefragt haben, wie Sie eine GUID erstellen sollen, können Sie sich beruhigt zurücklehnen und die Arbeit von .NET erledigen lassen. .NET stellt uns einen Befehl zur Verfügung, welcher eine neue GUID erstellt. System.Guid.NewGuid.ToString

Wir haben ein kleines Programm erstellt, welches diese Methode nutzt. Sie finden das Programm auf der CD in dem DirectPlay-Ordner.

Abb. 102. Screenshot CreateGuid

Player

395

36.4 Host Wir wissen, dass wir für eine Peer-to-Peer-Verbindung einen Gastgeber benötigen. Diesen wollen wir nun erstellen. Zuerst werfen wir einen Blick auf den Sourcecode. 1 2 3 4

5

6

7

8 9 10

11 12

Sub Hosting() Dim myPeer As DirectPlay.Peer = New DirectPlay.Peer Dim myLocalAddress As DirectPlay.Address Dim myAppGuid As New Guid _ ("9cd8b6ad-a8d6-47d6-a60d-68f559aef228") Dim myAppDesc As New DirectPlay.ApplicationDescription myLocalAddress.ServiceProvider = _ DirectPlay.Address.ServiceProviderTcpIp myLocalAddress.AddComponent("port", 2603) myAppDesc.GuidApplication = myAppGuid myAppDesc.SessionName = „Meine erste Session“ myAppDesc.Flags = DirectPlay.SessionFlags.NoDpnServer myPeer.Host(myAppDesc, myLocalAddress) End Sub

Was brauchen wir zum Erstellen eines Host-Systems. Wir benötigen eine Programmbeschreibung und eine Adresse. Die Programmbeschreibung regelt grundlegende Eigenschaften der Session. Die Adresse steuert den Kommunikationsweg. Über die Adresse wählen wir u.a. den ServiceProvider. In diesem Fall geschieht dies in Zeile 6. Dabei nutzen wir die von DirectX zur Verfügung gestellte Vorlage ServiceProviderTcpIp. Gleichzeitig bestimmen wir in Zeile 7, dass wir über den Port 2603 kommunizieren wollen. In den Zeilen 8 - 10 definieren wir die Programmbeschreibung. In Zeile 8 legen wir die GUID für die Session fest. Nur Computer mit der gleichen GUID dürfen dieser Session beitreten. In Zeile 9 legen wir den Namen der Session fest. Dieser wird angezeigt, wenn sich ein anderer Computer mit dieser Session verbinden möchte. In Zeile 11 ist es dann soweit. Wir erstellen den Host. Hierzu werden die Programmbeschreibung und die Adresse übermittelt.

36.5 Player Mit dem Host haben wir den Gastgeber für unsere Session erstellt, zu einer richtigen Party fehlen uns noch die Gäste. Das ist auch kein Wunder, denn im Moment wissen wir gar nicht, wie wir den Gastgeber finden sollen. Be-

396

DirectPlay

vor wir uns der Party anschließen können, müssen wir herausfinden, wie wir den Host erreichen können. Somit liegen folgende Aufgaben vor uns: • Host suchen • Player erstellen und an der Session anmelden 36.5.1 Host suchen Um einen Host zu finden, benötigen wir verschiedene Informationen. Wir müssen den ServiceProvider, HostNamen und SessionPort kennen. Außerdem müssen wir die GUID der Session kennen. Der Sourcecode hierfür sieht wie folgt aus: 1 2

3 4

Dim HostAddress As New DirectPlay.Address HostAddress.ServiceProvider = mySession.LocalAddress.ServiceProvider HostAddress.AddComponent("hostname", HostName) HostAddress.AddComponent("port", mySession.Port)

Ohne den passenden ServiceProvider könnten wir die gewünschte Session nicht finden. Wenn wir eine Session z.B. mit dem TCP/IPProtokoll gestartet haben können wir diese Session niemals z.B. mit dem IPX-Protokoll finden. Die beiden Protokolle sprechen einfach nicht die gleiche Sprache. Außerdem müssen wir genau wissen, welche Session wir suchen. Ohne den Sessionnamen werden wir nicht weiterkommen. Letztendlich fehlt uns noch der Kommunikations-Port. Dass dieser identisch sein muss, ist offensichtlich. Dim AppDesc As New _ DirectPlay.ApplicationDescription AppDesc.GuidApplication = myAppGuid

Über die Bedeutung der GUID habe wir bereits gesprochen. Nur Applikationen mit identischer GUID dürfen miteinander in Verbindung treten. myPeer.FindHosts(AppDesc, HostAddress, _ mySession.LocalAddress, Nothing, 0, 0, 0, _ DirectPlay.FindHostsFlags.Sync)

Nachdem alle Informationen zusammengetragen wurden, ist die Suche nach dem Host recht einfach. Wir nutzen die FindHosts()-Methode des DirectPlay.Peer -Objektes.

Player

397

Die Suche war einfach, dafür ist es etwas komplizierter, an die ermittelten Daten zu gelangen. An dieser Stelle müssen wir nochmals auf Handles eingehen. Handles werden ausgelöst, wenn ein bestimmtes Ereignis auftritt. Zum Beispiel wir ein Ereignis ausgelöst, wenn ein Host gefunden wurde. Dieses Handle haben wir zuvor deklariert und DirectX mitgeteilt, was zu tun ist, wenn genau dieses Ereignis eintrifft. AddHandler myPeer.FindHostResponse, _ AddressOf FindHostResponseHandler

Diese Sourcecode-Zeile besagt Folgendes: Mit dem ersten Parameter (myPeer.FindHostResponse) wird das Ereignis benannt. Mit dem zweiten Parameter (AddressOf FindHostResponseHandler) wird festgelegt, was passieren soll, wenn das Ereignis eintritt. In unserem Fall wird die Subroutine FindHostResponseHandler() ausgeführt, sobald ein Host gefunden wurde. Wird die Subroutine nicht ausgeführt, dann wurde auch kein Host gefunden. 1

2 3 4 5 6 7

8

9

10

11

12

Public Sub FindHostResponseHandler(_ ByVal sender As Object, ByVal args As _ DirectPlay.FindHostResponseEventArgs) Try ReDim Preserve HostArray(UBound(HostArray) + 1) Catch ex As Exception ReDim HostArray(0) End Try HostArray(UBound(HostArray)).Name = _ args.Message.ApplicationDescription.SessionName HostArray(UBound(HostArray)).Port = _ args.Message.AddressSender.GetComponentInteger _ ("port").ToString HostArray(UBound(HostArray)).IP = _ args.Message.AddressSender.GetComponentString _ ("hostname").ToString HostArray(UBound(HostArray)).Address = _ CType(args.Message.AddressSender.Clone(), _ DirectPlay.Address) HostArray(UBound(HostArray)).Guid = _ args.Message.ApplicationDescription.GuidInstance End Sub

Dieser Sourcecode stammt aus unserem Chat Beispielprogramm (siehe Abschnitt 35.8). Er demonstriert, wie die Informationen eines gefundenen Hosts ausgewertet werden. Sie können, wenn Sie wollen, noch wesentlich mehr Informationen herausziehen. In unserem Beispielprogramm begnügen wir uns auf die im Sourcecode enthaltenen Informationen. Eine

398

DirectPlay

Information ist aber von besonderer Bedeutung: Die GuidInstance des Hosts wir zwingend benötigt, wenn sich ein neuer Player mit der Session verbinden möchte. 36.5.2 Player erstellen und an der Session anmelden Es gab mal Zeiten, in denen musste man zuerst einen Player erstellen, der sich dann einer Session anschließen durfte. Dies ist mit der aktuellen DirectX-Version nicht mehr notwendig. Es genügt, wenn Sie sich mit einer Session verbinden. Der neue Player ist damit automatisch erzeugt worden. 1 2

3

Dim appDesc As New DirectPlay.ApplicationDescription appDesc.GuidInstance = mySession.HostInfoArray _ (myForm.lstSession.SelectedIndex).Guid myPeer.Connect(appDesc, _ mySession.HostInfoArray _ (myForm.lstSession.SelectedIndex) _ .Address, mySession.LocalAddress, Nothing, _ DirectPlay.ConnectFlags.Sync)

Achtung! In Zeile 2 müssen Sie aufpassen. Hier wird nicht die Applikation-Guid verlangt, sondern die Guid des Host-Systems. Dieser haben wir erfasst, als der Host gefunden wurde.

36.6 Senden von Daten Jeder Provider versendet Daten als Datenpakete. Der Aufbau solch eines Paketes ist von Provider zu Provider unterschiedlich. DirectX übernimmt die Kommunikation mit dem Provider, so dass wir nur noch ein Paket zusammenschnüren müssen und dieses an DirectX übergeben. Hierzu betrachten wir die Subroutine Send(). 1 2 3 4

5

6 7 8 9

Sub Send() Try Dim packet As New DirectPlay.NetworkPacket packet.Write(System.Text.Encoding.Unicode.GetBytes _ (“Das ist ein Test.”)) myPeer.SendTo(CInt(DirectPlay.PlayerID.AllPlayers) _ , packet, 0, DirectPlay.SendFlags.Sync Or _ DirectPlay.SendFlags.NoLoopback) myForm.txtSend.Text = "" Catch ex As Exception Return End Try

Empfangen von Daten 10

399

End Sub

In Zeile 3 deklarieren wir die Variable packet als DirectPlay.NetworkPacket. Dieser Datentyp ist für Sie als Programmierer sehr hilfreich, denn Sie müssen sich nicht um das genaue Datenformat kümmern. Es reicht dieser allgemeine Datentyp für jeden Provider. Nun können wir in Zeile 4 das Paket zusammenpacken. Hierzu verwenden wir die Methode DirectPlay.NetworkPacket .Write(). Auch wenn das in Zeile 4 nicht sofort ersichtlich ist, übergeben wir nicht einen einfachen String, sondern ein komplettes Byte-Array. Die Methode Unicode.GetBytes() liefert das benötigte ByteArray. In Zeile 5 wird das Paket versendet. Der erste Parameter bestimmt den Empfänger. Wir wählen eine Konstante, welche das Paket an alle Player der Session versendet. Das entspricht einer öffentlichen Diskussion.

36.7 Empfangen von Daten Die größte Schwierigkeit beim Empfangen von Daten besteht darin, zu wissen, wann Daten eintreffen. Soll man kontinuierlich prüfen, ob Daten eingetroffen sind, oder darauf warten, dass wir informiert werden. Wenn neue Daten eintreffen, möchten wir von DirectX informiert werden. Hierzu müssen wir ein neues Handle erzeugen: AddHandler myPeer.Receive, AddressOf ReceiveHandler

Wenn neue Daten eintreffen, dann soll die Subroutine ReceiveHandler() ausgeführt werden. 1

2 3

4

5

6 7 8 9 10

Public Sub ReceiveHandler(ByVal sender As Object, _ ByVal args As DirectPlay.ReceiveEventArgs) Try Dim packet As DirectPlay.NetworkPacket = _ args.Message.ReceiveData Dim data As Byte() = _ CType(packet.Read(GetType(Byte), _ packet.Length), Byte()) myForm.lstChat.Items.Add _ (System.Text.Encoding.Unicode.GetString(data)) Catch ex As Exception ShowException(ex, "ReceiveHandler", False) Return End Try End Sub

400

DirectPlay

Wir wissen, dass die Daten als DirectPlay.NetworkPacket ankommen. Deshalb initialisieren wir in Zeile 3 die Variable packet mit diesem Datentyp und übergeben direkt das empfangene Paket. Ebenfalls wissen wir, dass das Paket ein Byte-Array enthält. Dieses übergeben wir in Zeile 4 an die lokale Variable data(). Diese hat den Datentyp Byte bzw. Byte-Array. Solch ein Byte-Array ist für den Menschen schlecht lesbar und deshalb wollen wir aus dem Array einen gut lesbaren String formen. Dies tun wir in Zeile 5.

36.8 Beispielprogramm: Simple Chat Wir haben ein einfaches Chat-System erstellt. Sie können eine Session erzeugen und bis zu 12 Player dürfen sich der Session anschließen. Das Chat-System funktioniert sowohl lokal wie auch per Internet.

Abb. 103. Screenshot Chat-System

Sie können das Programm nutzen, um mit Freunden zu kommunizieren. Hierzu bleibt es Ihnen überlassen, ob Sie die Kommunikation in einem lokalen Netzwerk oder per Internet aufbauen möchten. Um das Programm zu testen, können Sie das Programm zweimal auf einem Computer starten. Das zuerst gestartete Programm übernimmt die Rolle des Gastgebers. Hierzu klicken Sie auf die Schaltfläche „Hosting“. Mit dem zweiten Programm müssen Sie zunächst den Gastgeber suchen. Dies geschieht durch

Beispielprogramm: Simple Chat

401

Klicken auf die Schaltfläche „Search“. Wenn der Gastgeber gefunden wurde, wird dieser in der Session-Listbox angezeigt. Anschließend können Sie sich mit der Session verbinden. Nachdem die Verbindung erfolgreich aufgebaut wurde, können die beiden Session miteinander kommunizieren. Wenn Sie das Programm auf zwei Computern laufen lassen, übernimmt wiederum ein Computer die Gastgeberrolle und der zweite Computer meldet sich als Gast an. Da Sie diesmal eine Kommunikation mit einem anderen Computer aufbauen möchten, müssen Sie dessen IP-Adresse kennen. Diese geben Sie dann in das Suchfeld „ServiceProvider“ ein.

Abb. 104. Service-Provider finden

Den Namen „localhost“ verwenden Sie nur, wenn Sie eine Session auf dem eigenen Computer suchen. Bei der Verbindung mit einem anderen Computer ist es nicht wichtig, ob der Computer lokal über ein LAN-Netzwerk eingebunden ist oder ob Sie eine Verbindung per Internet wünschen. Hauptsache Sie kennen die korrekte IP-Adresse. An dieser Stelle möchten wir auf mögliche Verbindungsprobleme aufmerksam machen. Im Regelfall verhindert eine Firewall, dass die IPAdresse für andere Computer sichtbar ist. In diesem Fall können Sie keine Verbindung aufbauen. Ein weiteres Problem tritt dann auf, wenn Sie die Verbindung zum Internet über einen Router herstellen. Nach außen ist nur die IP-Adresse des Routers sichtbar, aber nicht die IP-Adresse des am Router angeschlossenen Computers. Auch in diesem Fall können Sie keine Verbindung herstellen.

402

DirectPlay

36.9 Kommunikationsmodelle Im folgenden Abschnitt wollen wir zwischen zwei grundlegenden Kommunikationsmodellen unterscheiden. Auf der einen Seite finden wir die Peer-to-Peer-Session und auf der anderen Seite eine Client/Server-Session. 36.9.1 Peer-to-Peer-Session In einer Peer-to-Peer-Session sind alle Teilnehmer gleichberechtigt miteinander verbunden. Zwar übernimmt einer der Teilnehmer die Aufgabe des Gastgebers (Host / Server) und somit erhält dieser auch die administrativen Rechte, aber dennoch ist auch der Gastgeber ein normales Mitglied in der Netzwerkstruktur. Gleichberechtigt miteinander verbunden bedeutet, dass jeder Computer die Rolle des Gastgebers übernehmen kann. Der Gastgeber steht aber nicht außerhalb der Session, sondern ist in die Session integriert und somit auch ein normales Mitglied der Session. In einem gleichberechtigten Netzwerk werden Nachrichten von einem Mitglied direkt zu einem anderen Mitglied geschickt. Sie müssen nicht den Umweg über den Gastgeber nehmen. 36.9.2 Client/Server-Session Bei einer Client/Server-Session übernimmt ein Computer die Aufgabe des Servers. Alle anderen Computer sind Client-Systeme, welche auf die Administration des Servers angewiesen sind. Auf dem Server läuft ein spezielles Serverprogramm und auf den Clients ein spezielles Clientprogramm. Der wesentliche Unterschied zu einer Peer-to-Peer-Session besteht darin, dass die einzelnen Systeme keine direkte Verbindung zueinander haben. Möchte ein Client eine Nachricht an einen anderen Client senden, dann muss er die Nachricht an den Server senden und ihm gleichzeitig mitteilen, für wen die Nachricht gedacht ist. Der Server entscheidet nun, ob er die Nachricht weiterleiten möchte oder nicht. Obwohl es durchaus möglich wäre, so wäre es dennoch ungewöhnlich, wenn der Server ein Mitglied der Session wäre. Der Server steht im Regelfall außerhalb der Session und übernimmt nur administrative Aufgaben. 36.9.3 Sicherheit Beide Kommunikationsmodelle können die von DirectPlay mitgelieferten Sicherheitsmerkmale nutzen. DirectPlay bedient sich der Möglichkeiten

Kommunikationsmodelle

403

des SSPI (Security Support Provider Interface). Dazu gehören u.a. folgende markante Merkmale: Passwortschutz. Die Identität des Teilnehmers kann anhand eines Passworts gewährleistet werden. Erst nachdem das Passwort überprüft und für echt befunden wurde, erhält der Teilnehmer den Zugang zur Session. Digitale Signaturen für Systemnachrichten. Durch die Signatur wird die Identität des Teilnehmers und somit der gesendeten Nachricht gewährleistet. Verschlüsselung. Insbesondere das Thema Verschlüsselung wird immer wieder diskutiert. Natürlich ist eine Verschlüsselung sinnvoll. Dennoch bietet Sie keinen hundertprozentigen Schutz gegen ungewolltes Mithören.

37 Das Spiel: Return From Orion

Nachdem wir aus den ersten beiden Teilen des Buches den Umgang mit Visual Basic.NET und DirectX kennen gelernt haben, wollen wir nun diese beiden Programmiertechniken nutzen und uns im dritten Teil um den Einstieg in das Thema der Spieleprogrammierung kümmern. Wir wollen dem Leser dieses Buches erste Ansätze zur Entwicklung von Spielprojekten aufzeigen und Ihnen anhand eines Demospieles Techniken und Fertigkeiten bei der Programmierung eines solchen Projektes vermitteln. Wir werden Ihnen auch eventuelle Probleme und Fehler, die bei der Arbeit an einem Spiel immer wieder auftauchen können, aufzeigen und Lösungsvorschläge anbieten. Da es sich bei unserem Demospiel um ein Projekt in der Einsteigerklasse handelt, haben wir auf große theoretische Erklärungen innerhalb der einzelnen Kapitel verzichtet und uns immer der direkten praktischen Umsetzung des Themas gewidmet. So können wir schnell erste Fortschritte in der Erstellung unseres Projektes erzielen. Der praktische Teil erklärt dabei, wie wir die einzelnen Techniken in unserem Spiel eingesetzt haben. Für die genaue Erläuterung der einzelnen Techniken wollen wir Sie aber bereits an dieser Stelle wieder auf den zweiten Teil des Buches verweisen, damit wir uns Wiederholungen in diesem Kapitel soweit es geht ersparen. Wir wollen aber nicht ausschließlich über den technischen Ablauf bei der Erstellung eines Spieles sprechen, sondern die Spieleprogrammierung als Ganzes betrachten. Fangen wir damit an, wie man unserer Ansicht nach ein so umfangreiches Projekt wie die Erstellung eines Computerspiels beginnen sollte. Bevor wir uns der Entwicklung unseres Spieles zuwenden, wollen wir ein paar generelle Worte zum Thema Spieldesign anbringen. Jedem, der sich mit diesem Thema auseinander setzt, sollte klar sein, dass die Zeiten, in denen ein Spiel innerhalb von wenigen Tagen designt und umgesetzt wurde, vorbei sind. Heutzutage muss ein Spieldesigner ein wahres Multitalent sein. Nicht nur dass er die eigentliche Idee zu einem Spiel haben muss, nein er ist außerdem verantwortlich für alle Stadien der Erstellung des Spiels. Und zwar von der ersten Befehlszeile bis zu dem Punkt, wo die fertige CD das Werk verlässt. Da die heutigen Spiele nicht mehr so simpel sind, wie noch in den Anfangszeiten der Computerspiele, ist die Hauptauf-

406

Das Spiel: Return From Orion

gabe eines Spieldesigners das Überzeugen von Zeitgenossen von seiner Idee. Dabei ist es egal, ob man nun eine große Spielschmiede von seiner Idee überzeugen will oder seine Freunde. Es ist wichtig, dass man seine Idee gut verkaufen kann. Zu diesem Zweck reicht es meist nicht aus, seine Ideen nur im eigenen Kopf zu haben, sondern man sollte versuchen, die Ideen so früh wie möglich zu Papier zu bringen. Sollte man dieses versäumen, wird man die meiste Zeit während des Prozesses der Spielentwicklung damit verbringen, seine Gedanken anderen zu vermitteln. In diesem Stadium werden dann auch die meisten Ideen, die nicht ordentlich dokumentiert und aufbereitet sind, wieder begraben.

37.1 Erste Gedanken zum Spiel Wie gesagt, die ersten Seiten dieses Buchteils sollen Ihnen die Entstehungsgeschichte eines Spieles etwas näher bringen. Hier wollen wir ein paar Punkte aufführen, über die Sie sich im Vorfeld Ihres Projektes Gedanken machen sollten. Leider sind schon viele gute Ansätze zu guten Spielen im Sande verlaufen, weil sich die Designer und Programmierer im Vorfeld nicht ausreichend Gedanken über ihr Projekt gemacht haben. In diesem Punkt sprechen wir aus eigener Erfahrung. Nichts ist schlimmer, als ein Projekt sterben zu sehen, weil bei der Planung ein wichtiges Detail übersehen worden ist. Und nichts ist schwieriger, als einen Designfehler im fast fertigen Produkt korrigieren zu müssen. Um solche Fehler zu vermeiden, können wir Ihnen nur ans Herz legen, die folgenden Seiten zu lesen und in Ihre Überlegungen bei Ihrem ersten oder nächsten Projekt mit einfließen zu lassen. Dabei sollen die einzelnen Abschnitte Denkanstöße geben und eine erste Anregung für Ihren eigenen Weg als Spielentwickler sein. Wir sind mit diesen Tipps und Verhaltensregeln bei vielen Projekten, auch bei nicht spielbezogenen, gut gefahren und konnten damit viele Schwierigkeiten schon im Vorfeld ausmerzen.

37.2 Von der ersten Spielidee zu einem Konzept Vor der Realisierung eines jeden Spiels steht eine mehr oder weniger geniale Idee. Aus dieser Idee heraus wird bei einigen wenigen Spielen ein einmaliges Spielprinzip geboren, das viele tausend Spieler in ihren Bann zieht. Manchmal sind gerade die einfachsten Ideen Grundlage für erfolgreiche Spiele. Man denke zum Beispiel an die Idee, verschieden geformte Blöcke von der Decke fallen zu lassen, wo diese dann vom Spieler am Boden sortiert werden. Auch die Idee, kleine Männchen solange laufen zu

Von der ersten Spielidee zu einem Konzept

407

lassen, bis sie entweder am Ziel angekommen oder auf dem Weg dorthin verloren gegangen sind, sieht auf den ersten Blick nicht spektakulär aus. Aber wer hat nicht schon schreiend vor dem Computer gesessen und die kleinen Männchen verflucht, die wie die Lemminge alle in ein Loch gefallen sind. Die erste Idee ist oft unspektakulär und wird von den meisten verworfen. Aber wie gesagt sind es vorwiegend die einfachen Spielprinzipien, welche Spieler stundenlang an einen Computer fesseln können. Da es sich bei der Idee zu einem Spiel nur um die erste Initialzündung für ein späteres Projekt handelt, muss das Konzept nicht auf Anhieb hundertprozentig ausgefeilt sein. Man sollte eher mit dieser Idee „schwanger“ gehen und mindestens vier Wochen über die Idee nachdenken. In den vier Wochen ist es hilfreich, eine „Schmierzettel“-Sammlung anzulegen oder ständig einen Notizblock bei sich zu tragen. Jede Anregung und Idee zu dem aktuellen Projekt kann man auf diese Weise sofort notieren und dem Projekt hinzufügen. Dies kann zu diesem Zeitpunkt ruhig völlig unsortiert und unorganisiert vonstatten gehen. Nach diesen vier Wochen nimmt man nun seine „gesammelten Werke“ und wertet diese aus. Nun bringt man das Blätterwerk in eine geordnete Form und entscheidet, ob genug Material zusammengekommen ist, so dass sich die Umsetzung der ursprünglichen Idee zu einem Spiel wirklich lohnt. Diese Vorgehensweise hat sich bei den Autoren des Buches schon manches Mal ausgezahlt. Denn nicht immer ist eine „geniale“ Idee für ein Spielprojekt auf den zweiten Blick wirklich umsetzenswert und es ist ärgerlich, nach einigen Wochen des Programmierens festzustellen, dass das entstandene Spiel im Grunde langweilig ist. Das Prinzip der Ideensammlung unterstützt auch die Arbeit an einem Projekt in einer Gruppe. Hierbei sollte sich jedes Mitglied über den Zeitraum der Ideensammlung eigenständig Notizen zu dem Projekt machen. Diese eigenständigen Ideen sollten dann in der Gruppe sortiert und bewertet werden. Hierbei stellt sich oft heraus, dass sich ein Projekt in verschiedene Richtungen entwickeln kann. Das gewährleistet meistens ein breiteres Spektrum an Ideen und somit ein interessanteres und tieferes Spielprinzip, als wenn das Projekt nur von einer Person alleine entwickelt wird. Wir empfehlen speziell für den Anfänger, die Bildung kleiner Programmiergruppen. Dies hilft jedem der Beteiligten. Erstens steht man bei eventuellen Problemen nicht alleine da und zweitens wird die Realisierung eines Spieles wahrscheinlicher, wenn mehrere Programmierer in die gleiche Richtung arbeiten. Für den praktischen Teil dieses Buches haben wir uns ein Projekt ausgesucht, das man auf ca. 120 Seiten erläutern kann. Hierbei steht die Übung

408


der im theoretischen Teil des Buches erlernten DirectX9 - Techniken im Vordergrund. Die Autoren werden während der Erläuterung der einzelnen Entwicklungsschritte immer auf den Abschnitt des theoretischen Teils hinweisen, der den gerade behandelten praktischen Entwicklungsschritt näher erklärt. Da unsere Gedanken bei der Entwicklung des Spielkonzeptes für dieses Buch weniger auf die „geniale“ Spielidee, sondern mehr auf den Einsatz von DirectX9 - Techniken fokussiert waren, haben wir uns entschieden, ein „einfaches“ Labyrinthspiel als Projekt umzusetzen.

37.3 Der Entwicklungsprozess oder die Arbeit vor der Arbeit Wer geglaubt hat jetzt schon voll in die Spieleprogrammierung einsteigen zu können, den müssen wir hier an dieser Stelle leider enttäuschen. Denn vor der eigentlichen Programmierung und dem Design des Spieles sollten die vorher „gesammelten Werke“ in ein vollständiges Konzept gebracht werden. Mit diesem Konzept kann man schon im ersten Stadium der Entwicklung einen Überblick über mögliche Schwerpunkte und Probleme erhalten. Wichtig ist dieses Konzept auch, um seine eigenen Grenzen auszuloten. Bei der Erstellung des Konzeptes sollte man deshalb immer schon über die Möglichkeit der Umsetzung nachdenken. Denn es bringt nichts, wenn man mitten in der Programmierung des Projekts feststellt, dass einem die Techniken fehlen, um ein bestimmtes Feature des Spieles umzusetzen. Außerdem ist es einfacher, andere Programmierer, Grafiker oder Designer von seiner Idee zu überzeugen oder anderen Mitgliedern der Projektgruppe seine Ideen zu veranschaulichen

37.4 Festlegung des Spielprinzips/Spielablaufs Als ersten Punkt in der Ausarbeitung des Konzeptes sollte das komplette Spiel einmal grob aufgeschrieben werden. Hierbei sollten wichtige Sachen geklärt werden (wie z.B. in welchem Genre sollte das Spiel stattfinden; soll es sich bei Ihrem Projekt um einen Ego-Shooter, ein Adventure-, ein Strategie- oder ein Simulationsspiel handeln; welche Höhepunkte soll das Spiel haben; ist die Spielidee so fesselnd, dass das Spiel einzigartig ist, oder sollen schon existierende Ideen neu umgesetzt werden). Die Handhabung und Steuerung des Spiels sollten grob festgelegt werden. Hierbei muss z.B. überlegt werden, welches Eingabegerät die Steuerung des Spiels

Die Storyline – eine Geschichte entsteht

409

übernehmen soll und ob die Umsetzung der Steuerung den Spielverlauf unterstützt oder behindert. Eine schlechte Steuerung der Spielfigur ist nämlich in der Lage, selbst die einzigartigste Spielidee innerhalb von Minuten für einen Spieler uninteressant zu machen. Ein weiterer Punkt der guten Handhabemöglichkeiten eines Spieles ist die Perspektive. Hierbei ist die richtige Wahl genauso wichtig wie eine gute Bedienung. Denn was nützt es, eine Spielfigur perfekt steuern zu können, wenn man nicht sieht wohin. Dabei ist es wichtig, das Verhältnis zwischen einer dynamischen Ansicht der Spielfigur, wie sie eine Ego-Perspektive bietet, und einer guten Übersicht über das Spielfeld bzw. die Umwelt der Spielfigur, wie sie eine isometrische Ansicht bietet, ausgewogen zu halten. Dies kann man mit Kamerafahrten bei wichtigen Ereignissen oder sich nähernden Gegnern erreichen. Das ist aber schon die hohe Kunst der 3DProgrammierung. Für den Anfang sollte man vielleicht erst mit einer Schulterperspektive arbeiten. Dabei ist die Ansicht des Spielfeldes immer über die Schulter der Spielfigur hinweg gerichtet. Das gewährt eine gute Übersicht und man hat die Dynamik der Bewegung seines eigenen Charakters mit im Bild. Zum guten Schluss sollten noch die Ziele des Spiels definiert werden, wie z.B. wann gewinnt der Spieler das Spiel, wann verliert er; wie sieht ein Punktesystem in dem Spiel aus; wie werden dem Spieler Fortschritte im Spielablauf belohnt; gibt es ein Kreditsystem, mit dem der Spieler neue Gegenstände erstehen kann, oder gewährleistet eine hohe Punktzahl dem Spieler Zutritt zu verschlossenen Räumen oder einem neuen Level.

37.5 Die Storyline – eine Geschichte entsteht Das Thema der „Storyline“ werden wir hier nur kurz anschneiden, denn eine komplette Story für ein Spiel zu schreiben ist eine Kunst für sich und kann, wenn es gut gemacht wird, fesselnder als ein Romanklassiker sein. Andererseits ist bei einer fesselnden Spielidee eine Geschichte zum Spiel meist gar nicht notwendig. Oder haben Sie sich schon einmal beim Spielen eines Ego-Shooters gefragt, welche Story hinter dem steckt, was Sie gerade auf dem Bildschirm sehen. Wichtig ist eine „Storyline“ bei Adventuren-Spielen. Hier sollten im „Drehbuch“ alle möglichen Non Player Characters (NPC) mit aufgenommen werden. Wenn Ihr Spiel solche NPCs enthalten soll, sollten Sie die Eigenschaften jedes einzelnen Charakters, der in Ihrem Spiel vorkommt, festlegen, sowie seinen Nutzen im Spiel und die Möglichkeit des Spielers, mit dem Charakter zu interagieren, bestimmen, ebenso gehört die genaue örtliche Festlegung der NPCs in die Storyline.

410


37.6 Festlegen des Designs mit Designstudien Ein weiterer wichtiger Punkt vor dem eigentlichen Start der Entwicklung des Spiels ist das Aussehen des fertigen Projektes. Hierbei sollte der angehende Spieldesigner sich eine genaue Vorstellung von jedem Objekt, das im Spiel vorkommt, verschaffen. Das geht entweder über eine genaue Beschreibung des jeweiligen Objekts oder über eine Zeichnung. Wobei auch hier das Prinzip zählt: „Ein Bild sagt mehr als tausend Worte.“ Mit genauen Vorstellungen über das Aussehen eines jeden Objektes im Spiel können Sie nun auch größere Teile des Spiels grafisch in einen Zusammenhang bringen. Dabei können Sie Ihrer Phantasie freien Lauf lassen. Sie können einzelne Szenen oder Level zeichnen oder aber auch mit Hilfe von Grafikprogrammen mögliche Designstudien erstellen.

Abb. 105. Erste Strichzeichnung „Return From Orion“

Auf jeden Fall sollten Sie aber nie aus den Augen verlieren, dass Sie Ihre Ideen auch nachher umsetzen müssen und dass Sie keine animierten 3DObjekte einsetzen können, wenn Sie keinen Zugriff auf eine entsprechende Ressource zum Erstellen eines solchen Objektes haben. Wichtig bei der gesamten Festlegung des Designs ist, je genauer Ihre Vorstellung vom fertigen Projekt ist, desto einfacher ist nachher die Umsetzung Ihrer Ideen in der eigentlichen Projektrealisierungsphase. Sie sollten sich schon zum jetzigen Zeitpunkt über die gesamten Details Ihres Spiels im Klaren sein. Dazu gehören alle Details des Gameplays und

Das Konzept des Spiels

411

der einzelnen Spielabschnitte, die einzelnen Missionen oder Rätsel, eventuell der Architekturstil Ihrer Gebäude und das Verhalten Ihrer Gegner.

37.7 Das Konzept des Spiels Da wir für die Erklärung des Spielprojektes nur ca. 120 Seiten eingeplant haben, beschränkt sich unser Konzept auf folgende Punkte: • Die Idee des Spiels ist es, ein dreidimensionales Labyrinthspiel zu erstellen, in dem alle Programmiertechniken aus den ersten beiden Teilen des Buches eingesetzt werden. • Hierbei müssen vom Spieler alle Energiepillen in einem Level gesammelt werden, um das Level verlassen zu können. • Es gibt vier Gegner pro Level, die mit unterschiedlichen Strategien versuchen den Spieler an dem Erreichen seines Ziels zu hindern. • Die Steuerung geschieht über die Tastatur. • Als Kameraperspektive dient die Verfolgerperspektive auf die Spielfigur. • Das Spiel trägt den Namen „Return From Orion“. Aufgrund des relativ einfachen Spielprinzips verzichten wir an dieser Stelle auf eine ausgefeilte Geschichte.

38 Das Projekt startet

Da wir mit dem Spiel die Techniken der DirectX-Programmierung vertiefen wollen, die wir im zweiten Teil des Buches gelernt haben, werden wir auch auf Klassen aus diesem Teil zurückgreifen. Diese haben wir bereits im zweiten Teil erklärt, deshalb sehen wir an dieser Stelle von weiteren Erläuterungen ab und werden nur darauf hinweisen, in welchem Abschnitt des Buches die genaue Erklärung der DirectX-Technik zu finden ist. Wir wollen uns vielmehr darauf konzentrieren die Techniken aus der reinen Demonstrationsumgebung in ein „lebendes“ Projekt bzw. Spiel zu übernehmen. Da es sich bei dem Spielprojekt nicht um einzelne Technikdemonstrationen wie im zweiten Teil handelt, sondern um ein komplexes Gesamtprojekt, können wir die einzelnen Funktionen nicht in eigenen Projekten demonstrieren. Wir werden deshalb im Verlauf der Spielerklärung immer gezielt Programmteile herausnehmen und erklären. Dies geschieht nicht immer in der Reihenfolge, wie die Befehle im Programm aufeinander folgen. Vielmehr haben wir die Kapitel in die einzelnen Techniken unterteilt und greifen in dieser Reihenfolge auf den Quellcode zu.

38.1 Erstellen der ersten Objekte Wir sind uns also nun im Klaren, wie unser Spiel aussehen soll. Deshalb können wir auch ohne zu zögern an die Umsetzung unserer Ideen gehen. Wir fangen damit an, dass wir ein neues Projekt starten. Dazu wählen wir unter Visual Basic-Projekte eine normale Windows-Applikation aus. Danach geben wir einen Namen und einen Speicherort für unser neues Projekt an. Für die Erstellung des Projektes verzichten wir an dieser Stelle bewusst auf den DirectX9-Assistenten, um möglichst alle benötigten Optionen für die Erstellung unserer DirectX-Applikation manuell durchführen zu können und damit auch alle Einstellungen im Griff zu haben.

414

Das Projekt startet

Abb. 106. Ein neues Projekt erstellen

Wir speichern die Form des Projektes unter dem Namen frmStart in der Datei frmStart.vb in unserem angelegten Verzeichnis ab. Die Hauptklasse unseres Spiels ist nun festgelegt. Als Nächstes müssen wir unserer Applikation mitteilen, dass sie die für unsere Zwecke benötigten DirectXObjekte benutzen soll. Dazu müssen wir in der Visual StudioEntwicklungsumgebung im Menü „Projekt“ auf „Verweis hinzufügen...“ klicken. Nacheinander sollten nun folgende Verweise über den Button „Auswahl“ im „Verweis hinzufügen“ -Dialog dem Projekt hinzugefügt werden. • • • • • •

Microsoft.DirectX Microsoft.DirectX.Direct3D Microsoft.DirectX.Direct3DX Microsoft.DirectX.DirectInput Microsoft.DirectX.DirectSound System.Drawing

Damit haben wir die erste Verknüpfung in die DirectX-Welt für unser Programm erstellt. Um die Objekte in unserem Spiel nutzen zu können, müssen wir sie nun noch in unsere Form -Klasse importieren. Das geschieht mit den folgenden Befehlen, die wir in die ersten Zeilen unserer frmStart -Datei schreiben. Dabei ist zu beachten, dass diese noch vor der eigentlichen Klassendeklaration stehen müssen. 1 2 3

Imports DirectX = Microsoft.DirectX Imports Direct3D = Microsoft.DirectX.Direct3D Imports DirectSound = Microsoft.DirectX.DirectSound

Erstellen des Basis-Devices für das Projekt

415

Durch die Zeilen 1-3 importieren wir die für unsere Hauptklasse benötigten DirectX Schnittstellen und geben diesen von uns definierte Namen. Dadurch haben wir auch später im Projekt immer die genaue Übersicht, welches Objekt wir gerade einsetzen.

38.2 Erstellen des Basis-Devices für das Projekt Jetzt haben wir alle Grundlagen geschaffen, um in unserem Projekt DirectX nutzen zu können. Als Erstes fügen wir nun, wie bereits zuvor in den Projekten aus dem zweiten Teil des Buches, die Klasse DXSettings und die Form frm_Settings in unser Projekt ein, um auch bei unserem Spiel dem Spieler die Möglichkeit zu geben, das Programm mit der für sein System optimalen Grafikeinstellung zu starten. Dazu markieren wir im Projektmappen-Explorer unser Projekt und wählen dann im Menüpunkt Projekt das Element „Vorhandenes Element hinzufügen...“ aus. In dem nun erscheinenden Dialog suchen wir die Datei aus, die wir in unser Projekt einfügen wollen. Danach wählen wir mit dem Auswahlbutton (neben dem „Öffnen“ -Button) des Dialoges den Punkt „Datei verknüpfen“ aus. So erstellen wir nur eine Verknüpfung zu der Quellcodedatei die wir ausgewählt haben. Würden wir an dieser Stelle den „Öffnen“-Button nutzen, würden wir eine Kopie der Datei in unser Projekt übernehmen. Durch die Verknüpfung von Dateien in den Projekten können wir ein und dieselbe Datei in mehreren Projekten benutzen. Verbesserungen, die wir in einem Projekt an der verknüpften Klasse vornehmen, kommen automatisch allen Projekten zugute, in denen die Datei verknüpft ist. Diese Vorgehensweise verlangt aber auch besondere Sorgfalt beim Umgang mit den Klassen. Denn alle Änderungen, die in einem Projekt an einer verknüpften Datei vorgenommen werden, beeinflussen automatisch alle anderen Projekte, in denen die Klasse eingefügt wurde.

416

Das Projekt startet

Abb. 107. Vorhandenes Element hinzufügen

Nachdem wir die beiden Klassen mit unserem Projekt verknüpft haben, müssen wir sie noch im Deklarationsbereich der Klasse frmStart definieren. Dieses geschieht mit den folgenden beiden Zeilen: 1 2

Private frm_Settings As New frm_Settings Private Preset As CurrentSettings

Zu Beginn der Arbeit mit den beiden verknüpften Klassen müssen wir die Variable Preset in der Load-Methode der frmStart-Klasse mit Werten füllen und diese danach an die Klasse frm_Settings übergeben (Zeile 1). Außerdem müssen wir noch der frm_Settings-Klasse das Handle des Objektes übergeben, auf dem anschließend das Device erstellt werden soll (Zeile 2). 1 2

frm_Settings.DX.SetPreset = Preset frm_Settings.DX.SetAusgabeHandle = Me

Nun haben wir alle Einstellungen vorgenommen, um das Direct3D.Device mit Hilfe der frm_Settings-Klasse zu erstellen. Da es bei dieser Klasse zwei Möglichkeiten gibt, ein Device zu kreieren, müssen wir entscheiden, ob der Benutzer die Möglichkeit haben soll, die

Erstellen des Basis-Devices für das Projekt

417

Grafikeinstellungen selbst vorzunehmen, oder ob die in der PresetStruktur eingegebenen Werte genutzt werden sollen, um automatisch ein Device zu erstellen. Am Ende dieser If-Then-Else-Schleife steht im Programm ein Direct3DDevice zur Verfügung, auf dem alle unseren weiteren Funktionen aufbauen werden. 1 2 3 4 5 6 7

If (frm_Settings.DX.CurrentSettings.Automatic = True) Then frm_Settings.DX.EnumAllDirect3D = True D3DDevice = frm_Settings.DX.CreateDirect3DDevice() Else frm_Settings.ShowDialog(Me) D3DDevice = frm_Settings.DX.CreateDirect3DDevice() End If

Mit der Aufnahme der nächsten Zeilen in die Render-Funktion der frmStart-Klasse schließen wir nun das Einbinden des Direct3D.Devices ab. Alle weiteren Funktionen zur Darstellung von Objekten müssen zwischen der Zeile 2 und 4 positioniert werden. 1

2 3 4 5

D3DDevice.Clear(Direct3D.ClearFlags.Target Or Direct3D. _ ClearFlags.ZBuffer, System.Drawing. _ Color. FromArgb(255, 0, 0, 0),1.0F, 0) D3DDevice.BeginScene() ... D3DDevice.EndScene() D3DDevice.Present()

Würden wir unser Programm jetzt starten, würden wir nach der Auswahl der Grafikeigenschaften nur die großen Weiten des Nichts, nämlich ein schwarzes Bild, zu sehen bekommen. Damit das nicht so bleibt, müssen wir uns nun um die Erstellung unserer Objekte im Spiel kümmern. Jetzt fängt die eigentliche Arbeit der Spielentwicklung an. Um ein Labyrinthspiel realisieren zu können, brauchen wir als Erstes eine Plattform, auf der unser Spiel stattfinden kann. Diese werden wir im nächsten Kapitel erstellen.

39 Eine Welt erschaffen

Als Erstes wollen wir also das Spielfeld erstellen, auf dem wir anschließend alle anderen Objekte agieren lassen. Bevor wir an die technische Umsetzung gehen, wollen wir uns aber zunächst um einige grundsätzliche Dinge kümmern. Wir müssen uns überlegen, wie unsere Spielfläche aussehen soll und welche Techniken wir brauchen, um dieses Aussehen zu realisieren. Wie schon erwähnt, wollen wir in unserem Spiel hauptsächlich, die erlernten Techniken des zweiten Teils dieses Buches trainieren. Deshalb haben wir uns entschlossen, die Logik hinter unserem Spiel so einfach wie möglich zu halten. Darum setzen wir bei unserem Spiel auf ein zweidimensionales Feld zur Speicherung aller wichtigen Informationen. Dies hat den Vorteil, dass wir mit relativ wenig Aufwand erste Ergebnisse erzielen können. Wir können die Spielfläche, Kollisionsabfragen und künstliche Intelligenz mit einfachen Abfragen und Programmstrukturen bewerkstelligen, die auf unserem 2D-Feld beruhen.

39.1 Die Theorie des Spielfeldes Wie gesagt, unser Spielfeld soll auf einem zweidimensionalen Feld beruhen. Alle Daten und Informationen, die wir für den Spielablauf, den Rendervorgang und die Bewegungen brauchen, speichern wir in bzw. entnehmen wir diesem Feld. Wir speichern dazu verschiedene Werte in den einzelnen Feldern, die innerhalb des Programms für bestimmte Objekte stehen. Die folgende Abbildung zeigt einen Ausschnitt aus einem Spielfeld.

420

Eine Welt erschaffen

Abb. 108. Ausschnitt aus der 2D-Matrix des Spielfeldes

Durch diese einfache Art der Datenspeicherung haben wir die Möglichkeit, auf alle Informationen direkt zugreifen zu können, ohne erst lange Berechnungen durchführen zu müssen. Im Zweifelsfall müssen wir höchstens jedes einzelne Feld des gesamten Spielfeldes durchgehen und überprüfen, welchen Wert es hat. Wir haben festgelegt, dass die maximale Spielfeldgröße in unserem Spiel 25 x 30 Spielfelder ist. Somit haben wir in unserem Spiel eine maximale Anzahl von 750 Vergleiche, die wir durchführen müssen, um ein Objekt auf unserem Spielfeld zu finden. Bei der Geschwindigkeit der heutigen Computersysteme sollte dies also in wenigen Millisekunden geschehen. Als weiterer Vorteil dieser Methode ist die einfache Übernahme der Daten in unser Programm zu nennen. Wir können das Feld in einem zweidimensionalen Array speichern und danach alle Vorteile der Array-Klasse nutzen. Mit Hilfe von For-Next-Schleifen und den Funktionen des Array-Objektes können wir deshalb auch die Darstellung der Spielfeldobjekte automatisieren und vereinfachen. Wie dieses im Einzelnen funktioniert, zeigen wir im nächsten Abschnitt, der den ersten praktischen Einsatz dieser Strategie darstellt.

39.2 Das Spielfeld in der Praxis Die erste Anwendung für unsere 2D-Matrix ist das Spielfeld. Wir werden eine Spielfläche erstellen, die aus drei Höhen besteht. Die erste Höhe ist die Höhe des Spielfeldbodens. Diese haben wir mit dem Wert 1 in unserem Spiel definiert. Als zweites Element der Spielfläche nutzen wir einen halb hohen Stein. Dieser Stein bekommt den Wert 2 zugewiesen. Als Wand definieren wird den Wert 3. Dieser Wert bezeichnet eine Mauer, welche die gleiche Höhe wie die Spielfiguren haben soll. So können wir mit einfachen

Das Spielfeld in der Praxis

421

Mitteln ein Labyrinth festlegen. Wir müssen jetzt „nur“ noch diese einfachen Informationen aus unserer zweidimensionalen Spielfeldbeschreibung herausfiltern und in unsere dreidimensionale Welt umsetzen. Damit kommen wir zu unserem ersten Problem. Woher bekommen wir die Spielfelddaten zum Erstellen unseres 3D Labyrinths? Wir haben die Informationen für unsere Spielfelder in Textdateien gespeichert. Diese enthalten alle Angaben, die wir zum Aufbau unserer Spielfelder brauchen. 39.2.1 Spielfelddaten auslesen Die Textdatei besteht aus zwei Sektionen. Als Erstes befindet sich die Sektion [General] in der Datei. Diese Sektion hat den Aufbau einer klassischen INI-Datei, wir benutzen die Werte Width und Depth, die die Breite bzw. die Tiefe unseres Spielfelds festlegen. In der zweiten Sektion [Field] werden die Daten des Spielfeldes gespeichert. Die Daten sind in einem Zahlenfeld abgelegt. Die einzelnen Felder des Spielfelds werden durch das Pipe-Zeichen getrennt (|), somit repräsentiert jede Zahl im Zahlenfeld genau ein Feld innerhalb des Spielfeldes. 1 2 3 4 5 6

[General] Width=25 Depth=30 [Field] 3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3 3|1|1|1|1|1|1|1|1|1|1|1|1|1|2|1|1|1|1|1|1|1|1|1|3

Um im Verlauf des Spieles auf die Daten der Textdatei zurückgreifen zu können, verknüpfen wir die Klasse SpielfeldClass in gewohnter Weise mit unserem Projekt. Danach definieren wir die Klasse im Deklarationsbereich der frmStart-Klasse und initialisieren die Instanz der eingefügten Klasse mit den folgenden beiden Befehlen: 1 2

Spielfeld = New SpielfeldClass Spielfeld.CreateSpielfeld(DXUtilities.FindMediaFile _ (LevelVerzeichnis + "Spielfeld.txt"))

Die erste Zeile initialisiert die Variable Spielfeld und weist dieser die Klasse SpielfeldClass zu. Die zweite Zeile liest die als Parameter übergebene Spielfeld-Datei aus und stellt die benötigten Informationen innerhalb der Klasse Spielfeld zur Verfügung. Die Funktion der Routine CreateSpielfeld werden wir uns jetzt einmal genauer anse-

422


hen. Wir haben hier bewusst auf Funktionen und Methoden der INIDateibearbeitung verzichtet, um mehr Routine und Beispiele für die Visual Basic.NET Programmiersprache zu bekommen. 1

2 3 4 5

Public Sub CreateSpielfeld(ByVal strPathAndFile _ As String) Try Dim LevelDatei As System.IO.StreamReader Dim strDateiInhalt(), tmpArray(), tmpZeile() As String Dim FeldTiefe, FeldBreite, a, i As Integer

Die ersten fünf Zeilen sind dabei eher unspektakulär. Nach der Definition der Subroutine in der Zeile 1 mit der Angabe des benötigten Parameters starten wir in der Zeile 2 die Try-Catch-End-Try-Funktion innerhalb der Routine. Danach werden noch die für das Auslesen der Datei benötigten Objekte deklariert. Zum Auslesen der Datei benötigen wir also ein Objekt des Typs StreamReader aus dem Namespace System.IO. 6

LevelDatei = New System.IO.StreamReader _ (CType(strPathAndFile, String))

Mit Hilfe der New-Überladung des StreamReader-Objektes wird in Zeile 6 die über den Aufrufparameter angegebene Datei in den Stream LevelDatei gespeichert. Mit dem CType-Befehl wird damit sichergestellt, dass der Parameter, der an die Routine übergeben worden ist, vor der Nutzung durch den StreamReader in einen String konvertiert wird. Dieser Methode der expliziten Konvertierung eines Wertes oder einer Variablen werden wir im weiteren Verlauf noch häufiger begegnen. 7

strDateiInhalt = Split(LevelDatei.ReadToEnd(), _ "[Field]", , CompareMethod.Text)

In Zeile 7 nutzen wir die Split-Anweisung, um die Rohdaten des LevelDatei-Streams in das Array strDateiInhalt zu übernehmen. Wir teilen also die Daten in zwei unterschiedliche Strings auf. Der erste String beinhaltet alle Zeichen, die vor dem Text [Field] in der Textdatei gestanden haben. Im zweiten String befinden sich alle Daten, die nach dem Suchstring kamen. 8

9

FeldBreite = CType((strDateiInhalt(0).Substring_ (strDateiInhalt(0).IndexOf("Width") + Len("Width="), 2)), Integer) FeldTiefe = CType((strDateiInhalt(0).Substring_ (strDateiInhalt(0).IndexOf("Depth") + Len("Depth="), 2)), Integer)


423

Die Zeilen 8 und 9 ermitteln nacheinander die Werte Width bzw. Depth der ausgelesenen Daten der Textdatei. Dabei wollen wir uns die Befehlskombination einmal genauer ansehen. Wir wissen, dass alle Daten, die vor dem String [Field] in der Datei standen, durch den Split-Befehl in Zeile 7 im ersten Element des strDateiInhalt-Arrays gelandet sind. Auf dieses Element des Arrays greifen wir über den Index 0 zu. Wir wollen also von diesem String einen Teil auslesen. Das machen wir mit der Substring-Anweisung. Dieser Befehl benötigt als Parameter eine Startposition und die Länge des zu liefernden Substrings. Die Startposition berechnen wir dadurch, dass wir in dem Arrayelement nach der Position suchen, an dem der Begriff Width bzw. Depth steht. Zu dieser Position addieren wir noch die Länge des Wortes mit anschließendem Gleichheitszeichen. Von dieser ermittelten Position lesen wir nun 2 Zeichen ein. Das Ergebnis wird nun mit Hilfe des CType-Befehls in einen Integer-Wert konvertiert und in die passende Variable gespeichert. 10

ReDim objektSpielfeldArray(FeldTiefe - 1,_ FeldBreite - 1)

Mit der ermittelten Breite und Tiefe des Spielfeldes dimensionieren wir in Zeile 10 das Array, welches am Ende die gesamten Spielfelddaten aufnehmen soll. 11

tmpArray = Split(strDateiInhalt(1), vbCrLf, ,_ CompareMethod.Text)

In Zeile 11 kommt nun der Split-Befehl ein zweites Mal zum Einsatz. Diesmal nutzen wir den Befehl, um die Spielfelddaten in dem Zahlenfeld in einzelne Teilstrings zu konvertieren. Dazu nutzen wir als Trennzeichen das vbCrLf. Wir trennen also die Textdaten in einzelne Zahlen-Strings auf, wobei jeder String für eine Zeile des Spielfeldes steht. 12 13

14 15

16 17

For i = 1 To FeldTiefe tmpZeile = Split(tmpArray(i), "|", , _ Compare_Method.Text) For a = 0 To tmpZeile.Length - 1 objektSpielfeldArray(i - 1, a) = _ CType(tmpZeile(a), Integer) Next a Next i

An dieser Stelle sind alle Vorarbeiten abgeschlossen, um nun in den Zeilen 12 bis 17 die Daten der Textdatei in unser vorbereitetes Array zu kopieren. Wir benutzen dazu zwei For-Next-Schleifen, um durch die Rohdaten

424


der Textdatei zu navigieren und die Werte zu speichern. Mit der ersten Schleife gehen wir nun die einzelnen Elemente des tmpArray-Arrays durch, in dem sich die einzelnen Zeilen des Spielfeldes befinden. Wir benutzen hier die Split-Anweisung ein weiteres Mal, um aus jeder Zeile ein Array von einzelnen Feldern zu generieren. Dafür teilen wir die Zeile an den Stellen, an dem sich das Pipe-Zeichen befindet. Als Ergebnis erhalten wir ein Array mit den einzelnen Feldern der aktuellen Zeile (Zeile 13). Dieses Array durchlaufen wir nun mit der nächsten For-Next– Schleife in Zeile 14. In Zeile 15 erfolgt der eigentliche Datentransfer aus der Datei in unserer Klasse. Hier weisen wir den einzelnen Elementen des Arrays, das ab jetzt unsere Spieldaten verwalten soll, die entsprechenden Werte aus der Textdatei zu. 18 19

20

Catch currentEx As Exception MessageBox.Show(currentEx.Message & vbCrLf & _ "in Property ErstelleSpielfeld", _ "SpielfeldClass",MessageBoxButtons.OK, _ MessageBoxIcon.Error) End Try

Am Ende bleibt uns nur noch die Subroutine sauber abzuschließen. Sollte während des Ablaufs der Funktion ein Fehler auftreten, geben wir eine MessageBox mit einer Meldung aus, wo der Fehler innerhalb der Funktion stattgefunden hat. In Zeile 20 wird dann nur noch der Try-Block geschlossen und die Routine verlassen. Nach dem Aufruf der CreateSpielfeld-Anweisung in unserer frmStart-Klasse stehen uns jetzt alle benötigten Daten zur Erstellung des Spielfeldes zur Verfügung. Als Nächstes müssen wir diese auswerten und in eine dreidimensionale Landschaft verwandeln. Zur Erstellung des Spielfeldes benutzen wir die Klasse DXGeometricObjectBox, die uns schon aus dem DirectX Graphics-Teil bekannt ist. Mit dieser können wir Würfel in unterschiedlichen Größen erstellen und anschließend zu einem Spielfeld anordnen. Zusätzlich müssen wir noch für alle Würfel Texturen laden und den entsprechenden Objekten zuordnen. 39.2.2 Performance-Steigerung im Spielfeld An dieser Stelle sollten wir uns das erste Mal Gedanken zur Performance unseres Spieles machen. Wir haben jetzt aus unserer Datei die Informationen entnommen, wie das Spielfeld aussehen soll. Das Spielfeld kann eine maximale Größe von 750 Feldern umfassen. Das heißt, wir müssen theoretisch 750 Objekte haben, die wir alle mit einer Texture belegen müssen.


425

Das stellt einmalig kein Problem dar, aber wir müssen im Hinterkopf behalten, dass wir diese Masse an Daten in jedem Rendervorgang darstellen wollen, also so etwa 40-50 Mal pro Sekunde. In diesem Fall stellt diese Menge an Daten ein Problem dar. Dabei ist nicht unbedingt die Anzahl der Objekte das Problem, sondern der Speicherplatz, den die Objekte bzw. ihre Texturen belegen. Die meiste Performance geht dabei verloren, wenn im Speicher zwischen den Texturen der Objekte gewechselt werden muss. Zur Verbesserung der Performance haben wir uns deshalb die beiden Punkte Objektanzahl innerhalb der Spielfläche und Texturen für die Objekte einmal näher angesehen. Zunächst prüfen wir die Objekte im Spielfeld. Wir haben am Anfang des Kapitels festgelegt, dass unsere Spielfläche aus drei verschiedenen Größen von Würfeln bestehen soll. Gehen wir jetzt einmal davon aus, dass wir alle drei Objektgrößen gleichmäßig im Spielfeld verteilt haben, dann kommen wir zu folgendem Rechenbeispiel: Boden Element : 250 Objekte * 12 Polygone = 3000 Polygone Wand 1 Element : 250 Objekte * 20 Polygone = 5000 Polygone Wand 2 Element : 250 Objekte * 28 Polygone = 7000 Polygone Wir müssten in diesem Fall also 15000 Polygone bei jedem Rendervorgang darstellen. Um diese Polygone zu minimieren, haben wir folgende Vorgehensweise für unser Spiel erarbeitet: Wir wissen aus dem zweiten Teil, dass wir über die Matrix eines Objektes seine Position in der Weltmatrix bestimmen können. Deshalb haben wir uns entschlossen, nicht die einzelnen Objekte für den Aufbau des Spielfeldes zu benutzen, sondern nur jeweils einen Würfel von jeder Sorte. Zusätzlich speichern wir die Koordinaten eines jeden Feldes aus der Textdatei in ein eigenes Matrixobjekt. Der zweite Punkt, den wir zur Performance Steigerung benutzen, sind die Texturen der Würfelobjekte. Hier haben wir darauf verzichtet, für jeden Würfel ein eigene Textur zu nutzen, sondern wir verwenden nur eine einzige Texture für jedes Würfelelement. Diese übergeben wir anschließend nur noch als Referenzen an die einzelnen Objekte. So können wir den Speicherbedarf unseres Spieles gering halten und verhindern auch unnötiges Hin-und-her Kopieren im Speicher während des Renderns der Würfelobjekte.

426


39.2.3 Das Spielfeld erstellen Die beschriebene Vorgehensweise zur Erstellung des Spielfelds mit Blick auf die Performance sieht damit wie folgt aus: 1

Private PropertiesArray(0, 0) As DXObjectProperties

Um die Koordinaten der einzelnen Würfel zu speichern, legen wir ein Array mit Elementen der DXObjectProperties-Klasse an. Diese Klasse haben wir wie gewohnt mit unserem Projekt verknüpft. Anschließend definieren wir im Deklarationsbereich unseres frmStart-Objektes ein zweidimensionales Array mit Elementen dieser Klasse. 2 3 4

XWidth = Spielfeld.GetArrayDimension("Depth") ZWidth = Spielfeld.GetArrayDimension("Width") ReDim PropertiesArray(XWidth, ZWidth)

In der Load-Methode können wir nun das Array neu dimensionieren. Dazu lesen wir als Erstes die Größe des Spielfeldes aus der Spielfeldklasse und legen mit dem ReDim-Befehl die neue Größe des Arrays fest. Nun benötigen wir die obligatorischen For-Next-Schleifen, um die Spielfelddaten aus der Spielfeld-Klasse in unser Koordinaten-Array zu kopieren. 5 6 7 8

9

10

11 12

For XPosition = 0 To XWidth For ZPosition = 0 To ZWidth 'Matrizen für den Rendervorgang initialisieren PropertiesArray(XPosition, ZPosition) = New _ DXObjectProperties PropertiesArray(XPosition, ZPosition).X_Position = _ XPosition PropertiesArray(XPosition, ZPosition).Z_Position = _ ZPosition Next ZPosition Next XPosition

Die wichtigsten Zeilen in dem abgebildeten Block sind die Zeilen 8 bis 10. Hier werden nacheinander folgende Aktionen durchgeführt: Als Erstes wird das aktuelle Element in dem Array mit der DXObjectProperties-Klasse initialisiert. Danach wird dieser neuen Instanz zunächst der neue X-Wert übergeben und dann in der nächsten Zeile der neue Z-Wert. Das waren bis hierhin alle erforderlichen Einstellungen, um die Logik des Spielfeldes aus dem zweidimensionalen Feld in die dritte Dimension zu holen. Alle weiteren Schritte, die wir benötigen, werden während des Renderns des Spielfeldes vorgenommen.


427

39.2.4 Die Bitmaske Vielleicht ist es Ihnen schon aufgefallen, wir haben erwähnt, dass wir in unserer Spielfelddatei genau einen Wert für jedes Feld haben. Wie geht man aber vor, wenn zwei Informationen auf einem Feld benötigt werden? Zum Beispiel, wenn wir auf einem Spielfeld nicht nur ein Element der Bodenplatte haben, sondern zusätzlich eine Energiepille oder einen Gegner. Für diesen Fall haben wir uns der Funktion der Bitmaske bedient. Mit Hilfe dieser Technik können wir in einem Wert mehrere Informationen speichern. Dazu werden mit Hilfe einer AND-Verknüpfung jeweils bitweise die unteren 4 Bits bzw. die oberen 4 Bits maskiert. Diese Vorgehensweise wird erfahrenen Programmierern geläufig sein, diejenigen, die mit dieser Methode noch nicht gearbeitet haben, finden hier ein paar Beispiele zum besseren Verständnis. 0000 0001 AND 0000 1111 = 0000 0001 = 01 0000 0010 AND 0000 1111 = 0000 0010 = 02 0001 0010 AND 0000 1111 = 0000 0010 = 02 0001 0010 AND 1111 0000 = 0001 0000 = 16 0100 0001 AND 1111 0000 = 0100 0000 = 64

Wir sehen also, dass wir die unteren und oberen 4 Bits jeweils getrennt voneinander auswerten können. Im dritten und vierten Beispiel ist zu erkennen, dass man aus dem gleichen Ausgangswert (18) nur durch die Verknüpfung mit den Bitmasken unterschiedliche Resultate bekommt. Wenn wir die oberen 4 Bits ausmaskieren, erhalten wir das Resultat 2. Die gleiche Operation mit den unteren 4 Bits ergibt einen Wert vom 16. Für unsere Zwecke haben wir in der Spielfeldklasse Konstante für die jeweiligen Bitwerte festgelegt. 1

Public Const btmStaticObjects As Byte = 15

'0000 1111

Zuerst geben wir die Bitmaske für die statischen Objekte an, das heißt für alle Objekte, die direkt zur Spielfläche gehören und im Verlauf des Spieles nicht verändert werden. 2

Public Const btmGround As Byte = 1

'0000 0001

428 3 4


Public Const btmWall1 As Byte = 2 Public Const btmWall2 As Byte = 3

'0000 0010 '0000 0011

Die nächsten drei Zeilen im Sourcecode stellen die Bitsignatur für die Objekte der Spielfläche dar. Wir haben hier genau die gleichen Werte gewählt, wie wir sie in der Textdatei vorfinden, da diese Werte am häufigsten vorkommen. 5

Public Const btmDynamicObjects As Byte = 240

'1111 0000

In Zeile 5 legen wir die Bitmaske für die dynamischen Objekte fest. Diese Objekte können im Verlauf des Spieles geändert bzw. gelöscht werden. 6 7 8 9 10 11

Public Public Public Public Public Public

Const Const Const Const Const Const

btmSpieler As btmGegner1 As btmGegner2 As btmGegner3 As btmGegner4 As btmEnergyPill

Byte = 16 Byte = 32 Byte = 64 Byte = 128 Byte = 144 As Byte = 192

'0001 '0010 '0100 '1000 '1001 '1100

0000 0000 0000 0000 0000 0000

In unserem Spiel brauchen wir 6 unterschiedliche Werte für die Darstellung von Objekten, die wir alle mit einem Bitwert in den oberen 4 Bits definieren. Zum Schluss haben wir noch eine kleine Tabelle angehängt, mit Werten, die wir innerhalb des Spieles benutzen und die auch in der Textdatei zu finden sind. Tabelle 18. Oft verwendete Bitmuster

Wert 33 65 17 129 145 193

Bitmuster 0010 0001 0100 0001 0001 0001 1000 0001 1001 0001 1100 0001

Beschreibung Gegner 1 plus Grundplatte Gegner 2 plus Grundplatte Spieler plus Grundplatte Gegner 3 plus Grundplatte Gegner 4 plus Grundplatte Energiepille plus Grundplatte

39.2.5 Das Spielfeld rendern Jetzt haben wir fast alle Informationen, die wir brauchen, um uns die Renderroutine für das Spielfeld anzusehen. Als letztes benötigen wir noch Informationen darüber, welche Objekte gerendert werden sollen. Wie schon zuvor erwähnt, nutzen wir zur Darstellung der Spielfelder Instanzen der DXGeometricObjectBox-Klasse. Wir haben mit Hilfe dieser Klasse drei Objekte erstellt und diese mit einer Textur versehen. Dieses


429

geschieht in der Funktion GrafikObjekteInitialisieren. Die genauen Funktionen zur Erstellung der Objekte haben wir im zweiten Teil des Buches schon erläutert. Deshalb reicht uns an dieser Stelle die Information, dass diese Objekte erstellt wurden und von uns über die RenderDXGeometricObjectBox dargestellt werden können. Jetzt ist es endlich soweit, wir können unser Spielfeld darstellen. Dazu haben wir in der Renderfunktion die Subroutine DrawStaticObjects eingefügt. Mit deren Hilfe werden wir nun unser Spielfeld Stein für Stein in unser D3DDevice rendern. 1

2 3

Private Function DrawStaticObjects(ByRef D3DDevice As _ Direct3D.Device) as Boolean Try Dim tempByte As Byte

In der Deklaration der Routine übergeben wir der Funktion das Device als Referenz, in dem die Boxen dargestellt werden sollen. Wir benutzen hier aus Geschwindigkeitsgründen den Übergabeparameter als Referenz. Würden wir eine Variable ByVal übergeben, müssten wir am Ende der Funktion das modifizierte Device als Rückgabewert wieder an die aufrufende Funktion übergeben. Dies würde bei jedem Durchlauf der Funktion zwei Kopiervorgänge auslösen und dementsprechend viel Zeit und Performance verschlingen. In Zeile 3 legen wir dann eine temporäre Variable fest, mit deren Hilfe wir im weiteren Verlauf der Funktion die Daten des Spielfeld-Arrays auswerten. 4 5

For XPosition = 0 To XWidth For ZPosition = 0 To ZWidth

Die Basis für unsere Spielfeld-Renderroutine sind wieder einmal zwei For-Next-Schleifen, mit deren Hilfe wir durch die einzelnen Felder unseres Spielfeldes navigieren. 6

tempByte = CType(Spielfeld.GetArrayPositionValue_ (XPosition, ZPosition), Byte)

Bei jedem Durchlauf der For-Next-Kombination rufen wir den aktuellen Wert aus dem Array der Spielfeldinformationen aus der Klasse Spielfeld ab. Diesen weisen wir dann der temporären Variablen tempByte zu und konvertieren gleichzeitig den Integer-Wert in ein Byte. 7

If (tempByte And Spielfeld.btmStaticObjects) = _ Spielfeld.btmGround Then

430 8

9 10

Eine Welt erschaffen GroundBox.MatrixObject = PropertiesArray _ (XPosition, ZPosition).MatrixObject GroundBox.ForceToUseMatrix = True GroundBox.RenderDXGeometricObjectBox(D3DDevice)

Den so ermittelten Wert können wir jetzt mit einer If-ElseIf-End-If -Kombination auswerten. Wir nehmen dazu unseren aktuellen Wert und führen mit diesem und der Bitmaske für die statischen Objekte aus der Spielfeld-Klasse eine AND-Verknüpfung durch. Das Ergebnis dieser Verknüpfung vergleichen wir dann mit der Bitkonstanten für die Bodenplatte (Zeile 7). Stimmen die beiden Werte überein, dann wird in den Zeilen 8 bis 10 das Objekt in dem Device dargestellt. Da wir immer wieder das gleiche Objekt darstellen, nur mit andernen Koordinaten, weisen wir diesem Objekt als Erstes die Koordinaten des aktuellen Elementes zu, die wir am Anfang im PropertiesArray hinterlegt haben. In Zeile 9 weisen wir der Klasse an, beim Rendern die von uns zur Verfügung gestellten Koordinaten zu verwenden. Mit dem Befehl in der Zeile 10 rendern wir das Objekt in das Device, das wir erneut als Referenz dem Befehl RenderDXGeometricObjectBox mitgeben. 11

12

13 14 15

16

17 18 19 20 21

ElseIf (tempByte And Spielfeld.btmStaticObjects) = _ Spielfeld.btmWall1 Then WallBox1.MatrixObject = PropertiesArray _ (XPosition, ZPosition).MatrixObject WallBox1.ForceToUseMatrix = True WallBox1.RenderDXGeometricObjectBox(D3DDevice) ElseIf (tempByte And Spielfeld.btmStaticObjects) = _ Spielfeld.btmWall2 Then WallBox2.MatrixObject = PropertiesArray _ (XPosition,ZPosition).MatrixObject WallBox2.ForceToUseMatrix = True WallBox2.RenderDXGeometricObjectBox(D3DDevice) End If Next Next

Die beiden ElseIf-Anweisungen funktionieren entsprechend der ersten If-Anweisung nur mit dem Unterschied, dass hier die beiden Wandobjekte im Device dargestellt werden. 22 23 24 25 26

Return True Catch Return False End Try End Function


431

Am Ende der Funktion fangen wir noch einen eventuellen Fehler ab und beenden im Anschluss die Funktion mit der Rückgabe von True im Erfolgsfall oder False, wenn ein Fehler aufgetreten ist. Wir werden im weiteren Verlauf alle Funktionen auf diese Weise enden lassen. Wir können somit von der aufrufenden Funktion aus feststellen, ob ein Befehl funktioniert hat und dementsprechend reagieren.

Abb. 109. Spielfeldansicht nur mit statischen Objekten gerendert

Wenn wir unser Projekt in diesem Stadium starten würden, hätten wir ein Spielfeld wie in Abbildung 109 dargestellt. Es sieht noch relativ unspektakulär aus, aber man kann auf jeden Fall schon erkennen, dass die Daten aus der Textdatei übernommen worden sind und zu einem drei dimensionalen Spielfeld zusammengefügt wurden. Unser Bild zeigt eine Ansicht des Spielfeldes direkt von oben. Würden wir unseren Blick in die entgegengesetzte Richtung drehen, würden wir sehen, dass alles rings um das Spielfeld noch genauso tiefschwarz ist wie eh und je. Um dies zu ändern und um einem Spieler die Vorstellung zu geben, er befindet sich in einer realen Welt, müssen wir uns um die nächste Technik kümmern. Wir müssen einen künstlichen Horizont oder Himmel erstellen. Das machen wir mit einem Skydome.

432


39.3 Skydome: Die Begrenzung der Spielwelt Über das Thema Skydome, auch Skysphere genannt, gibt es unzählige Artikel und Meinungen in der Welt der Spieleprogrammierung. Es werden verschiedenste Methoden und Techniken als die einzig wahren angepriesen und jede erdenkliche geometrische Form wird zu einem Himmel umfunktioniert. Wir werden uns diesem Streit enthalten und wollen hier eine Technik vorstellen, mit der wir in den vergangenen Jahren immer ziemlich gut gefahren sind. Wer darüber hinaus interessiert ist, sich an der Diskussion über den „Sky“ zu beteiligen, braucht sich nur einmal in einschlägigen Suchmaschinen im Internet umzusehen. Da sich unser Projekt hauptsächlich an Einsteiger der Spieleprogrammierung richtet, haben wir wie gesagt für das Thema Skydome eine einfach umzusetzende Variante gewählt. Wir nutzen zur Erstellung unseres Himmels eine Mesh-Datei.

Abb. 110. Skydome aus einer Mesh-Datei

Wir haben mit Hilfe eines 3D-Modellers eine Datei erstellt, die für unsere Zwecke ausreichend ist. Dazu haben wir eine Sphere erzeugt und diese am unteren Ende abgeflacht. Damit wir die Datei als Skydome einsetzen können, müssen wir diese nun in unser Projekt einbinden und richtig positionieren. Danach werden noch die Dimensionen des Objektes so angepasst, dass das gesamte Mesh-Objekt unser Spielfeld einschließt. Zum Schluss müssen wir noch dem Objekt eine Textur zuweisen und das Ganze in unserem Device darstellen. So einfach, wie es sich in der theoretischen Beschreibung unseres Skydome anhört, ist es auch. Wir benötigen nur wenige Befehlszeilen, um unsere Mesh-Datei in unser Projekt einzubinden und im Anschluss darzustellen. Was genau passiert bei der Integration unseres Sky-Meshes in unser Pro-

Skydome: Die Begrenzung der Spielwelt

433

jekt kann in Kapitel 24 nachgelesen werden. Hier werden nur noch einmal kurz die wichtigsten Punkte beschrieben, die wir benötigen, um das Objekt darzustellen. 1 2

Private SkySphere As DXStaticMesh Private SkyTexture As Direct3D.Texture

Der Skydome oder auch die Skysphere besteht in unserem Projekt aus zwei Teilen. Der erste ist eine Instanz der DXStaticMesh-Klasse, die wir wieder mit unserem Projekt verknüpft haben (Zeile 1). Der zweite ist eine Variable des Typs Texture (Zeile 2). 1 2

3

4

SkySphere = New DXStaticMesh SkySphere.CreateMesh(D3DDevice,_ "C:\Buch DX VB.NET\Media\Meshes\", "dome") SkyTexture = Direct3D.TextureLoader.FromFile(D3DDevice,_ DXUtilities.FindMediaFile(LevelVerzeichnis + "dome.jpg")) SkySphere.LadeTextureReference(SkyTexture)

In der Routine MeshObjekteInitialisieren werden nun die beiden definierten Variablen mit Leben gefüllt. Wir deklarieren die Variable SkySphere als neue Instanz der Klasse DXStaticMesh in Zeile 1. In Zeile 2 laden wir dann die Mesh-Datei dome.x in die erstellte Klasse. Als Nächste wird die Texture der Skysphere mit Hilfe des TextureLoader.FromFile-Befehles aus der Datei ausgelesen und in die vorher vorbereitete Variable abgelegt. Zu guter Letzt übergeben wie eine Referenz auf die Texture an unsere SkySphere-Klasse. An dieser Stelle haben wir die Datei schon komplett in unser Projekt eingebunden. Damit diese nun noch unsere Spielwelt einschließt, müssen wir die Größe des Mesh Objektes anpassen. Das geschieht mit den größen Paramatern des Scale-Befehls der DXStaticMesh-Klasse in der nächsten Zeile. 5

SkySphere.Scale(16, 12, 16)

Zum Abschluss müssen wir die Skysphere nur noch an die richtige Stelle positionieren. Da wir den Mittelpunkt der Mesh-Datei bei der Erstellung genau in der Mitte der Sphere gewählt haben, also bei den Koordinaten 0,0,0, können wir nun die Position des Objektes ganz leicht über die Xund Z-Position bestimmen. 6 7

SkySphere.X_Position = 14.5 SkySphere.Z_Position = 12

434


Wenn das Erstellen des Domes bis jetzt ziemlich einfach war, ist das Rendern dagegen ein Klacks. Mit dieser einzigen Zeile in der Renderroutine können wir unsere SkySphere im D3DDevice darstellen. 1

SkySphere.StaticMeshObjektRendern(D3DDevice)

Abb. 111. Spielfeld mit Skydome

Nun hat unsere Spielwelt einen Himmel. Durch die Wölbung der Sphere entsteht dabei sogar der Eindruck eines Horizonts. Wir haben in unserem Fall als Texture einen einfachen Himmel gewählt. Es bleibt aber Ihnen überlassen, sich für Ihr nächstes Projekt eine für Sie passende Textur zu erstellen. An dieser Stelle sei noch einmal erwähnt, dass es sich bei diesem Skydome um die einfachste Art der Umsetzung dieses Thema handelt. Es gibt noch etliche andere Möglichkeiten, dieses Thema anzugehen, diese sollten Sie aber erst dann ansehen, wenn Sie mit der „Denkweise“ von DirectX vertraut sind und einige Erfahrung im Umgang mit dieser Programmierschnittstelle haben. Da wir nun eine komplette Spielwelt erstellt haben, ist der nächste logische Schritt, dass wir diese Welt auch erkunden wollen, deshalb beschäftigen wir uns im nächsten Kapitel mit unserem direkten Vertreter in unserer Spielwelt, nämlich der Spielfigur.

40 Die Spielfigur

Das wohl wichtigste Objekt in jedem Spiel ist die Spielfigur, d.h. das Objekt, das den Spieler vor dem Computer innerhalb der Spielwelt vertritt. Die Spielfigur ist sehr wichtig, da diese je nach Kameraperspektive am häufigsten, wenn nicht sogar ständig, zu sehen ist. Man sollte deshalb vor der eigentlichen Programmierarbeit einige Zeit darauf verwenden, die Spielfigur ordentlich zu planen und zu designen. Wenn man dann eine Vorstellung hat, wie sein Charakter aussehen soll, muss man sich ausgiebig mit der Umsetzung dieses Plans beschäftigen. Dazu gehört auch einige Erfahrung mit einem 3D-Modeller, mit dem man dann sein dreidimensionales Objekt erstellen kann. An dieser Stelle wollen wir darauf hinweisen, dass es ziemlich viel Arbeit macht, eine ordentliche Spielfigur zu erfinden und anschließend zu erstellen. Da wir auf dem Gebiet des 3D-Designs leider nicht zu den führenden Köpfen zählen, haben wir uns bei unserer Spielfigur auf einfache Formen beschränkt.

Abb. 112. Konzeptentwurf der Spielfigur (Bleistiftzeichnung)

436

Die Spielfigur

40.1 Die Techniken der Spielfigur Nun haben wir also das Konzept für unsere Spielfigur und je nach Fertigkeit auch eine mehr oder minder schöne Umsetzung des Ganzen als 3DObjekt. Damit jetzt aus dem 3D-Objekt eine Spielfigur wird, mit der der Spieler vor dem Computer die Spielwelt erkunden kann müssen wir uns noch Gedanken um ein paar andere Dinge machen. Folgende Punkte sind zu überlegen: Wie soll der Bewegungsablauf meiner Spielfigur aussehen, kann sich meine Spielfigur im Spiel bewegen, welche Grenzen sollen meinem Spieler gesteckt sein und reagiert der Spieler auf seine Umwelt? Diese vier Punkte sollte man bei der Integrierung des Spielers in das Spiel immer im Hinterkopf haben. Am besten ist es jedoch, die Techniken für diese Punkte schon umgesetzt zu haben, bevor der Spieler überhaupt in das Spiel eingefügt wird. Wir werden im Folgenden unsere Überlegungen zu diesen vier Punkten einmal näher erläutern und die technische Umsetzung vorstellen.

40.1.1 Bewegungsablauf – Animation der Spielfigur Erst einmal wollen wir hier das Thema Bewegungsablauf bzw. die Animation unserer Spielfigur vorstellen. Über die generelle Technik der Animation von Mesh-Dateien haben wir ja schon in Kapitel 25 gesprochen. Hier interessiert uns der Einsatz dieser Technik in unserem Spiel und was wir dabei beachten müssen. Zuerst stellen wir ein paar allgemeine theoretische Überlegungen an. Bei der Keyframe-Animation, die wir für unser Projekt benutzen, müssen wir Keyframes für jede Bewegung haben, die wir machen wollen. Deshalb sollten wir uns vorher im Klaren sein, welche Bewegungen wir mit unserer Spielfigur ausführen wollen, und die entsprechenden Keyframes erstellen. Je nach Komplexität des Bewegungsablaufes müssen wir hier mit mehreren Keyframes pro Bewegung rechnen. Dabei kommt es auch darauf an, wie natürlich und detailreich die Bewegung sein soll. Dies wollen wir anhand des Beispiels mit dem Ball erläutern, welches wir bei der Erklärung der Mesh-Animation benutzt haben. Wir sehen uns zur Erinnerung noch einmal das Bild aus diesem Beispiel an.

Die Techniken der Spielfigur

437

Abb. 113. Beispiel einer Mesh-Animation

Auf dem Bild sehen wir den Bewegungsablauf des Balles. Die dunklen Bälle stellen die Keyframes dar und die hellen Bälle sind die durch Interpolation errechneten Objekte. Wir sehen, dass sich die Form des Balles zu keiner Zeit verändert. Dieses ist zwar für die Animation der Szene von Vorteil, aber nicht realistisch. Wenn wir für unsere Spielwelt eine realistische Physik voraussetzen, hätte der Ball in unserer Szene zwei Möglichkeiten. Entweder das Material des Balles ist so hart, dass es sich nicht verformt, dann müsste der Winkel, in dem der Ball wieder vom Boden abspringt, minimal sein, oder der Ball verformt sich beim Aufprall und kann danach in der abgebildeten Form wieder davon springen. Wenn wir also wollen, dass der Ball wieder vom Boden abspringt, müssen wir uns für die Verformung des Objektes entscheiden. Wir müssen also zu der Szene zwei weitere Keyframes hinzufügen, die den Ball kurz vor dem Aufprall und kurz nach dem Abprall zeigen. Außerdem müssen wir den mittleren Keyframe, den direkten Aufprall des Balles, modifizieren. Dieser Frame sollte dann einen verformten Ball zeigen. Wir müssen also bei unserem Beispiel zwei Keyframes einfügen, um die ganze Szene realistischer zu machen. Würden wir darauf verzichten, die beiden erwähnten Frames einzufügen, und nur eine Verformung des mittleren Objektes durchführen, hätten wir als Ergebnis, dass durch die Interpolation der Objekte die Verformung des Balles schon in der Mitte der Flugbahn sichtbar würde. Dies wäre dann noch unrealistischer als die Ausgangssituation, das Springen des Balles ohne jegliche Verformung. Wir sehen also, dass je mehr Rea-

438

Die Spielfigur

lismus wir in unsere Bewegung bringen wollen, desto mehr Vorarbeit müssen wir leisten. Der zweite Punkt, den man bei der Entwicklung der Bewegungsabläufe berücksichtigen sollte, ist das Zusammenspiel der einzelnen Bewegungen. Für diesen Punkt gibt es unseren Erfahrungen nach zwei Lösungsmöglichkeiten: Zum einen kann man seine Spielfigur in voneinander unabhängige Teile aufsplitten. Diese Teile kann man dann unabhängig voneinander bewegen und damit zu jeder Zeit jede mögliche Bewegung durchführen. Dieses ist aber schon die hohe Kunst der Animation und sollte uns als Anfänger noch nicht interessieren. Als zweite Möglichkeit der Synchronisation von Bewegungsabläufen gilt es, einen Basisframe zu nutzen, von dem jede Bewegung ausgeht und mit dem jede Bewegung endet. Das ist zwar nicht unbedingt die realistische Art, aber für den Anfang die einfachste Möglichkeit, seine Bewegungen zu koordinieren. Generell ist es anzuraten, einen Bewegungsablauf so zu kreieren, dass der Anfang und das Ende der Bewegung an der gleichen Stelle bzw. in der gleichen Stellung erfolgt. Für den Anfang haben wir uns bei der Bewegung aber auf einen Bewegungsablauf beschränkt. Dieser Bewegungsablauf ist eine einfache Laufbewegung, die wir mit Hilfe von fünf Keyframes realisieren können. In unserem Projekt sieht die Integration der Spielfigur und die Umsetzung der Bewegung wie folgt aus: Das eigentliche Einbinden der Spielfigur ist denkbar einfach. Wir haben im Vorfeld die Klasse DXDynamicMesh mit unserem Projekt verknüpft und im Deklarationsbereich der frmStart-Klasse eine Variable definiert. Diese Instanz der Klasse (clsSpielfigur) füllen wir nun mit Leben. In Zeile 1 wird die Variable instanziert. Mit dem Befehl CreateDynamicMesh der Klasse werden die 5 einzelnen Frames geladen und in der Klasse hinterlegt. Den genauen Ablauf dieser Funktion lesen Sie bitte in Abschnitt 25.3 nach. Danach muss noch die passende Textur für den Spieler geladen werden. Als Abschluss passen wir die Größe des Objektes an unsere Spielwelt an. 1 2

3

4

clsSpielfigur = New DXDynamicMesh clsSpielfigur.CreateDynamicMesh(D3DDevice, _ "C:\Buch DX VB.NET\Media\Meshes\", "NewSpieler", 4) clsSpielfigur.LadeTexture(D3DDevice, DXUtilities_ .FindMediaFile(LevelVerzeichnis + "player.jpg")) clsSpielfigur.Scale(0.7, 0.7, 0.7)

Zu Beginn des Kapitels haben wir bereits den zeitlichen Faktor bei der Darstellung unseres Bewegungsablaufes erklärt. An dieser Stelle wollen


439

wir nur noch mal kurz zusammenfassen. Um eine gleichförmige Bewegung zu erhalten, hat unsere gesamte Bewegung eine Dauer von einer Sekunde. Wir müssen also bei jedem Renderdurchlauf feststellen, wie viel Zeit vergangen ist, seitdem die letzte Bewegung vollendet wurde. Das geschieht mit den Befehlen im nächsten Befehlsblock. 1

2 3 4 5

intCurTime = intCurTime + (Environment.TickCount - _ lastCurTime) If intCurTime > 1000 Then intCurTime = 0 End If lastCurTime = Environment.TickCount

Mit Hilfe des nächsten Abschnittes legen wir nun die beiden Keyframes fest, die zur Berechnung des nächsten Bildes zu verwenden sind. 1 2 3

4 5 6 7

Dim i As Integer For i = 0 To 3 If intCurTime >= clsSpielfigur.objAnimation(i). _ TimeIndex Then lastAnim = i nextAnim = lastAnim + 1 End If Next i

Zu guter Letzt müssen wir die Informationen nur noch benutzen, um den aktuellen Frame zu rendern. An dieser Stelle berücksichtigen wir einen Wert, den wir erst etwas später kennen lernen werden. Dieser Wert zeigt uns an, ob unsere Spielfigur vor einer Wand steht. Wenn dem so ist, brauchen wir unseren Spieler nämlich nicht zu animieren, sondern wir wählen einfach unseren Basisframe aus, um das nächste Abbild unseres Objektes zu erstellen. 1 2 3 4 5 6

If StandForWall = False Then .CalculateFrame(lastAnim, nextAnim, intCurTime) Else ……… .CalculateFrame(0) End If

An dieser Stelle haben wir also das Einfügen der Spielfigur abgeschlossen. Sollten wir das Projekt in diesem Stadium starten, könnten wir eine Spielfigur sehen, die ohne Pause immer auf der Stelle laufen würde, da wir zwar den Bewegungsablauf, sprich die Animation, erstellt haben, aber der Spieler an sich immer auf der gleichen Stelle stehen bleibt. Um dies zu ändern,

440

Die Spielfigur

müssen wir zum Bewegungsablauf noch die eigentliche Bewegung hinzufügen.

40.1.2 Bewegung der Spielfigur In diesem Abschnitt wollen wir unserem Spieler außer der eigentlichen Animation auch noch eine Bewegung über das Spielfeld ermöglichen. Dazu müssen wir uns aber erst einmal im Klaren sein, wie wir dies umsetzen können. Wir wissen, dass wir jedes Objekt innerhalb unseres Direct3DDevices über seine Matrix platzieren und verändern können. Da bietet es sich an, diesen Effekt für unsere Zwecke voll auszunutzen. Wir werden also die Bewegung unserer Spielfigur über das Spielfeld über die Matrix unseres Spielobjektes realisieren. Es stellt sich die Frage, welche Werte innerhalb der Matrix des Objektes verändert werden müssen, um unserer Spielfigur das Laufen beizubringen? Da sich unser gesamtes Spiel in einer Ebene abspielt, brauchen wir uns bei der Veränderung des Standortes der Spielfigur nur um zwei Richtungen zu kümmern. Die Y-Position unserer Spielfigur ändert sich demnach im gesamten Spiel nicht. Ausschließlich die X- und Z-Positionen müssen verändert werden. Außer der eigentlichen Positionsveränderung müssen wir auch noch einen weiteren Umstand beachten. Unser Spieler soll also durch das Labyrinth laufen und da man im Allgemeinen vorwärts läuft, d.h. mit dem Gesicht nach vorne gerichtet, müssen wir neben der Position des Spielers auch noch dessen Blickrichtung kontrollieren. Es ist also unsere Aufgabe, bei der Bewegung des Spielers die erwähnten drei Parameter unter Kontrolle zu halten und mit Hilfe dieser Werte unsere Spielfigur im Spielfeld zu platzieren. Die eigentliche Platzierung und Ausrichtung der Spielfigur ist dabei schnell geschehen. Kurz bevor unser Objekt in unserem Device gerendert wird (Zeile 7), weisen wir unserer Figur die vorher errechneten Werte zu. In Zeile 2 wird die aktuelle Blickrichtung übergeben, danach in den Zeilen 3 5 die vorgesehenen Y-, X- und Z-Positionen. Wobei wie vorher erwähnt die Y-Position immer gleich ist. 1 2 3 4 5 6 7 8

With clsSpielfigur .AngleY = StructSpielfigur.DirectionCounter .Y_Position = 1 .X_Position = StructSpielfigur.AktuellerPunkt.x .Z_Position = StructSpielfigur.AktuellerPunkt.z … .DynamicMeshObjektRendern(D3DDevice) End With


441

40.1.3 Relative Bewegungen im Spiel Da das Zuweisen der aktuellen Veränderung kein Problem ist, sehen wir uns nun an, wie wir zu den Werten kommen. Dazu müssen wir an dieser Stelle kurz den beiden nächsten Kapiteln mit dem Thema Steuerung und Kamera vorgreifen. Wir werden sehen, dass wir für unser Spiel eine Verfolgerperspektive gewählt haben, d.h., unsere Sicht auf unser Objekt wird immer die gleiche sein. Der Spieler vor dem PC wird seine Spielfigur immer von hinten beobachten, ihm sozusagen über die Schulter blicken. Um das realisieren zu können, konnten wir für unser Spiel keine festen Bewegungsrichtungen festlegen, sondern mussten die nächste Bewegung immer relativ zur aktuellen Bewegung berechnen. Diese Methode werden Sie auch bei manch anderen 3D-Spielen finden. Da man sich bei den Spielen meistens frei im Raum bewegen kann, ist es unabdingbar, die nächste Bewegung immer an der aktuellen auszurichten. Da die freie Bewegung im Raum gar nicht so einfach umzusetzen ist, haben wir uns entschieden, für unser erstes Spielprojekt die Bewegung einzuschränken. Nach dem Vorbild von einigen anderen berühmten Labyrinthspielen lassen wir für unseren Spieler nur Bewegungen in vier Richtungen zu. Aber wie setzen wir nun diese Vorgehensweise in unserem Projekt um? Wie erwähnt wollen wir für unser Objekt die vier Himmelsrichtungen als Laufrichtungen zulassen. Demnach ist also festgelegt, welche Änderungen mit der Position unserer Spielfigur vollzogen werden muss, wenn wir die Bewegungsrichtung unseres Objektes ändern. Diese Änderungen haben wir in unserem Projekt in einer Struktur abgelegt. Diese Struktur hat folgende Eigenschaften: 1 2 3 4 5 6 7

Public Structure _DirectionStruct Dim Direction As Integer Dim KomplettXAdd As Single Dim KomplettZAdd As Single Dim SchrittXAdd As Single Dim SchrittZAdd As Single End Structure

Als Erstes wird in der Struktur die Richtung in Grad angegeben, die die aktuelle Bewegung haben soll. Danach werden noch die Positionsänderungen übergeben, die eine Auswahl dieser Bewegungsrichtung zur Konsequenz haben. Die beiden Werte in Zeile 3 und 4 speichern die Xund Z- Änderungen, die ausgeführt sein müssen, bevor die nächste Bewegung gemacht werden darf. Zeile 5 und 6 beschreiben die Änderungen die bei dieser Bewegung pro Renderdurchlauf gemacht wird.

442

1

Die Spielfigur

Private StructDirectionSpieler(3) As _DirectionStruct

Da wir insgesamt vier Bewegungsrichtungen haben, erstellen wir ein Array mit vier Elementen, die wir mit den einzelnen Werten füllen. Wir erläutern die Werte anhand des ersten Elements des Arrays. 1 2 3 4 5 6 7

With StructDirectionSpieler(0) .Direction = 0 .KomplettXAdd = 0 .KomplettZAdd = -1 .SchrittXAdd = 0 .SchrittZAdd = -1 * StructSpielfigur.Speed End With

Bei der Richtung 0 soll also die Blickrichtung unseres Spielobjektes 0 Grad sein (Zeile 2). Wenn wir in diesem Spiel dieses Element als Richtung auswählen, soll die Bewegung so lange stattfinden, bis die Figur seine Position um –1 in Richtung der Z-Achse geändert hat. Der Wert der X-Achse soll dementsprechend nicht geändert werden (Zeile 3 - 4). In den nächsten beiden Zeilen wird dann noch die passende Schrittweite festgelegt. Wir legen diese Bewegungsparameter für alle vier Richtungen in der Funktion BewegungsEinstellungen in der Klasse frmStart fest. Wir haben nun alle benötigten Werte für die Bewegung über den Index des StructDirectionSpieler-Arrays im Zugriff. Deshalb werden wir ab jetzt nicht mehr mit den direkten Werten arbeiten, sondern mit dem Indexwert des Arrays. Nun wissen wir, welche Positionsänderungen unsere Figur vornehmen darf. Jetzt müssen wir uns die Funktionen ansehen, die diese Bewegungen in unserem Spiel umsetzen. Dazu betrachten wir aber zuerst zwei weitere Strukturen, die wir für die Bewegung in unserem Projekt nutzen. Da unser gesamtes Spiel auf einem zweidimensionalen Feld beruht, können wir alle Objekte über ihre Koordinaten X und Z bestimmen. Dazu benutzen wir die Structure _Punkt in unserem Projekt. 1 2 3 4

Public Structure _Punkt Public x As Single Public z As Single End Structure

Die zweite Structure, die wir benötigen, ist _DynamicObject. Mit Hilfe dieser Struktur speichern wir alle aktuellen Daten unserer dynamischen Objekte. Sie ist so aufgebaut, dass man alle Werte speichern kann, die wir für unsere relativen Bewegungen brauchen.


443

Da wir für unsere relative Bewegung immer die Ausgangsrichtung und die Zielrichtung kennen müssen, speichern wir in den ersten beiden Variablen den Index des StructDirectionSpieler-Arrays, der die Richtung bezeichnet. Die Variable DirectionCounter in Zeile 4 dient im Verlauf des Spieles dazu, die aktuelle Blickrichtung unseres Objektes zu speichern. Mit der Variablen Speed aus Zeile 5 legen wir die Entfernung fest, die das Objekt pro Renderdurchlauf bewegt werden soll. Die drei nächsten Befehlszeilen definieren Punkte innerhalb des Koordinatensystems unseres Spielfeldes. Die genaue Funktion werden wir im Laufe dieses Abschnittes noch erklären. In Zeile 9 speichern wir zum Schluss noch die Laufrichtung, die der Spieler vor dem PC seiner Spielfigur vorgegeben hat. 1 2 3 4 5 6 7 8 9 10 11

Public Structure _DynamicObject Dim currentDirection As Integer Dim desiredDirection As Integer Dim DirectionCounter As Integer Dim Speed As Single Dim StartPunkt As _Punkt Dim ZielPunkt As _Punkt Dim AktuellerPunkt As _Punkt Dim Laufrichtung As Integer ... End Structure

40.1.4 Logik der Bewegung Der Ausgangspunkt für die Bewegung unserer Spielfigur innerhalb der Spielwelt ist die Funktion SpielerLogik in der frmStart-Klasse. In dieser Routine entscheiden wir in jedem Renderdurchlauf, was mit dem Objekt geschehen soll. 1 2 3 4

Public Function SpielerLogik() Dim tempByte As Byte With StructSpielfigur If (.ZielPunkt.x = .AktuellerPunkt.x) And _ (.ZielPunkt.z = .AktuellerPunkt.z) Then

Da unser gesamtes Spielfeld auf vielen einzelnen Feldern basiert, haben wir festgelegt, dass sich unsere Spielfigur von Feld zu Feld bewegen muss. Das heißt, jede Bewegung im Spiel ist immer genau ein Feld lang. Dies stellen wir mit der If-Anweisung in Zeile 4 fest. Erst wenn die aktuelle Position der X- und Z-Position der vorher festgelegten entspricht, wird eine neue Aktion des Spielers zugelassen. Stimmen die Positionen nicht über-

444

Die Spielfigur

ein, wird in die Zeile 30 gesprungen, wo die aktuelle Bewegung fortgesetzt wird. 5 6 7

8 9

10 11 12 13 14

.StartPunkt = .ZielPunkt Try tempByte = CType(Spielfeld.GetArrayPositionValue_ ((.StartPunkt.x - 0.5) + StructDirectionSpieler_ (.desiredDirection).KomplettXAdd, _ (.StartPunkt.z - 0.5) + StructDirectionSpieler_ (.desiredDirection).KomplettZAdd), Byte) Catch ex As Exception If TypeOf ex Is System._ IndexOutOfRangeException Then StandForWall = True Else Throw New Exception(ex.Message) End If End Try

Wenn wir die Zeile 5 erreicht haben, ist die letzte gewählte Bewegung abgeschlossen. Deshalb müssen wir als Erstes den alten ZielPunkt zu unserem neuen StartPunkt machen, von dem die nächste Bewegung anschließend ausgeht. In Zeile 7 rufen wir den Status des nächsten Feldes ab, das wir betreten wollen. Dazu gehen wir vom aktuellen StartPunkt des Spielers aus und berechenen den nächsten Punkt mit Hilfe der Werte aus unserem StructDirectionSpieler-Array. Wobei der Eintrag, das Element des Arrays, durch die Zielrichtung unseres Objektes bestimmt wird. Da wir mit dem ermittelten Wert wieder eine Bitmaskierung durchführen wollen, konvertieren wir das ausgelesene Ergebnis direkt wieder in einen Byte-Wert. Sollte es bei dieser Abfrage des Arrays zu einem Fehler des Typs IndexOutOfRangeException kommen, liegt das aktuelle Spielfeld, auf dem sich der Spieler befindet, am Spielfeldrand und wir können nicht weiter vorwärts gehen. Dieser Fehler wird daher in der Zeile 9 abgefangen und die Variable StandForWall wird gesetzt, um den Spieler anzuhalten. Der Spieler muss dann in eine andere Richtung gelenkt werden. 15

16

17

If (tempByte And SpielfeldClass.btmDynamicObjects) _ 0 Then If (tempByte And SpielfeldClass._ btmDynamicObjects) = SpielfeldClass._ btmEnergyPill Then Spielfeld.SetArrayPositionValue(_ (.StartPunkt.x - 0.5) + _ StructDirectionSpieler(.desiredDirection)_ .KomplettXAdd, (.StartPunkt.z - 0.5) + _


18 19

445

StructDirectionSpieler(.desiredDirection)_ .KomplettZAdd, 1) End If End If

Mit dem ermittelten Wert stellen wir fest, ob sich auf dem Feld, das wir betreten wollen, ein dynamisches Objekt befindet. In unserem Fall interessiert uns nur, ob sich auf dem nächsten Feld eine Energiepille befindet. Sollte das der Fall sein, löschen wir die Kennung der Energiepille von dem Feld, das wir als Nächstes betreten werden. 20

21 22

If (tempByte And SpielfeldClass.btmStaticObjects) SpielfeldClass.btmGround Then StandForWall = True End If

Nachdem wir festgestellt haben, ob sich ein dynamisches Objekt auf dem nächsten Feld befindet, müssen wir herausfinden, ob wir das nächste Feld überhaupt betreten dürfen. Mit den Zeilen 13 - 15 überprüfen wir, welche Kennung der ermittelte Wert hat. Sollte dieser Wert nicht dem Wert der Bodenplatte entsprechen, setzen wir die globale Variable StandForWall auf True und signalisieren damit allen anderen Routinen, die jetzt noch folgen, dass unsere Spielfigur vor einer Wand steht. 23 24 25 26 27 28 29

If (.desiredDirection .currentDirection) Then SpielerDrehung() ForceStepAhead = True Else SpielerLaufen() ForceStepAhead = False End If

Jetzt, da wir festgestellt haben, ob wir das nächste Feld betreten dürfen oder nicht, werten wir die Vorgaben des Spielers vor dem PC zur Bestimmung der nächsten Bewegung aus. Wir überprüfen, ob die gewünschte Laufrichtung (desiredDirection) des Spielers ungleich der aktuellen Laufrichtung (currentDirection) ist. Sollte dies der Fall sein, müssen wir eine Drehung ausführen. Dazu rufen wir die Funktion SpielerDrehung() auf. Wenn die beiden überprüften Richtungen übereinstimmen, dann wird die Funktion SpielerLaufen() aufgerufen, die dann den nächsten Schritt des Spielers einleitet. An dieser Stelle haben wir zusätzlich noch eine Variable eingefügt, um den Spielablauf zu verbessern. Diese Variable ForceStepAhead sorgt dafür, dass die Spielfigur nach Vollendung einer Drehung automatisch in die gewählte Richtung

446

Die Spielfigur

weiterläuft. Die beiden Funktionen, die die Drehung bzw. das Laufen ausführen, sehen wir uns in den nächsten beiden Abschnitten an. 30 31

32

33 34 35

Else .AktuellerPunkt.x += StructDirectionSpieler_ (.currentDirection).SchrittXAdd .AktuellerPunkt.z += StructDirectionSpieler_ (.currentDirection).SchrittZAdd End If End With End Function

Wenn wir am Anfang der Funktion festgestellt haben, dass wir noch nicht den Zielpunkt erreicht haben und somit noch die Änderung der Bewegung zulässig ist, führen wir die angefangene Bewegung einfach weiter aus. Dies geschieht, indem wir zu der aktuellen Position des Spielers (AktuellerPunkt) die Schrittwerte des Arrayelementes hinzufügen, das über die aktuelle Laufrichtung (currentDirection) bestimmt wird. 40.1.5 Drehung der Spielfigur Die erste Bewegung, die unsere Spielfigur ausführen kann, ist eine Drehung. Zum besseren Verständnis der Funktion SpielerDrehung, die wir in diesem Abschnitt erklären wollen, haben wir das StructDirectionSpieler-Array einmal grafisch dargestellt. Mit Hilfe dieses Arrays und den Indexwerten des Arrays bereiten wir die Drehung des Objektes vor und führen sie danach aus.

Abb. 114. Mögliche Bewegungsrichtungen des Spielers


447

Wenn wir uns die Anordnung der einzelnen Indexwerte ansehen, stellen wir fest, dass sich eine komplette Drehung des Objektes durch den Aufruf aller Indizes von 0 bis 3 realisieren lässt. Um ein stufenloses Drehen des Objektes sicherzustellen, brauchen wir also nur den Übergang zwischen den Indexwerten 0 und 3 in beide Richtungen abzufangen. Wie wir das programmiertechnisch umgesetzt haben, ist in der nachfolgenden Erklärung der Subroutine SpielerDrehung() zu sehen. 1 2 3

4 5 6 7 8

Public Sub SpielerDrehung() With StructSpielfigur If .desiredDirection = 0 And .currentDirection = 3 Then . DirectionCounter += 10 If .DirectionCounter >= 360 Then . DirectionCounter = 0 . currentDirection = .desiredDirection End If

Nach dem Start der Subroutine überprüfen wir als Erstes eine unserer beschriebenen Ausnahmen bei der Drehung des Objektes. In Zeile 3 fragen wir die gewünschte Laufrichtung (desiredDirection) und die aktuelle Laufrichtung (currentDirection) ab. Wenn die Spielfigur aktuell in Richtung 3 läuft und als Nächstes die Richtung 0 gewählt wurde, wird der Zähler der aktuellen Blickrichtung so lange erhöht, bis die 360 überschritten ist. Das Objekt wird somit nach rechts gedreht. Wenn die 360 überschritten ist, wird der Zähler auf 0 gesetzt und dem System mitgeteilt, dass die gewünschte Richtung ab jetzt die aktuelle Richtung ist. 9

10

11

12 13 14 15

ElseIf .desiredDirection = 3 And .currentDirection = 0 Then If .DirectionCounter StructDirectionSpieler_ (.desiredDirection).Direction Then . DirectionCounter -= 10 Else . currentDirection = .desiredDirection End If

Anschließend müssen wir die Bewegung unseres Objektes in die umgekehrte Richtung abfangen. In Zeile 9 starten wir damit, indem wir feststellen, ob die gewählte Laufrichtung 3 ist und die aktuelle 0. Sollte dies der Fall sein, leiten wir eine Linksdrehung ein. Da bei einer aktuellen Laufrichtung des Indexes 0 der DirectionCounter auch 0 anzeigt, müssen wir diesen Wert auf 360 setzen, um eine Drehung zu ermöglichen. In Zeile 11 startet dann die If-Else-End-If-Schleife. Diese stellt si-

448

Die Spielfigur

cher, dass unser Objekt so lange gedreht wird, bis die gewünschte Richtung erreicht ist. Danach wird die aktuelle Laufrichtung wieder der gewünschten Laufrichtung gleichgesetzt. Die beiden lezten Blöcke der Funktion sind eher unspektakulär. In Zeile 16 startet der Block, der sicherstellt, dass bei einer Rechtsdrehung des Objektes die Drehung so lange ausgeführt wird, bis die aktuelle Laufrichtung der gewünschten entspricht. Das Gleiche macht der ElseIf-Block ab Zeile 22 für die gewählte Linksdrehung. 16 17

18 19 20 21 22 23

24 25 26

27 28 29 30

ElseIf .desiredDirection >= .currentDirection Then If .DirectionCounter < StructDirectionSpieler_ (.desiredDirection).Direction Then . DirectionCounter += 10 Else .currentDirection = .desiredDirection End If ElseIf .desiredDirection StructDirectionSpieler_ (.desiredDirection).Direction Then . DirectionCounter -= 10 Else .currentDirection = StructSpielfigur._ desiredDirection End If End If End With End Sub

Somit ist die erste Bewegungsart, die Drehung in beide Richtungen, realisiert. Wir haben sichergestellt, dass es keine Lücken im Bewegungsablauf der Drehung gibt. Auch wählen wir immer den kürzeren der beiden möglichen Wege bei einer Drehung. Die Funktion stellt also selbstständig fest, ob eine Linksdrehung schneller ist als eine Rechtsdrehung. Im nächsten Abschnitt werden wir jetzt die zweite Bewegungsart der Spielfigur kennen lernen, die Bewegung von einem Spielfeld auf das nächste.

40.1.6 Laufen der Spielfigur Da sich unsere Spielfigur jetzt in alle gewünschten Richtungen drehen kann, kommen wir nun zu der wichtigsten Bewegung unserer Spielfigur, dem Laufen. In der Funktion SpielerLaufen(), die wir benutzen, um die Laufbewegung in Gang zu setzen, treffen wir auch zum ersten Mal auf eine Möglichkeit des Spielers vor dem PC auf unser Spielobjekt Einfluss


449

zu nehmen. Wir werten innerhalb der Routine die Variable Laufrichtung der StructSpielfigur-Struktur aus. In diese wird an anderer Stelle die Tastatureingabe des Spielers gespeichert. Die Funktion der Tastatureingabe werden wir im Anschluss an dieses Kapitel erläutern. Da wir uns auf unserem Spielfeld relativ zu der aktuellen Laufrichtung bewegen, reicht es, wenn wir in unserer Routine 4 Tastatureingaben unterscheiden. Wir unterscheiden diese Eingaben mit einer Select-Case-EndSelect-Abfrage. 1 2 3 4 5 6 7

Public Function SpielerLaufen() With StructSpielfigur Select Case .Laufrichtung Case 1 ' istRechts StandForWall = False .desiredDirection = .desiredDirection + 1 If .desiredDirection > 3 Then _ .desiredDirection = 0

Der erste Case-Fall mit dem Wert 1 (Zeile 4) repräsentiert eine Drehung unseres Objektes nach rechts, dabei wird als Erstes die Variable wieder auf False gesetzt, die ein eventuelles Stehen des Objektes vor einer Wand anzeigt. Danach wird die gewünschte Laufrichtung um 1 erhöht und somit die Rechtsdrehung angestoßen. Wie wir aus dem Abschnitt Drehung der Spielfigur wissen, müssen wir immer den Übergang des Arrayindexes von 3 nach 0 gesondert abfangen, dass machen wir mit der If-ThenAnweisung in Zeile 7. 8 9 10 11

Case 2 ' istLinks StandForWall = False .desiredDirection = .desiredDirection - 1 If .desiredDirection < 0 Then _ .desiredDirection = 3

Der Wert 2 in der Case-Anweisung steht für die Drehung unserer Figur nach links. Die Funktionen sind dieselben wie in ersten Case-Block. Der Unterschied ist nur, dass wir für die Linksdrehung von der gewünschten Zielrichtung eine Stelle abziehen und wir abfangen müssen, dass der Arrayindex nicht unter 0 fällt. 12 13 14 15

16

Case 3 ' istHoch If StandForWall = False Then ' neuen Zielpunkt setzen .ZielPunkt.z += StructDirectionSpieler_ (.currentDirection).KomplettZAdd .ZielPunkt.x += StructDirectionSpieler_ (.currentDirection).KomplettXAdd

450 17

18

19

20

Die Spielfigur ' um kein Stocken in der Bewegung zu haben muss ' hier auch ein Schritt ausgeführt werden .AktuellerPunkt.x += StructDirectionSpieler_ (.currentDirection).SchrittXAdd .AktuellerPunkt.z += StructDirectionSpieler_ (.currentDirection).SchrittZAdd End If

Im dritten Case-Block fangen wir den Fall ab, dass der Spieler die Taste für die Vorwärtsbewegung gedrückt hat. Es soll also keine Drehung ausgeführt werden, sondern unsere Spielfigur soll einen Schritt nach vorn machen. Wir können allerdings nur einen Schritt nach vorn ausführen, wenn wir nicht vor einem undurchdringlichen Objekt stehen. Dies können wir feststellen, wenn wir die Variable StandForWall in Zeile 13 auswerten. Diese Variable wird im Spielverlauf immer dann auf True gesetzt, wenn sich der Spieler vor einem Objekt befindet, das er per Definition nicht durchschreiten kann. Kann der Spieler das nächste Feld betreten, die Variable StandForWall ist also False, dann wird der nächste Schritt unseres Spielobjektes initiiert. Dazu legen wir die neuen Zielkoordinaten für unser Objekt fest. Mit Hilfe der aktuellen Laufrichtung und unserem StructDirectionSpieler-Array können wir die nächste Position des Spielers ermitteln und der Struktur ZielPunkt übergeben (Zeile 15/16). Damit wir innerhalb der Laufbewegung kein Stocken in den Bewegungsablauf bekommen, müssen wir neben der Festlegung der neuen Zielkoordinaten auch schon den ersten Schritt ausführen. Das geschieht mit den Zeilen 18 und 19. 21 22 23 24 25 26 27 28 29 30 31 32 33 34

Case 4 ' istRunter StandForWall = False If .desiredDirection = 0 Then _ .desiredDirection = 2 ElseIf .desiredDirection = 1 Then _ .desiredDirection = 3 ElseIf .desiredDirection = 2 Then _ .desiredDirection = 0 ElseIf .desiredDirection = 3 Then _ .desiredDirection = 1 End If End Select End With End Function

Last but not least, haben wir noch den vierten Case-Block, mit dessen Hilfe wir steuern können, dass sich unser Objekt in die entgegengesetzte Richtung der gewünschten Laufrichtung dreht. Dazu stellen wir im If-

Einfügen der Tastaturabfrage

451

ElseIf-End-If-Abfrageblock fest, welche Laufrichtung gewünscht wird und welche anstatt dieser als nächste gewählt werden soll. Jetzt haben wir alle Funktionen und Techniken erläutert, die wir innerhalb unseres Projektes benötigen, um unseres Spielfigur darzustellen und zu bewegen. Wenn wir unser Projekt an dieser Stelle starten, würden wir unseren Spieler sehen, der zwar theoretisch jede Bewegung auf dem Spielfeld ausführen kann, praktisch aber nur in der Ecke herumsteht. Was wir jetzt also noch brauchen, sind die Mittel, unserem Objekt die entsprechenden Bewegungsbefehle zu übermitteln. Diese Übermittlung der Befehle wird in unserem Projekt über die Tastatur realisiert. Zu dieser Realisierung kommen wir im nächsten Abschnitt.

Abb. 115. Spielfigur im Spielfeld

40.2 Einfügen der Tastaturabfrage Im letzten Kapitel haben wir uns ausführlich damit beschäftigt, unserer Spielfigur die Bewegung über das Spielfeld zu ermöglichen. Jetzt wollen wir uns darum kümmern, dass sich die Spielfigur auch nach unseren Vorstellungen über das Spielfeld bewegt. Wir werden dazu das DirectInput-Objekt nutzen. Dieses ist uns ja schon aus dem zweiten

452

Die Spielfigur

Teil des Buches bekannt. Wir beschränken uns innerhalb der API auf die Auswertung der Tastatur. Erklärungen zur genauen Funktion der API und ihrer Routinen entnehmen Sie bitte dem Kapitel 34. Wir wollen an dieser Stelle also nur verdeutlichen, wie wir die Programmierschnittstelle in unser Projekt eingebunden haben und welchen Nutzen wir daraus ziehen. Zur besseren Übersicht über unser Projekt haben wir auch für das DirectInput-Objekt eine eigene Klasse erstellt und mit unserem Spiel verknüpft. Diese Klasse haben wir wie gewohnt in unserem Deklarationsbereich definiert. 1

Private clsInput As DXInput

Nachdem wir die Klasse in unserem Projekt eingebunden und initialisiert haben, erstellen wir mit dem Befehl CreateInputDevice das nötige DirectInput-Device und geben diesem die benötigten Einstellungen mit. Public Function CreateInputDevice(ByVal Handle As _ System.Windows.Forms.Control) 2 Try 3 coopFlags = coopFlags Or DirectInput._ CooperativeLevelFlags.NonExclusive _ Or DirectInput.CooperativeLevelFlags.Background 4 DirectInputDevice = New DirectInput.Device_ (DirectInput.SystemGuid.Keyboard) 5 DirectInputDevice.Properties.BufferSize = _ sizeSampleBuffer 1

Da wir das Erstellen eines DirectInput-Devices schon ausgiebig im theoretischen Teil des Buches erklärt haben, fassen wir hier nur kurz die Funktionen der Routine zusammen. In Zeile 3 legen wir die CooperativeLevelFlags fest. Mit diesen Flags bestimmen wir, wie sich unser neu erstelltes Device im Umgang mit dem System und mit anderen Instanzen des DirectInput-Objektes verhält. Zeile 4 erstellt das neue Device, wir übergeben die GUID des Keyboards, um festzulegen, auf welches Gerät das Device reagieren soll. Mit der Zeile 5 bestimmen wir wie viele Daten das erstellte Device zwischenspeichern kann. 7

8 9 10 11 12

DirectInputDevice.SetCooperativeLevel(Handle,_ coopFlags) DirectInputDevice.Acquire() Catch dx As DirectInput.InputException Throw dx End Try End Function


453

Bevor wir nun über den Acquire()-Befehl Zugang zu dem Eingabegerät erhalten, müssen wir erst noch in Zeile 7 den CooperativeLevel des Devices einstellen. Dazu übergeben wir dem Befehl die vorher festgelegten Flags und ein Handle auf das Control, mit dem das Device verbunden wird. Wir haben somit alle Vorbereitungen getroffen, um die Tastatureingaben des Spielers vor dem PC abzufragen. Die Funktionen der DirectInput-Klasse benutzen wir in der Funktion DoGameLogic() der frmStart-Klasse. In der DoGameLogic()-Funktion rufen wir nacheinander die beiden Methoden TastaturBufferAuswerten und TastaturEingabeAuswerten auf. Den beiden Funktionen übergeben wir eine Referenz auf das Integer-Array TastaturBuffer, in dem die einzelnen Tastaturbefehle als Integer zwischengespeichert werden. Die einzelnen Schritte der beiden Funktionen sehen wir uns jetzt einmal genauer an. Wie der Name der ersten Funktion, TastaturBufferAuswerten, vielleicht schon vermuten lässt, werden in dieser Methode die Daten der Tastatureingabe ausgewertet. Dabei werden die aktuellen Eingaben der Tastatur berücksichtigt. Als Erstes initialisieren wir zwei für die Funktion benötigte Variablen und weisen diesen den Wert Nothing zu. 1

2 3

Public Function TastaturBufferAuswerten(ByRef _ TastaturBuffer() As Integer) As Boolean Dim State As DirectInput.KeyboardState = Nothing Dim IE As DirectInput.InputException = Nothing

Mit dem nächsten Sourcecode-Block ermitteln wir den Status unseres DirectInput-Devices. Dabei fangen wir eventuelle Fehlermeldungen ab und verarbeiten diese. Im Detail geschieht dies folgendermaßen: In Zeile 5 fragen wir den Status des Devices innerhalb des ersten TryCatch-End-Try-Blockes ab. Sollte es zu einem Fehler bei der Abfrage kommen, wird der zweite Fehlerbehandlungsblock gestartet. In diesem Try-Catch-End-Try-Block versuchen wir die Datenübertragung des Input-Devices mit dem Acquire()-Befehl erneut zu starten. Wenn es dabei wieder zu einem Fehler kommt, wird dieser Fehler in der Zeile 10 in die vorbereitete Variable gespeichert. Die Variable benutzen wir dann anschließend in Zeile 12 zur Auswertung der Fehlerquelle. Ist der gespeicherte Fehler akzeptabel, d.h., die Funktion des Spieles ist also nicht gefährdet, verlassen wir die Funktion, ohne eine Fehlermeldung zu generieren (Zeile 13). Sollte der Fehler aber grundlegender Natur sein, dann

454

Die Spielfigur

beenden wir die Methode mit der Rückgabe eines False-Wertes, den wir in der aufrufenden Funktion als Fehler werten. 4 5 6 7 8 9 10 11 12

13 14 15 16 17

Try State = DirectInputDevice.GetCurrentKeyboardState() Catch Try DirectInputDevice.Acquire() Catch InputExeption As DirectInput .InputException IE = InputExeption End Try If TypeOf IE Is DirectInput_ .OtherApplicationHasPriorityException Or_ TypeOf IE Is DirectInput_ .NotAcquiredException Then Return True ElseIf Not IE Is Nothing Then Return False End If End Try

An dieser Stelle der Funktion haben wir sichergestellt, dass wir auf die Daten der Tastatur zugreifen können. Dies tun wir auch sofort. Um die Tastaturdaten auszuwerten, deklarieren wir als Erstes eine temporäre Variable. Die eigentliche Auswertung geschieht in der For-Next-Schleife in den Zeilen 20 bis 25. Die Schleife wird so definiert, dass nacheinander alle Tasten der Tastatur abgefragt werden. Wir überprüfen in Zeile 21, ob die Taste, die gerade durch die Schleife geprüft wird, auch gedrückt wird. Ist dies der Fall, ist die Item-Eigenschaft des Elements auf True gesetzt und wir können den Wert der Taste in unseren eigenen TastaturBuffer übernehmen (Zeile 22/23). 18 19 20

21 22

23 24 25 26 27 28 29 30

Try Dim k As DirectInput.Key For k = DirectInput.Key.Escape To DirectInput_ .Key.MediaSelect If State.Item(k) Then ReDim Preserve TastaturBuffer_ (UBound(TastaturBuffer) + 1) TastaturBuffer(UBound(TastaturBuffer)) = k End If Next k Return True Catch Return False End Try End Function


455

Am Ende der Funktion haben wir nun alle Tastenwerte von Tasten gespeichert, die gedrückt wurden, während die Funktion TastaturBufferAuswerten ausgeführt wurde. Aus diesen Daten müssen wir nun die Informationen herausfiltern, die wir für unsere Spielerbewegung benötigen. Dazu gehen wir wie folgt vor: Wir haben im Vorfeld festgelegt, welche Informationen für unser Spiel erforderlich sind und diese innerhalb einer Enumeration abgelegt. 1 2 3 4 5 6 7 8

Public Enum Laufrichtung istNull = 0 istRechts = 1 istLinks = 2 istHoch = 3 istRunter = 4 istEnde = 5 End Enum

Mit Hilfe diese Enumeration werten wir nun in der Funktion TastaturEingabeAuswerten unseren TastaturBuffer aus. Wir gehen mit einer For-Next-Schleife alle Elemente unseres Speichers durch und werten diese mit einem Select-Case-End-Select-Block aus. Wird ein für das Spiel relevanter Tastenwert identifiziert, wird die für diesen Wert festgelegte Konstante in die klasseninterne Variable intAktuelleLaufrichtung gespeichert. Diese Variable werden wir im Anschluss auswerten. Durch die For-Next-Schleife haben wir für unsere Tastatureingabe einen LILO-Buffer (Last In Last Out) realisiert. Wir haben damit sichergestellt, dass immer die letzte Taste, die gedrückt wurde, auch ausgewertet wird. Wir werten hierbei die Tastaturcodes der vier Cursortasten sowie der ESC-Taste aus. Sollte keine auswertbare Eingabe in unserem Speicher vorliegen, wird der Wert der internen Variablen nicht geändert und somit keine neue Bewegung gestartet. 1

2 3 4 5 6 7

8 9

10

Public Function TastaturEingabeAuswerten(ByRef _ TastaturBuffer() As Integer) As Boolean Try Dim i As Integer For i = 1 To UBound(TastaturBuffer) Select Case TastaturBuffer.GetValue(i) Case 1 'Escape intAktuelleLaufrichtung =_ Laufrichtung.istEnde Case 205 'rechts intAktuelleLaufrichtung =_ Laufrichtung.istRechts Case 203 'links

456 11

12 13

14 15

16 17

18 19 20 21 22 23 24

Die Spielfigur

intAktuelleLaufrichtung =_ Laufrichtung.istLinks Case 200 'oben intAktuelleLaufrichtung =_ Laufrichtung.istHoch Case 208 ' unten intAktuelleLaufrichtung =_ Laufrichtung.istRunter Case Else intAktuelleLaufrichtung =_ Laufrichtung.istNull End Select Next Return True Catch Return False End Try End Function

Nachdem wir die beiden Funktionen zur Tastaturauswertung kennen gelernt haben, bleibt uns jetzt nur noch deren Einsatz in unserem Projekt zu beschreiben. Wie erwähnt werten wir die Tastatureingabe in der Funktion DoGameLogic() aus. 1 2

3

With clsInput If Not .TastaturBufferAuswerten(TastaturBuffer) Then_ Throw New Exception_ ("Fehler beim Auslesen der Tastatur") If Not .TastaturEingabeAuswerten(TastaturBuffer) Then_ Throw New Exception_ ("Fehler beim Auswerten der Tastatureingabe")

Als Erstes rufen wir die beiden beschriebenen Funktionen auf. Sollten die beiden Methoden den Wert False zurückgeben und damit einen Fehler melden, werfen wir eine Exception, die am Ende der DoGameLogic -Funktion ausgewertet wird. 4 5

ReDim TastaturBuffer(0) TastaturBuffer(0) = 0

Da der Wert, den wir für unsere Bewegungsauswertung nutzen, in der Input-Klasse zwischengespeichert ist, können wir sofort nach der Auswertung des TastaturBuffers diesen wieder löschen (Zeile 4/5). Danach brauchen wir nur noch die neu ermittelte Laufrichtung an unsere Spielfigur übergeben, welche anschließend in der Routine SpielerLogik() ausgewertet wird.

Einfügen des Kameramoduls 6 7 8 9 10 11 12 13

457

If .aktuelleLaufrichtung .Laufrichtung.istEnde Then StructSpielfigur.Laufrichtung = .aktuelleLaufrichtung Else EndGame = True Run = False End If End With If Not SpielerLogik() Then Throw New Exception_ ("Fehler bei der Berechnung der Spielerbewegung")

Damit wären wir mit dem Thema „Tastatureingabe im Spiel “ schon fast am Ende. Es gibt in unserem Projekt nur noch eine zusätzliche Stelle, an der wir Einfluss auf unseren TastaturBuffer nehmen. In der Funktion CheckGameStatus() überprüfen wir die Variable ForceStepAhead, die immer dann auf True gesetzt wird, wenn eine Drehung ausgeführt wurde. Wenn die Variable True ist, erweitern wir den TastaturBuffer um einen Eintrag, indem wir den Wert der Taste, die die Vorwärtsbewegung definiert, speichern. Damit zwingen wir unsere Spielfigur nach jeder Drehung einen Schritt nach vorn auszuführen. Dieses dient der Vereinfachung des Spielablaufs. 1 2 3 4

If ForceStepAhead = True Then ReDim TastaturBuffer(UBound(TastaturBuffer) + 1) TastaturBuffer(UBound(TastaturBuffer)) = 200 End If

40.3 Einfügen des Kameramoduls Jetzt ist es uns also möglich, unsere Spielfigur über das Spielfeld zu steuern. Da unsere Ansicht der Welt aber immer noch statisch auf einen Punkt ausgerichtet ist, werden wir zum jetzigen Zeitpunkt diese Bewegungen nicht sehen können. Was uns also fehlt, ist eine dynamische Sicht auf die Dinge. Diese dynamische Sicht wollen wir nun einmal näher betrachten, d.h., wir wollen uns die Funktionen ansehen, die wir zur Realisierung der Ansicht benötigen. Wie immer haben wir für unser Modul eine eigene Klasse kreiert. Diese Klasse heißt DirectXCamera und wird in unserem Projekt als Variable clsCamera eingefügt. Wir haben in unserem Kameramodul die Möglichkeit, zwei Ansichten zu kreieren. Die erste Perspektive ist die Sicht aus der Ich-Position (Ego). Diese wird in den meisten 3D-Actionspielen bevorzugt. In unserem Fall hat sich aber die Ego-Perspektive als „nicht

458

Die Spielfigur

spieltauglich“ herausgestellt. Wir haben deshalb die zweite mögliche Ansicht für unser Spiel gewählt, die „Sky“-Ansicht, auch Verfolgerperspektive genannt. Diese Perspektive, in der die Kamera unserem Spielobjekt in einem festgelegten Abstand folgt, hat sich als beste spielbare Perspektive erwiesen. Zum Schluss der Initialisierung stellen wir dann noch die Projektionsmatrix des Direct3D-Devices ein. 1 2 3 4

clsCamera = New DirectXCamera clsCamera.CameraTyp = enumCameraTyp.Sky clsCamera.SpielerBlickWinkel = CType(0, Single) D3DDevice.Transform.Projection = _ DirectX.Matrix.PerspectiveFovLH_ (CSng(Math.PI / 5.0F), 1.0F, 1.0F, 100.0F)

Da wir unsere Ansicht auf die Spielwelt dynamisch gestalten wollen, müssen wir die Kamera ständig anpassen. Außerdem soll unsere Spielfigur immer im Mittelpunkt des Sichtfelds stehen. Deshalb benutzen wir die Position des Spielers in jedem Renderdurchlauf als Berechnungsgrundlage für unsere Kameraposition. Die Zeilen 1 bis 4 legen den Vektor zur Berechnung fest. Da sich unsere Kamera immer hinter unserer Spielfigur befinden sollen, müssen wir bei der Berechnung ebenfalls die Blickrichtung unseres Spielers berücksichtigen (Zeile 5). Die eigentliche Berechnung der Ansicht ist Teil der Zeile 6. Mit der Eigenschaft CalculateCameraView wird die aktuelle Ansicht berechnet und dieses Ergebnis der Viewmatrix des Devices zugewiesen. Damit ist die Ansicht auf das nächste zu rendernde Bild eingestellt.

1 2 3 4 5

6

vecSpielerPosition.X = clsSpielfigur.X_Position vecSpielerPosition.Y = 2 vecSpielerPosition.Z = clsSpielfigur.Z_Position clsCamera.SpielerPosition = vecSpielerPosition clsCamera.SpielerBlickWinkel = StructSpielfigur_ .DirectionCounter D3DDevice.Transform.View = DirectX.Matrix_ .LookAtLH(clsCamera.CameraPosition,_ clsCamera.CalculateCameraView,_ New DirectX.Vector3(0.0F, 1.0F, 0.0F))

Wir berechnen unsere Ansicht auf das Geschehen also mit der Eigenschaft CalculateCameraView der DirectXCamera-Klasse. Obwohl wir schon ausgiebig über die Matrizen im Direct3D-Device berichtet haben, wollen wir der Vollständigkeit halber die Funktion noch einmal kurz beschreiben.

Einfügen des Kameramoduls 1

2 3 4

5 6 7 8

9 10

459

Readonly Property CalculateCameraView() As DirectX.Vector3 Get Dim DefaultView As DirectX.Vector3 DefaultView.X = 0 : DefaultView.Y = 0 :_ DefaultView.Z = 0 Select Case mCameraTyp Case enumCameraTyp.Ego mCameraPosition = mSpielerPosition DefaultView.X = CType(mCameraPosition.X – 100 *_ Math.Sin(mSpielerBlickWinkel / 57.296), Single) DefaultView.Y = CType(mCameraPosition.Y, Single) DefaultView.Z = CType(mCameraPosition.Z - 100 *_ Math.Cos(mSpielerBlickWinkel / 57.296), Single)

In der Property wird als Erstes ein temporärer Vektor deklariert, der zum Schluss unseren Rückgabewert darstellt. Dieser wird im Laufe der Funktion berechnet. Innerhalb der Eigenschaft wird danach geprüft, welche Perspektive gewählt wurde. Nach dieser Wahl wird dann die Blickrichtung und die Kameraposition errechnet bzw. festgelegt. Die erste Berechnung in dem Select-Case-End-Select-Block ist die Berechnung der IchPerspektive. Dabei wird die Kameraposition zuerst auf die Position des Spielers gesetzt. Im Anschluss daran erfolgt die Berechnung der Blickrichtung. Diese liegt auf einer Kreisbahn rund um unseren Spieler. Dieser Kreis hat einen Radius von 100. Zur Berechnung benutzen wir die Sinusbzw. Cosinusfunktion der Math-Objektes. 11 12

13 14

15 16 17 18 19 20 21

Case enumCameraTyp.Sky mCameraPosition.X = CType(5 * Math.Sin_ (mSpielerBlickWinkel / (180 / Pi)), Single)_ + SpielerPosition.X mCameraPosition.Y = SpielerPosition.Y + 6 mCameraPosition.Z = CType(5 * Math.Cos_ (mSpielerBlickWinkel / (180 / Pi)), Single)_ + SpielerPosition.Z DefaultView.X = SpielerPosition.X DefaultView.Y = 3 DefaultView.Z = SpielerPosition.Z End Select Return DefaultView End Get End Property

Die zweite Berechnung in der Funktion ist somit die Berechnung der Vogelperspektive. Hierbei wird nicht wie bei der Ich-Perspektive die Kameraposition mit der Spielerposition gleichgesetzt, sondern die Blickrichtung wird durch die Spielerposition festgelegt. Dabei geht die Blickrichtung über unsere Spielfigur hinweg, damit wir den Bereich vor

460

Die Spielfigur

unserer Figur besser einsehen können. Die Position der Kamera müssen wir bei unserer zweiten Perspektive berechnen. Wir benutzen wieder die Kreisbahnberechnungen des Math-Objektes, um einen Kreis mit dem Radius 5 um unsere Spielfigur zu berechnen. Dabei befindet sich die Kamera 6 Einheiten über unserer Spielfigur.

Abb. 116. Eingesetzet Perspektiven (schematisch)

In der Abbildung sehen wir zum besseren Verständnis noch einmal eine schematische Darstellung unserer beiden möglichen Perspektiven. Damit haben wir einen eher einfachen Teil unseres Projektes abgeschlossen. Wir können nun unsere Spielfigur durch unser Labyrinth steuern und sie dabei auch im Auge behalten. Da dies aber zu einfach ist und der Spaß daran schnell verloren geht, müssen wir für etwas Abwechslung sorgen. Denn was ist schon ein Computerspiel ohne Gegner, die uns nach dem Leben trachten und dafür sorgen wollen, dass das Spiel so kurz wie möglich ist? Das wäre doch eher langweilig. Deshalb werden wir uns im nächsten Abschnitt um dieses Thema kümmern und überlegen wie wir dem Spieler bei dem Weg durch das Labyrinth das Leben schwer machen können.

41 Gegner: Computergesteuerte Elemente

Bevor wir uns die Umsetzung dieses Themas in unserem Projekt ansehen, wollen wir ein paar generelle Worte über das Thema „Gegner in Computerspielen“ verlieren. Bei der Entwicklung einer Spielidee sollte man sich von Anfang an im Klaren sein, wie die Gegenspieler auszusehen haben. Dabei ist das Wort „Gegner“ an dieser Stelle eigentlich falsch gewählt, denn nicht jedes computergesteuerte Element in einem Spiel muss der Spielfigur zwangsläufig feindlich gesinnt sein. Es kommt immer auf die Programmierung des Elementes an. Und diese wird ja schließlich von Ihnen bestimmt. Sie legen also fest, wie das Element mit Ihrem Spieler interagieren soll. Dabei kommt es natürlich darauf an, in welchem Genre das Spiel angesiedelt ist.

41.1 Arten von Gegnern Auch Wenn es nicht zwingend vorgeschrieben ist, so bestimmt doch die Auswahl des Genres auch die Art der computergesteuerten Elemente. Es macht nämlich nur wenig Sinn, wenn in einem Jump’n’Run – Spiel plötzlich ein NPC (Non Player Character) vor einem auftaucht, der versucht, uns in ein Gespräch zu verwickeln. Diese Art des Spielobjekts wäre zwar originell, würde aber dem Spielablauf nur im Wege stehen. Unserer Meinung nach kann man computergesteuerte Objekte in drei Kategorien aufteilen.

41.1.1 Festgelegte Bewegungen und Aktionen Die erste Kategorie der computergesteuerten Objekte ist wahrscheinlich die am einfachsten zu realisierende. Bei dieser Methode wird schon bei der Erstellung des Spieles festgelegt, wie sich das Objekt im Spiel zu bewegen hat. Dabei sind die Bewegungen und Aktionen des Elements unabhängig von den Aktionen des Spielers. Das typische Einsatzgebiet dieser Technik sind Jump’n’Run- und Beat’m up-Spiele. Diese Art der computergesteuer-

462

Gegner: Computergesteuerte Elemente

ten Objekte ist aber auch schon fast genauso alt wie die Computer- bzw. Videospiele an sich. Die ersten Videospielkonsolen-Klassiker wie PacMan, SpaceInvaders oder DonkeyKong basieren auf dieser Technik. Dabei bewegen sich die Gegner im Spiel immer wieder auf den gleichen vorgezeigten Wegen. Die Motivation für den Computerspieler besteht in Spielen mit dieser Technik darin, diese vorgegebenen Wege der Gegner so gut wie möglich zu studieren und seine Strategie auf diese Bewegungen anzupassen. Je besser diese Anpassung der eigenen Strategie auf die Bewegungen der Gegner klappt, desto weiter kommt der Spieler in dem entsprechenden Spiel und desto mehr Punkte kann er sammeln. Dieses Prinzip ist zwar einfach zu realisieren, hat aber den Nachteil, dass bei längerer Spielzeit der Computerspieler die Bewegungen unserer Spielobjekte immer besser einschätzen und voraussehen kann. Deshalb sollte man bei einer Umsetzung dieser Technik in einem Spiel nicht nur auf ein Bewegungsmodell setzen, sondern mindestens drei verschiedene Strategien programmieren. Wenn man diese dann auch noch zufällig den Computerspielern zuweist, dann wird es dem Spieler schwer gemacht, die Bewegungen vorauszuahnen und somit feste Strategien zu entwickeln. Durch die zufällige Auswahl von unterschiedlichen Strategien haben wir zwar keine intelligenten Spielfiguren geschaffen, aber trotzdem dem Spieler vor dem PC das Leben schwerer gemacht. Wenn wir es den computergesteuerten Objekten jetzt auch noch ermöglichen, auf die Aktionen der Spielfigur zu reagieren, dann kommen wir zu der nächsten Kategorie von Computergegnern. 41.1.2 Intelligente Bewegungen und Aktionen Auf der nächsten Stufe in der Rangfolge der Computergegner stehen die Objekte, die nicht nur auf festgelegten Pfaden durch die Spielwelt laufen, sondern auch auf Ereignisse in ihrer Umwelt reagieren können. Diese Technik findet man heutzutage in den meisten Ego-Shootern und in vielen Aufbauspielen. Oft kommen auch Kombinationen aus dieser und der ersten beschriebenen Strategie vor. Als Beispiel sei hier folgende Szene einmal beschrieben: Der Spieler hat die Aufgabe, in ein Haus einzubrechen, dabei muss er versuchen, an den Wachen vor dem Haus vorbeizukommen. Die Wachen patrouillieren so lange vor dem Haus, bis der Spieler in ihr Sichtfeld gerät oder ein Geräusch verursacht. Wie würden wir bei der Realisierung dieser Szene vorgehen? Die Umsetzung dieser Szene hat drei Elemente. Das erste Element ist eine vorher festgelegte Strategie, die die Wachen in einem vorher festgelegten Rahmen um das Haus herum laufen lässt. Der zweite Punkt ist dann die Reaktion der Wache, wenn der Spieler ihr entweder zu nahe gekommen ist oder der Spieler ein Geräusch verursacht hat. An dieser Stelle müsste dann die

Arten von Gegnern

463

zweite Strategie des Objektes starten und auf die Aktionen des Spielers reagieren. In unserem Beispiel käme hier vielleicht eine Strategie zum Einfangen der Spielfigur in Frage. Als drittes Element kommt der Realismus der gesamten Szene ins Spiel. Mit Realismus meinen wir, wie realistisch das Verhalten des computergesteuerten Objektes ist. Dazu müssen wir die Programmierung dieses Verhaltens möglichst natürlich gestalten. Welche Punkte sind bei unserer Szene zu beachten? • Als Erstes müssen wir wohl das Sichtfeld der Wache beachten. Da diese Figur keine Augen im Hinterkopf hat, darf die Figur nur auf Objekte innerhalb des Blickfelds reagieren. Ebenso sollten wir beachten, dass die Wache nicht auf Elemente reagiert, die hinter festen Objekten verborgen sind. Da die Sichtweite nicht unendlich, ist sollte unsere Wache auch nicht auf Aktionen reagieren, die außerhalb dieser Sichtweite geschehen. • Als Zweites müssen wir die Geräusche beachten. Für diese zählen nicht die gleichen Einschränkungen wie für die Sicht, da dass unsere Wache in alle Richtungen hören und auch Geräusche hinter festen Objekten wahrnehmen kann. Es ist zu erkennen, dass diese Strategien nicht einfach zu realisieren sind. Es müssen viele verschiedene Dinge beachtet werden, auf die reagiert werden soll. Die Königsklasse der Computergegner, die so genannten NPCs, wollen wir uns jetzt einmal ansehen. 41.1.3 Intelligente Bewegungen, Aktionen und Kommunikation Der nächste Schritt in der Evolution der computergesteuerten Objekte sind die NPCs, die „Non Player Characters“. Mit diesem Begriff sind Objekte gemeint, die zwar vom Computer gesteuert werden, sich aber wie ein menschlicher Mit- bzw. Gegenspieler verhalten. Wir treffen diese Art der Spielobjekte in immer mehr Spielen an. Viele Adventure- und Rollenspiele setzen auf dieses Element der Spielgestaltung um dem Spieler eine immer bessere Atmosphäre beim Spielen zu ermöglichen. Es gibt auch schon viele Online-Rollenspiele, die diese Art von computergesteuerten Objekten beinhalten. Oftmals fällt es dem Spieler eines solchen Spiels nicht sofort auf, ob die Figur, mit der er gerade kommuniziert, ein menschlicher oder ein computergesteuerter Mitspieler ist. Für unser Beispiel mit der Wache könnte eine Erweiterung der Szene mit der neuen Gegnerstrategie vielleicht so aussehen: Der Computergegner

464


läuft wie gehabt um das Haus herum. Wenn seine Aufmerksamkeit auf unseren Spieler gelenkt wird, würde nicht wie beschrieben automatisch eine Routine zum Einfangen der Spielfigur gestartet, sondern die Wache würde unsere Spielfigur ansprechen. Wir könnten dann versuchen, die Wache in einem Gespräch zu überzeugen, dass sie uns nicht einfangen muss, sondern wir nur zum Spaß um das Haus herumschleichen. Dieser Aspekt würde die Spieltiefe um ein Vielfaches steigern, da man innerhalb der Kommunikation der Wache ja auch noch verschiedene Möglichkeiten hätte. Diese Strategie ist aber die Königsklasse der Computergegner und für Einsteiger in die Spieleprogrammierung so gut wie unmöglich zu realisieren. Außerdem hängen diese Strategien sehr stark mit dem Thema künstliche Intelligenz (KI) zusammen, mit der wir uns im weiteren Verlauf des Buches (siehe Kapitel 41) noch beschäftigen werden.

41.2 Einfügen der Gegner in „Return From Orion“ Nachdem wir nun erfahren haben, welche Strategien es beim Einsatz von computergesteuerten Objekten gibt, und wir uns im Klaren sind, wie viel Erfahrung und Hintergrundwissen der Einsatz der einzelnen Vorgehensweisen benötigt, wollen wir uns ansehen, welche Technik wir als Einsteiger in die Spieleprogrammierung realisieren können. Da wir in erster Linie die Programmierung von DirectX und Visual Basic.NET demonstrieren wollen, haben wir bei unseren Gegnern auf ein eigenes Design der Objekte verzichtet. Wir wollen vier computergesteuerte Objekte in unser Spiel einfügen und verwenden dafür die gleichen Mesh-Dateien zur Erstellung, die wir auch schon bei unserer Spielfigur genutzt haben. Zur besseren Erkennung der einzelnen Gegner haben wir diese aber mit eigenen Texturen belegt. Wir können uns bei der Umsetzung der Gegnerfunktionen an den Funktionen und Routinen der Spielfigur orientieren. Dabei müssen wir beachten, dass im Gegensatz zur Spielfigur, die Funktionen der computergesteuerten Objekte so gestaltet sein müssen, dass wir sie für alle vier Objekte nutzen können. Die Grundlage für unsere Computergegner ist, genau wie bei unserer Spielfigur, die Klasse DXDynamicMesh. Diese binden wir als Array im Deklarationsbereich der frmStart-Klasse ein. So können wir innerhalb des weiteren Verlaufes mit Hilfe des Indexwertes auf die einzelnen Gegnerobjekte zugreifen. Da wir außer den reinen Daten zur Darstellung der Gegner auch noch Daten für die Logik der Objekte benötigen, erstellen wir

Einfügen der Gegner in „Return From Orion“

465

auch noch ein Array der Struktur _DynamicObject. Zum Schluss benötigen wir noch die Informationen, die festlegen, wie sich die Gegner durch die Spielwelt bewegen dürfen. Diese Informationen speichern wir in dem Struktur-Array StructDirectionGegner des Typs _DirectionStruct. 1 2 3

Private clsGegner(3) As DXDynamicMesh Private StructGegner(3) As _DynamicObject Private StructDirectionGegner(3) As _DirectionStruct

Nach der Deklarierung der Variablen werden diese zusammen mit den Spielerobjekten und dem Skydome in der Funktion MeshObjekteInitialisieren() mit Daten gefüllt. Dies geschieht in gleicher Weise, wie wir es schon im Abschnitt der Spielfigur erklärt haben. Der einzige Unterschied ist die zusätzliche Festlegung von Parametern für die Logik der Gegner im StructGegner-Array. Dabei legen wir als erste Laufrichtung des Gegner die Bewegung mit dem Index 3 fest (Zeile 5). Das ist gleichbedeutend mit einem Schritt nach vorn. Das bewirkt, dass der Gegner am Anfang des Spieles sofort in Bewegung gesetzt wird und nicht auf der Stelle stehen bleibt. Danach wird in Zeile 6 die Geschwindigkeit des Spielers im Spiel festgelegt. Wir stellen hier die Hälfte der Spielergeschwindigkeit ein, um der Spielfigur die Möglichkeit zu geben, vor dem Gegner zu fliehen. Wir haben diese Einstellung gewählt, da eine gleiche Geschwindigkeit von Gegner und Spieler zur Unspielbarkeit des Spieles führt. Der Spieler hätte keine Zeit mehr, um Ausweichbewegungen durchzuführen. Die nächste Einstellung ist die Festlegung der Verfolgungsstrategie des Gegners. Diese unterschiedlichen Strategien werden wir im nächsten Kapitel näher beleuchten. Zum Schluss initialisieren wir noch zwei Boolean-Werte, die wir zur Steuerung des Bewegungsablaufes des Gegnerobjektes benötigen. 1 2

3

4 5 6 7

8

9

clsGegner(0) = New DXDynamicMesh clsGegner(0).CreateDynamicMesh(D3DDevice,_ "C:\Buch DX VB.NET\Media\Meshes\", "NewSpieler", 4) clsGegner(0).LadeTexture(D3DDevice,_ DXUtilities.FindMediaFile(LevelVerzeichnis +_ "gegner_rot.jpg")) clsGegner(0).Scale(0.7, 0.7, 0.7) StructGegner(0).Laufrichtung = 3 StructGegner(0).Speed = 0.0625 StructGegner(0).KIStrategieCurrent = _ StructGegner(0).Strategien.Vertical StructGegner(0).KIStrategiePrimary _ StructGegner(0).Strategien.Vertical StructGegner(0).KICounter = 0

466 10 11


StructGegner(0).StandForObject = False StructGegner(0).ForceStepAhead = False

Diese Initialisierung der Objekte führen wir in der Funktion für alle vier Gegner aus. Dabei gibt es aber bis auf die Einstellung der Verfolgungsstrategie keine Veränderungen. Deshalb verzichten wir an dieser Stelle darauf, die Befehlszeile hier abzudrucken. Ohnehin gibt es bei der Einbindung der Bewegung der Gegner kaum große Unterschiede zur Einbindung der Spielfigur. Die Funktionen unterscheiden sich zum Großteil nur durch die Übergabe einer Referenz auf eine _DynamicObject-Struktur. Die Handhabung der übergebenen Strukturen wollen wir an dieser Stelle, stellvertretend für alle Funktionen, mit der Routine GegnerLogik demonstrieren. Die Methode wird in der Funktion DoGameLogic aufgerufen. Dabei werden mit Hilfe einer For-Next-Schleife und dem daraus resultierenden Indexwert die einzelnen Gegnerstrukturen aus dem Array der Funktion übergeben und berechnet. 1 2 3

4

Dim i As Integer For i = 0 To 3 If Not GegnerLogik(StructGegner(i)) Then Throw New _ Exception("Fehler bei der Berechnung der_ Bewegung des Gegners " + i.ToString) Next

Die Funktion bekommt wie schon erwähnt eine Referenz auf die aktuelle Gegnerstruktur übergeben und liefert einen Boolean-Wert zurück, der signalisiert, ob die Funktion fehlerfrei abgearbeitet wurde. 1

2 3

4

Public Function GegnerLogik(ByRef tmpGegnerStruct As _DynamicObject)as Boolean Try If (tmpGegnerStruct.ZielPunkt.x = tmpGegnerStruct_ .AktuellerPunkt.x) And (tmpGegnerStruct_ .ZielPunkt.z = tmpGegnerStruct.AktuellerPunkt.z) Then tmpGegnerStruct.StartPunkt = _ tmpGegnerStruct.ZielPunkt

Um auch bei unseren Gegnern sicherzustellen, dass Bewegungen nur genau auf dem Mittelpunkt eines Feldes ausgeführt werden können, überprüfen wir in der Funktion als Erstes, ob der Gegner, dessen Steuerungsstruktur wir der Funktion übergeben haben, schon die vorher festgelegte Position erreicht hat. Ist dies der Fall legen wir den ehemaligen Zielpunkt in der übergebenen Struktur als neuen Startpunkt fest.

Einfügen der Gegner in „Return From Orion“ 5 6 7

467

If tmpGegnerStruct.ForceStepAhead = False Then GegnerKI(tmpGegnerStruct) End If

Die Zeilen 5 bis 7 stellen die größte Änderung der GegnerLogikFunktion im Vergleich zur SpielerLogik()-Funktion dar. Im Gegensatz zum Spieler bekommen die Gegner ihre Befehle nicht vom Spieler vor dem PC, der über die Tastatur die Laufrichtung des Spielobjektes festlegt, sondern über die Funktion GegnerKI. Dieser Funktion übergeben wir erneut eine Referenz auf die aktuelle Gegnerstruktur. Wie der Name schon vermuten lässt, verbirgt sich in dieser Funktion die gesamte Intelligenz unserer computergesteuerten Objekte. Nach der Ausführung dieses Befehls haben wir in der aktuellen Struktur die neue Bewegung unseres Gegners festgelegt. Diese wird dann anschließend direkt in die nächste Bewegung verwandelt. Als Erstes holen wir uns den Byte-Wert des nächsten Feldes, das in der errechneten Laufrichtung liegt. Sollte bei der Abfrage des Wertes ein Fehler festgestellt werden, überprüfen wir diesen. Stellt sich dabei heraus, dass es sich um einen Fehler vom Typ System.IndexOutOfRangeException handelt, wissen wir, dass sich der Gegner am Rand des Spielfeldes befindet. Da wir am Rand nicht weitergehen können, geben wir dem Gegner den Befehl, stehen zu bleiben. Sollte ein anderer Fehler aufgetreten sein, geben wir diesen an die aufrufende Funktion weiter. 8 9

10 11 12 13 14 15 16

Try tempByte = Spielfeld.GetArrayPositionValue(_ (tmpGegnerStruct.StartPunkt.x - 0.5) + _ StructDirectionGegner_ (tmpGegnerStruct.desiredDirection).KomplettXAdd, _ (tmpGegnerStruct.StartPunkt.z - 0.5) + _ StructDirectionGegner_ (tmpGegnerStruct.desiredDirection).KomplettZAdd) Catch ex As Exception If TypeOf ex Is System.IndexOutOfRangeException Then tmpGegnerStruct.StandForObject = True Else Throw New Exception(ex.Message) End If End Try

Als Nächstes finden wir heraus, ob sich auf dem gewünschten Feld ein dynamisches Objekt befindet. Ist dies der Fall, dann geben wir dem Gegnerobjekt an dieser Stelle auch den Befehl, stehen zu bleiben. 17

If (tempByte And SpielfeldClass.btmDynamicObjects)_ 0 Then

468 18

19 20 21


If (tempByte And SpielfeldClass.btmDynamicObjects) = SpielfeldClass.btmEnergyPill Then tmpGegnerStruct.StandForObject = True End If End If

Die gleiche Prüfung führen wir anschließend auch mit den statischen Spielfeldobjekten durch. 22

23 24

If (tempByte And SpielfeldClass.btmStaticObjects)_ SpielfeldClass.btmGround Then tmpGegnerStruct.StandForObject = True End If

Nach der Prüfung, ob das nächste Feld betreten werden darf, legen wir noch fest, welche Bewegung der Gegner als Nächstes ausführen soll. Dazu vergleichen wir die aktuelle Laufrichtung des Gegners mit der von der KI errechneten bzw. festgelegten nächsten Laufrichtung. Sollten diese beiden Richtungen unterschiedlich sein, wird eine Drehung ausgeführt, sind die beiden Richtungswerte gleich, wird ein Schritt eingeleitet. 25

26 27 28 29 30

If (tmpGegnerStruct.desiredDirection _ tmpGegnerStruct.currentDirection) Then GegnerDrehung(tmpGegnerStruct) Else GegnerLaufen(tmpGegnerStruct) tmpGegnerStruct.ForceStepAhead = False End If

Die Zeilen 4 bis 31 werden wie erwähnt nur durchlaufen, wenn sich der Gegner genau auf der Mitte eines Feldes befindet. Ist dies nicht der Fall, befindet sich das Gegnerobjekt in einer Vorwärtsbewegung, die so lange ausgeführt wird, bist der nächste Mittelpunkt eines Feldes erreicht ist. 31 32

33

34 35 36 37 38 39

Else tmpGegnerStruct.AktuellerPunkt.x += StructDirectionGegner_ (tmpGegnerStruct.currentDirection).SchrittXAdd tmpGegnerStruct.AktuellerPunkt.z += StructDirectionGegner_ (tmpGegnerStruct.currentDirection).SchrittZAdd End If Return True Catch Return False End Try End Function

Einfügen der Gegner in „Return From Orion“

469

Am Ende haben wir die gewohnte Vorgehensweise zur Auswertung der Funktion. Ist es während des Ablaufs der Methode zu einem Fehler gekommen, melden wir der aufrufenden Funktion einen False-Wert, hat alles funktioniert, liefern wir den Wert True zurück. So - das war doch wirklich nicht viel Neues, sondern vielmehr eine Festigung von schon vorhandenem Wissen. Der einzige interessante Punkt, da noch unbekannt, ist der Befehl aus Zeile 6. Dieser Befehl GegnerKI führt uns zu unserem nächsten Kapitel, das eng mit der Steuerung des Gegners und den unterschiedlichen Strategien von computergesteuerten Objekten verbunden ist. Dieses Thema ist die künstliche Intelligenz oder kurz KI genannt.

42 Künstliche Intelligenz

42.1 Was ist künstliche Intelligenz? Bevor wir uns über die künstliche Intelligenz (KI) oder auch Englisch „Artificial Intelligence“ unterhalten, sollten wir erst einmal versuchen, den Begriff genauer zu erörtern. Die künstliche Intelligenz ist eine Kombination von Wissenschaft, Philosophie und Physiologie. Alle diese Teilbereiche müssen betrachtet werden, wenn wir uns dem Thema KI nähern wollen. Was aber allen Bereichen gleich ist, ist die Vorstellung davon, eine Maschine oder einen Computer zu erschaffen, der denken kann. Da aber die Intelligenz ein Begriff ist, der bei vielen Dingen gebraucht wird, sehen wir uns hier vier Bereiche des menschlichen Denkens an und versuchen, daraus zu ermitteln, was eine Maschine tun muss, um menschlich zu denken. Es gibt einen ganze Menge schlauer Männer und Frauen, die sich mit diesem Thema beschäftigen und auch verschiedene Standpunkte vertreten. Wir wollen uns an dieser Stelle nicht in diese Diskussion einmischen und auch nicht allzu sehr ins Detail gehen. Deshalb kommen wir direkt zu generellen Aussagen, die sich aus der Diskussion der Gelehrten ergibt. Es gibt unserer Meinung nach vier generelle Auffassungen zum Thema Künstliche Intelligenz. Diese kann man wie folgt zusammenfassen: Man kann über Künstliche Intelligenz bei Computern reden, wenn • • • •

das System menschlich handelt; das System menschlich denkt; das System rational denkt; das System rational handelt.

Was heißt das jetzt aber genau? In den nächsten Abschnitten wollen wir versuchen, die vier einzelnen Themengebiete ein wenig zu erklären. Nach

472

Künstliche Intelligenz

diesen Definitionen werden wir uns dann der KI widmen, die wir für unser Projekt genutzt haben. Bis dahin kommt jetzt aber ein bisschen Theorie. 42.1.1 Menschlich handeln Für den ersten Ansatz sehen wir uns eine der ersten Arbeiten über Künstliche Intelligenz an. Der Mathematiker Alan Turing hat 1950 die Arbeit „Computing machinery and intelligence“ veröffentlicht. In dieser Arbeit analysiert Turing die These, ob Maschinen je in der Lage sein werden, eigenständig zu denken. Dabei hat er sich nicht darum bemüht, zu klären, was Intelligenz und das damit zusammenhängende Denken ausmacht, sondern er schlägt einen praktischen Test vor, den sogenannten Turing-Test. Der Test läuft wie folgt ab: Eine menschliche Testperson steht in Verbindung mit einem Menschen und einem Computer. Damit der Test fair ist und die Testperson unvoreingenommen gegenüber den beiden „Testobjekten“ ist, geschieht die Kommunikation ausschließlich über Terminals. Die Testperson hat nun die Aufgabe, mit Hilfe von gezielten Fragen herauszufinden, welcher Kommunikationspartner der Mensch ist und welcher der Computer. Während des Testes ist der Computer und auch der Mensch über die Aufgabe der Testperson informiert, der Computer wird also versuchen, sich im Laufe des Testes wie ein Mensch zu verhalten. Am Ende des Testablaufes muss die Testperson nun bestimmen, welcher der beiden Partner der Mensch und welcher der Computer ist. Ist die Testperson nicht in der Lage, die beiden Kontrahenten zu unterscheiden, so kann nach Turing der Computer als intelligent aufgefasst werden. Dies bedeutet damit nicht dass der Computer wirklich intelligent ist, sondern dass der Computer gegenüber der Testperson menschlich gehandelt hat. 42.1.2 Menschlich denken Im Gegensatz zum Turing-Test, der herausfindet, ob ein System menschlich handelt, betrachtet der Bereich des menschlichen Denkens den Prozess des Denkens an sich. Wir müssen also nicht herausfinden, was ein Mensch denkt, sondern wir müssen herausfinden, wie ein Mensch denkt. Dieses hört sich erst einmal ziemlich kompliziert an und das ist es auch. Trotz intensiver Recherche und darüber Nachdenkens ist uns für diese Art der künstlichen Intelligenz kein Beispiel oder Anwendungsgebiet eingefallen. Auch ist noch nicht eindeutig geklärt, wie der Vorgang des Denkens bei einem Menschen logisch abläuft, das erschwert die Entwicklung eines menschlich denkenden Systems noch einmal zusätzlich. Generell ist zur Technik des menschlichen Denkens folgende Aussage zutreffend:

KI in Computerspielen

473

Ein System denkt menschlich, wenn nicht nur der Eingang und der Ausgang des Denkvorgangs dem eines Menschen gleicht, sondern auch der Denkprozess an sich. 42.1.3 Rational denken Eine weitere Form des menschlichen Denkens ist das rationale Denken. Diese Art des Denkens wird oft auch „logisches Denken“ genannt. In diesem Bereich der Intelligenz bewegen wir uns schon weit auf philosophischem Gebiet. Der Philosoph Sokrates hat sich im alten Griechenland schon mit dem Thema des „richtigen Denkens“ befasst. Er hat schon damals mit seinen Schlussfolgerungen den Grundstein dafür gelegt, was wir heute rationales Denken nennen. Diese Schlussfolgerungen waren dabei immer nach dem gleichen Muster aufgebaut: Es werden immer zwei Voraussetzungen, die sogenannten Prämissen, zu einer Schlussfolgerung (Konklusion) verknüpft. Das klassische Beispiel für dieses Thema ist folgendes. Prämisse 1: Alle Menschen sind sterblich. Prämisse 2: Sokrates ist ein Mensch. Konklusion: Also ist Sokrates sterblich. Dieses Beispiel wird Ihnen immer wieder begegnen, wenn sie sich mit diesem Thema weiter beschäftigen wollen. Für unsere Zwecke reichen die Informationen zum Thema rationales Denken an dieser Stelle aus. Das führt uns zum letzten Punkt der Theorie der Künstlichen Intelligenz. 42.1.4 Rational handeln Diesen Punkt können wir dabei sehr schnell behandeln, denn die Theorie des rationalen Handelns unterscheidet sich nicht von der des rationalen Denkens. Beim rationalen Handeln versucht man, genau wie beim rationalen Denken, von einer gegebenen Ausgangssituation durch logisch aufeinander abgestimmte Handlungen zu einem Ziel zu kommen.

42.2 KI in Computerspielen Soweit zu der Theorie des menschlichen Denkens und Handelns. Wenden wir uns nun wieder dem eigentlichen Thema zu, der KI in Computerspie-

474


len. Wenn wir die aufgeführten Definitionen näher betrachten, werden wir feststellen, dass für den Einsatz der KI in Computerspielen die erste Definition die passende ist. In unseren Spielen interessiert uns nicht, wie der Computergegner seine Handlungen berechnet, sondern uns interessiert die Handlung an sich. Diese sollte möglichst intelligent oder auch menschlich sein. Wir können deshalb auch die Schlussfolgerung anstellen, dass eine KI bei einem Computerspiel gut gelungen ist, wenn sie das menschliche Verhalten gut simuliert. Diese KI kommt dabei in den unterschiedlichsten Formen zum Einsatz. Egal ob wir in einem Ego-Shooter von Computergegnern gejagt werden oder ob ein Gegner in einer Aufbausimulation uns mit geschickten Manövern seiner Einheiten überwältigt, immer werden diese Aktionen von unserem Computer errechnet. Dabei wirkt die Simulation besonders realistisch, wenn die KI auch noch lernfähig ist. Das soll heißen, wenn die KI die Aktionen des Spielers beobachtet und sich darauf einstellen kann, um so immer wieder auftretende Aktionen des Spielers „vorauszusehen“. Da in der heutigen Zeit der Trend eher zu Online-Computerspielen geht, in denen menschliche Spieler über große Server miteinander spielen, wird sich die Entwicklung der KI in Zukunft in eine andere Richtung verlagern. Es wird dann nicht mehr Aufgabe der KI sein, die Aktionen der Gegner zu simulieren, sondern die KI wird sich in erster Linie auf die Berechnung der Umwelt des Spieles konzentrieren und somit immer authentischere Simulationen der Wirklichkeit realisieren. In Zukunft werden sich unserer Meinung nach die Spiele am besten verkaufen, die diese Aufgabe am besten umsetzen.

42.3 KI in „Return From Orion“ Wir wollen uns nun um die KI in unserem kleinen Spielprojekt kümmern. Unsere Aufgabe ist es nun zu versuchen, unserem Computergegner ein möglichst intelligentes Handeln mit auf den Weg zu geben. Zusammen mit den Strategieansätzen aus dem vorhergehenden Kapitel kommen wir bei der Wahl unserer KI zu folgendem Entschluss. Wir haben für die computergesteuerten Objekte in unserem Spiel drei verschiedene Strategien festgelegt. Random. Das Objekt bekommt in festgelegten Abständen durch Zufall eine neue Bewegungsrichtung mitgeteilt.

KI in „Return From Orion“

475

Vertikal. Der Gegner versucht zuerst, sich dem Spieler auf der vertikalen Achse zu nähern. Ist er auf der Höhe des Spielers angekommen, wird versucht, sich dem Spieler auf der horizontalen Ebene zu nähern. Horizontal. Diese Strategie funktioniert wie die vertikale, nur mit dem Unterschied, dass zuerst versucht wird, die horizontale Höhe der Spielfigur zu erreichen und danach die vertikale.

Abb. 117. Strategien der computergesteuerten Objekte

In der Abbildung sieht man eine schematische Darstellung des Spielfeldes von oben. Das Feld mit der Spielfigur ist mit einem S gekennzeichnet. Die drei unterschiedlichen Strategien der Gegner (G) sollen durch die eingezeichneten Pfeile dargestellt werden. Wir haben uns entschieden, für das erste Programmierbeispiel zum Thema Künstlicher Intelligenz auf Techniken zur Umsetzung realistischen Verhaltens zu verzichten. Die Gegner in unserem Spiel sind damit, unabhängig von der Entfernung zur Spielfigur und ihres Blickfeldes, in der Lage, den Spieler auf dem ganzen Spielfeld zu orten. Die Umsetzung dieser beschriebenen Strategien werden wir uns im Folgenden ansehen.

476


42.3.1 Random-Strategie Wir benutzen in der Routine das System.Random-Objekt von Visual Basic.NET um einen zufälligen Integer-Wert zu erhalten. Dazu haben wir im Deklarationsbereich unserer Klasse die Variable rnd angelegt. 1

Private rnd As Random

Im Load-Ereignis der frmStart-Klasse wird das Objekt mit der NewÜberladung der Random-Klasse erstellt. Dabei übergeben wir einen dynamischen Startwert an die Klasse. 1

rnd = New Random (Environment.TickCount)

Den Einsprungspunkt für unsere KI haben wir schon im vorherigen Kapitel erwähnt. Die Funktion GegnerKI wird in der Methode GegnerLogik aufgerufen. Dabei wird eine Referenz auf das aktuelle Element des _DynamicObject-Arrays an die Funktion übergeben. Mit dem With-Befehl in Zeile 2 starten wir die Funktion und ermöglichen gleichzeitig eine leichtere Verarbeitung der Informationen der Struktur. Danach müssen wir feststellen, welche Strategie für das aktuelle Objekt gewählt wurde. Diese werten wir mit einem Select-End-SelectEntscheidungsblock und der Variablen KIStrategiePrimary der Struktur aus. In Zeile 3 startet dieser Block und in Zeile 4 wird die Entscheidung getroffen, ob die Strategie des Gegners die Random-Strategie sein soll. 1

2 3 4 5 6 7 8 9 10

Public Function GegnerKI(ByRef tempStruct As _ _DynamicObject) With tempStruct Select Case .KIStrategiePrimary Case 0 ' random If .KICounter >= 0 Then .KICounter -= 1 Else .KICounter = 5 .KIStrategieCurrent = .KIStrategiePrimary End If

Da wir nicht bei jedem neuen Schritt die Laufrichtung des Objektes neu festlegen wollen, überprüfen wir bei der zufälligen Bewegung als Erstes, wie lange die letzte Zufallsauswahl schon her ist. Da unsere RandomStrategie nur eine Ausweichstrategie ist, setzen wir nach fünf Bewegungen


477

mit zufälliger Auswahl der Bewegungsrichtung unsere ursprünglich gespeicherte Strategie wieder ein. 11

If .DirectionCounter = 0 Or _ DirectionCounter = 90 Or _ .DirectionCounter = 180 Or _ .DirectionCounter = 270 Then

Zur Absicherung des Bewegungsablaufes lassen wir nur Bewegungen zu, wenn eine der vier Himmelsrichtungen erreicht ist. Danach folgen unsere Methoden zur zufälligen Änderung der Laufrichtung. 12 13 14 15 16 17

If .desiredDirection = 0 Then .currentDirection = 0 ' 1,2,3 als Mögliche Richtung While .desiredDirection = 0 .desiredDirection = rnd.Next(0, 3) End While

Da wir auch bei unseren Computergegnern mit relativen Bewegungen arbeiten, müssen wir als Erstes herausfinden, in welche Richtung das aktuelle Objekt gerade unterwegs ist (Zeile 12). Diese Richtung legen wir dann in Zeile 13 sofort als Ausgangsrichtung fest und bestimmen in den Zeilen 15 bis 17 die neue Zielrichtung. Dazu benutzen wir eine WhileEnd-While-Schleife. Diese durchlaufen wir so lange, bis sich der Wert der Zielrichtung von dem letzten Wert der Zielrichtung unterscheidet. In Zeile 16 legen wir diesen Zielwert bei jedem Durchlauf der Schleife erneut fest. Dazu benutzen wir die Next-Methode des Random-Objektes, diesem übergeben wir dann den minimalen und maximalen Wert des Bereiches, in dem die gewünschte Zufallszahl liegen sollen. Der NextBefehl liefert dabei einen Integer-Wert zurück. Durch den Aufruf dieses Befehles in der While-Schleife stellen wir sicher, dass auch eine Änderung der Richtung stattfindet. Die folgenden ElseIf-Blöcke in der Funktion haben die gleiche Aufgabe wie der gerade erklärte Block. Der Unterschied bei den einzelnen ElseIf-Entscheidungen sind dabei nur die unterschiedlichen Ausgangsrichtungen und die gewünschten Zielrichtungen. 18 19 20 21 22 23 24

ElseIf .desiredDirection = 1 Then .currentDirection = 1 ' 0,2,3 als mögliche Richtung While .desiredDirection = 1 .desiredDirection = rnd.Next(0, 3) End While ElseIf .desiredDirection = 2 Then

478 25 26 27 28 29 30 31 32 33 34 35 36

Künstliche Intelligenz .currentDirection = 2 ' 0,1,3 als mögliche Richtung While .desiredDirection = 2 .desiredDirection = rnd.Next(0, 3) End While ElseIf .desiredDirection = 3 Then .currentDirection = 3 ' 0,1,2 als mögliche Richtung While .desiredDirection = 3 .desiredDirection = rnd.Next(0, 3) End While End If

Damit sich unsere Gegner nicht durch unglückliche Random-Werte immer nur auf der Stelle drehen, haben wir festgelegt, dass ein Gegner nach einer vollendeten Zufallsentscheidung automatisch einen Schritt nach vorn machen muss. 37 38

.ForceStepAhead = True End If

Damit ist die Realisierung unserer ersten Strategie, der Ausweichstrategie, unserer Künstlichen Intelligenz abgeschlossen. Dabei müssen wir aber eingestehen, dass dabei nicht von „Intelligenz“ gesprochen werden kann, sondern ein Gegner mit dieser Strategie gleicht eher einem blinden Huhn auf der Suche nach einem Korn. Und dass er dies findet, ist dabei sehr unwahrscheinlich. Deshalb begeben wir uns jetzt ohne zu zögern an die nächste Strategie für unsere Computergegner. 42.3.2 Vertikale Strategie Zum besseren Verständnis des nächsten Sourcecode-Abschnittes wollen wir die Funktion erst einmal als Diagramm darstellen.


479

Abb. 118. Programmbeschreibung der vertikalen Strategie

Wie wir im Diagramm sehen, kann man unsere vertikale Strategie in zwei Blöcke aufteilen. Der erste Block versucht dabei, den Gegner auf die vertikale Höhe des Spielers zu bringen. Ist diese Ebene erreicht, versucht der zweite Teil der Funktion, die horizontale Position des Spielers zu erreichen. Da der Spieler dabei ja nicht ruhig auf einer Stelle steht, muss der Gegner seine Strategie bei jedem Schritt neu überprüfen, also die Funktion bei jedem Schritt durchlaufen. Im Sourcecode sieht diese Funktion dann so aus: 39 40

Case 1 ' vertical If (StructSpielfigur.AktuellerPunkt.z _ .AktuellerPunkt.z) Then

Das Erste, was unser computergesteuerter Gegner bei der Berechnung seines nächsten Schrittes machen muss, ist rauszufinden, ob er sich mit dem Spieler auf der gleichen Höhe befindet. Dazu vergleichen wir, ob die aktuelle Z-Position des Gegners ungleich der aktuellen Z-Position des Spieler

480


ist. Ist dies der Fall, befinden wir uns mit unserem Gegner noch nicht auf der gleichen Z-Ebene wie der Spieler. 41

42 43 44 45 46 47 48

If (.DirectionCounter 0 And _.DirectionCounter 180) Then If .DirectionCounter = 90 Then .Laufrichtung = 1 ElseIf .DirectionCounter = 270 Then .Laufrichtung = 2 End If Exit Select End If

Da wir uns dem Spieler noch in der Z-Position nähern müssen, überprüfen wir in Zeile 41 als Erstes, ob der Gegner in die richtige Richtung gedreht ist, um einen Schritt in Z-Richtung auszuführen. Dazu überprüfen wir, ob die aktuelle Blickrichtung, die in der Variablen DirectionCounter gespeichert ist, der Z-Achse unseres Gegners entspricht. Ist dies nicht der Fall, überprüfen wir im If-ElseIf-End-If-Block ab Zeile 42 die Laufrichtungen auf der X-Achse und initialisieren, abhängig von der Blickrichtung, eine Drehung in Richtung der Z-Achse. Am Ende der einzelnen Entscheidungen haben wir immer einen Exit-Select-Befehl eingebaut. Mit diesem Befehl verlassen wir den aktuellen Select-Block und arbeiten nach der End-Select-Anweisung weiter. Wir ersparen uns damit zusätzliche Abfragen innerhalb des Select-Blocks und können damit die Laufzeit der Funktion verbessern. Ist die Drehung des Objektes vollendet und befindet es sich in Blickrichtung der Z-Achse des Spielfeldes, dann müssen wir entscheiden, in welche Richtung wir uns auf dieser Achse bewegen müssen. 49 50

51 52 53 54 55 56

If .DirectionCounter = 0 Then If StructSpielfigur.AktuellerPunkt.z < _ .AktuellerPunkt.z Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If

Abhängig von unserer aktuellen Blickrichtung müssen wir den Befehl für die nächste Bewegung festlegen. In diesem Fall heißt das, wenn unsere Blickrichtung 0° ist (Zeile 49) und der Wert der Z-Position des Spielers kleiner ist als die aktuelle Z-Position des Gegners (Zeile 50), dass der Spieler in Blickrichtung liegt und wir einen Schritt nach vorne ausführen


481

müssen. Ist die Position des Spielers aber kleiner als die des Gegners, müssen wir den Befehl für eine 180°-Drehung geben (Zeile 53). Am Ende verlassen wir wieder den Select-Block, da alle zu diesem Zeitpunkt erforderlichen Befehle an das Objekt übergeben wurden. 57 58

59 60 61 62 63 64

If .DirectionCounter = 180 Then If StructSpielfigur.AktuellerPunkt.z > _ .AktuellerPunkt.z Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If

Die gleiche Prozedur müssen wir für die andere mögliche Blickrichtung des Objektes auf der Z-Achse realisieren. Wenn das Objekt in Richtung 180° unterwegs ist, müssen wir überprüfen, ob die Z-Position des Spielers größer ist als die des Gegners und danach dann die entsprechenden Befehle an das Objekt weitergeben. 65

Else

Der erste Vergleich, den wir innerhalb der vertikalen Strategie gemacht haben, war die Überprüfung, ob die aktuelle Z-Position des Gegnerobjektes ungleich der des Spielerobjektes ist. Ist diese Überprüfung falsch, heißt das, die Z-Positionen der beiden Objekte sind identisch und wir haben die erste Aufgabe unserer Strategie vollendet. Der Else-Befehl in Zeile 65 ist somit also der Einsprungspunkt der Strategie, wenn das Objekt die ZEbene des Spielers erreicht hat. An dieser Stelle müssen wir uns nun darum kümmern, dass wir auch die X-Ebene des Spielers erreichen. Dies realisieren wir, indem wir die gleichen Funktionen wie im ersten Block benutzen und nur die Parameter austauschen, die wir dabei überprüfen. 66

67 68 69 70 71 72 73

If (.DirectionCounter 90 And _ .DirectionCounter 270) Then If .DirectionCounter = 0 Then .Laufrichtung = 1 ElseIf .DirectionCounter = 180 Then .Laufrichtung = 2 End If Exit Select End If

Als Erstes überprüfen wir in Zeile 66, ob sich die Blickrichtung des Gegnerobjektes auf der X-Achse befindet, wenn nein, müssen wir das Objekt

482


drehen. Sieht unser Objekt in die richtige Achsenrichtung, dann müssen wir wieder feststellen, ob die X-Position des Spielers von der des Gegners unterschiedlich ist (Zeile 74). Ist dieses der Fall, dann müssen wir wie gehabt die beiden möglichen Laufrichtungen auf der X-Achse analysieren und diejenigen auswählen, die unseren Gegner dem Spieler näher bringt. Die beiden Funktionen starten in den Zeile 75 und 83. 74

75 76

77 78 79 80 81 82 83 84

85 86 87 88 89 90 91 92 93 94

If StructSpielfigur.AktuellerPunkt.x _ .AktuellerPunkt.x Then If .DirectionCounter = 270 Then If StructSpielfigur.AktuellerPunkt.x > _ .AktuellerPunkt.x Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If If .DirectionCounter = 90 Then If StructSpielfigur.AktuellerPunkt.x < _ .AktuellerPunkt.x Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If Else Exit Select End If End If

Am Ende des Select-Blockes kommt dann das eher unscheinbare Ziel unserer Strategie in Sicht. Sollte der Vergleich in Zeile 74 zu der Erkenntnis führen, dass die X-Position des Spielers die gleiche ist wie die des Gegners, dann haben wir das Ziel unserer Strategie erreicht, nämlich die gleiche Position von Gegner und Spieler, wir brauchen also nichts weiter zu tun, als den Select-Block zu beenden. Die Auswertungen der Position werden wir dann an einer anderen Stelle im Projekt vornehmen.

42.3.3 Horizontale Strategie Die dritte Strategie in unserer KI ist die horizontale Strategie. Diese ist genauso aufgebaut wie die vertikale Strategie, nur wird dabei erst versucht, auf der X-Ebene des Spielfeldes den Spieler zu erreichen und danach dann


483

die Z-Ebene. Da sich die Funktionen an sich bis auf veränderte Parameter nicht ändern, brauchen wir diese hier nicht noch einmal explizit zu erklären. Wir werden uns auf kurze Kommentare zu den einzelnen Blöcken beschränken. 95 96

Case 2 ' horizontal If (StructSpielfigur.AktuellerPunkt.x _ .AktuellerPunkt.x) Then

Starten der horizontalen Strategie in Zeile 95, anschließend überprüfen wir, ob die X-Ebene des Spielers noch nicht erreicht ist. 97

98 99 100 101 102 103 104


Blickrichtung des Gegners überprüfen (Zeile 97) liegt diese nicht in Richtung der X-Achse, dann wird eine Drehung eingeleitet (Zeile 98 -104). 105 106

107 108 109 110 111 112 113 114

115 116 117 118 119 120

If .DirectionCounter = 90 Then If StructSpielfigur.AktuellerPunkt.x < _ .AktuellerPunkt.x Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If If .DirectionCounter = 270 Then If StructSpielfigur.AktuellerPunkt.x > _ .AktuellerPunkt.x Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If

Wenn die Blickrichtung des Gegners gleich der X-Achse ist, dann wird anhand der Blickrichtung die nächste Bewegung eingeleitet. 121

Else

484


An dieser Stelle ist der erste Block abgeschlossen und die X-Position des Spielers ist gleich der X-Position des aktuellen Gegnerobjektes. In Zeile 122 beginnen wir dann auch sofort den zweiten Block der Strategie ein. Wir überprüfen als Erstes wieder die Blickrichtung des Gegners und drehen ihn falls nötig. 122

123 124 125 126 127 128 129


Ist die Blickrichtung in Ordnung, wählen wir die nächste Bewegung aus. 130

131 132

133 134 135 136 137 138 139 140

141 142 143 144 145 146 147 148 149 150 151 152 153

If StructSpielfigur.AktuellerPunkt.z _ .AktuellerPunkt.z Then If .DirectionCounter = 180 Then If StructSpielfigur.AktuellerPunkt.z > .AktuellerPunkt.z Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If If .DirectionCounter = 0 Then If StructSpielfigur.AktuellerPunkt.z < _ .AktuellerPunkt.z Then .Laufrichtung = 3 Else .Laufrichtung = 4 End If Exit Select End If Else Exit Select End If End If End Select End With End Function

In Zeile 148 haben wir dann das Ende der horizontalen Strategie erreicht und somit den Spieler auf dem Feld eingefangen.


485

42.3.4 Änderung der KI-Strategie Soweit also die einzelnen Strategien unserer KI. Wir haben in unser Projekt noch eine weitere Strategie eingebaut. Dieses ist keine Strategie an sich, sondern vielmehr eine Regel, die angibt was passiert, wenn ein Gegner vor einem Objekt steht und nicht mehr weiterkommt mit seiner aktuellen Strategie. Für diesen Fall haben wir festgelegt, dass der computergesteuerte Gegner kurzeitig seine Strategie ändert. Dieses geschieht in der Funktion GegnerLaufen der frmStart-Klasse. 1

Public Function GegnerLaufen(ByRef tempStruct As _DynamicObject)

Im Select-Case-End-Select-Block dieser Funktion, mit dessen Hilfe wir die einzelnen Laufrichtungen des Gegnerobjektes auswerten, haben wir für den Fall, dass die Variable StandForObject der aktuellen Gegnerstruktur True ist, vorgesehen, dass die Strategie des Objektes auf Random gesetzt wird. Dieses ermöglicht dem Gegner mit 5 zufälligen Bewegungen sich aus der Sackgasse zu befreien. Nach diesen 5 Bewegungen wird die ursprüngliche Strategie in der Funktion GegnerKI wieder eingestellt. 1 2 3

4

5

6

7 8 9 10

Case 3 ' istHoch If .StandForObject = False Then .AktuellerPunkt.x += StructDirectionGegner_ (.currentDirection).SchrittXAdd .AktuellerPunkt.z += _ StructDirectionGegner(.currentDirection).SchrittZAdd .ZielPunkt.z += _ StructDirectionGegner(.currentDirection).KomplettZAdd .ZielPunkt.x +=_ StructDirectionGegner(.currentDirection).KomplettXAdd Else .KIStrategieCurrent = .Strategien.Random .StandForObject = False End If

Damit haben wir das Thema KI in unserem Projekt abgeschlossen. An dieser Stelle sei noch einmal gesagt, dass die von uns genutzten Strategien nur die ersten Schritte im Thema KI sind. Wirklich komplexe künstliche Intelligenzen haben im Gegensatz zu der von uns eingesetzten mehrere tausend Codezeilen und werden meist im Zusammenhang mit komplexen Datenbanken erstellt, die das Wissen der KI darstellen.

43 Kollision

Jetzt, da wir dafür gesorgt haben, dass die computergesteuerten Objekte unsere Spielfigur verfolgen können, müssen wir uns darum kümmern, was passiert, wenn die Gegner unseren Alter Ego erreichen. Wir müssen also feststellen, wann eine Berührung oder auch Kollision zwischen Gegner und Spieler stattgefunden hat. Bevor wir dabei aber zur Realisierung in unserem Spiel kommen, wollen wir uns ein wenig Theorie zu diesem Themenbereich anschauen.

43.1 Kollision in DirectX Bei dem Thema Kollision in der DirectX-Programmierung handelt es sich um eine Programmiertechnik, die sehr viel Erfahrung im Umgang mit der Programmierung von dreidimensionalen Objekten voraussetzt. Wir wollen deshalb in unserem Buch auf dieses Thema weitgehend verzichten, da wir dem Einsteiger in die Programmierung unter DirectX an dieser Stelle nicht den Spaß an der für ihn neuen Programmierschnittstelle verderben wollen. Dennoch wollen wir hier kurz die generelle Technik der Kollisionsbestimmung erklären. Microsoft hat für dieses Thema in DirectX zwei Objekte mit den dazu passenden Methoden integriert. Mit Hilfe dieser beiden Objekte kann festgestellt werden, ob sich Objekte innerhalb der 3DWelt berühren, also eine Kollision stattgefunden hat. 43.1.1 BoundingBox Die erste Methode, eine Kollision zu ermitteln, erfolgt mit der so genannten BoundingBox. Mit dem Befehl Direct3D.Geometry. ComputeBoundingBox wird eine virtuelle Box um unser 3D-Objekt gelegt. Wir erhalten als Ergebnis dieser Funktion die Koordinaten unseres Objektes zurück, die den äußersten Punkt unseres Objektes repräsentieren. Diese Koordinaten sind relativ zum Mittelpunkt unseres 3D-Modells. Wenn wir nun also eine Kollisionsabfrage realisieren wollen, müssen wir für jedes Objekt im Spiel entweder eine BoundingBox berechnen oder

488

Kollision

die genauen Ausmaße des Objektes kennen. Bei jedem Renderdurchlauf des Spieles müssen wir dann alle BoundingBox-Objekte mit dem Befehl BoxBoundProbe überprüfen und so eine eventuelle Kollision herausfiltern. Dies bedeutet je nach Anzahl der Objekte im Spiel einen gehörigen Rechenaufwand und ist wie gesagt für Einsteiger in das Thema DirectX nicht einfach nachzuvollziehen.

Abb. 119. Schematische Darstellung einer BoundingBox

43.1.2 BoundingSphere Das zweite Objekt zur Ermittlung der Kollision ist BoundingSphere, die mit dem Befehl Direct3D.Geometry.ComputeBoundingSphere erstellt wird. Dieser Befehl gibt uns den Radius zurück, vom Mittelpunkt aus gesehen, der das gesamte Objekt umschließt. Der Befehl zur Überprüfung der BoundingSphere heißt SphereBoundProbe. Auch bei der Benutzung der BoundingSphere müssen wir bei jedem Renderdurchlauf alle Objekte miteinander vergleichen und so herausfinden, wo eventuell eine Kollision stattgefunden hat.

Kollision in DirectX

489

Abb. 120. Schematische Darstellung einer BoundingSphere

43.1.3 Feintuning Beim Einsatz der beiden beschriebenen Techniken ist noch ein weiterer Umstand zu beachten. Dadurch, dass wir mit Hilfe der beiden Objekte immer nur die äußersten Punkte des 3D-Objektes erfassen, kann es je nach der Beschaffenheit des Objektes zur Anzeige eine Kollision kommen, ohne dass eine wirkliche Kollision stattgefunden hat.

Abb. 121. Schematisch Kollision ohne Kollision

490

Kollision

In diesem Fall muss bei der Programmierung eine weitere Kollisionsabfrage gestartet werden. Diese hat dann zur Aufgabe, die genaue Kollision zu ermitteln. Die optimale Umsetzung einer Kollisionsabfrage sieht somit wahrscheinlich so aus, dass man mit Hilfe der Bounding-Objekte eine Annäherung zweier Objekte ermittelt. Bei einer Berührung von zwei Bounding-Objekten muss dann die zweite Kollisionsabfrage gestartet werden. Diese hat dann zur Aufgabe eine polygongenaue Kollision zu ermitteln, indem sie die Vertexbuffer der beiden Objekte auf eine Kollision vergleicht. Sie sehen also, eine wirklich gute Kollision ist kein Zuckerschlecken und die Umsetzung einer solchen hätte wahrscheinlich den Rahmen unseres kleinen Projektes gesprengt. Wir haben daher entschieden, unsere Kollision im Spiel auf unserer schon oft genutzten 2D-Matrix basieren zu lassen.

43.2 Kollision im Spiel Wie gesagt haben wir uns bei der Kollision wieder auf unser bekanntes 2D-Koordinatensystem verlassen. Da wir zu jeder Zeit im Spielablauf alle Positionen der Spielfigur und der Gegner kennen, brauchen wir diese nur zu vergleichen und herauszufinden, ob diese in irgendeiner Weise übereinstimmen. Die Befehle für diese Abfrage sind in der Funktion CheckGameStatus() untergebracht. 1 2 3

With StructSpielfigur For i = 0 To 3 If (.ZielPunkt.x = StructGegner(i).ZielPunkt.x) And _ (.ZielPunkt.z = StructGegner(i).ZielPunkt.z) Then

Unser Kollisionsabfrage besteht also darin, festzustellen, ob sich ein gegnerisches Objekt auf das gleiche Feld zu bewegt, das wir auch gerade ansteuern. Dazu gehen wir in einer For-Next-Schleife alle Gegnerobjekte durch und überprüfen, ob deren Zielkoordinaten mit denen der Spielfigur übereinstimmen. 4 5

6 7 8 9 10

If intLeben >= 0 Then If (lastPunkt.x .ZielPunkt.x) And _ (lastPunkt.z .ZielPunkt.z) Then intLeben -= 1 lastPunkt.x = .ZielPunkt.x lastPunkt.z = .ZielPunkt.z End If Else

Kollision im Spiel

491

Haben wir eine Übereinstimmung erzielt, ist eine Kollision geschehen und wir müssen prüfen, ob noch ein Spielerleben übrig ist. Ist das der Fall, überprüfen wir, ob die letzte Kollision mit einem Gegner auf dem gleichen Feld stattgefunden hat, auf dem wir uns gerade befinden. Wenn ja, ignorieren wir die Kollision. Diese Funktion haben wir zur besseren Spielbarkeit in das Projekt eingebaut. Ist das aktuelle Feld aber unterschiedlich zu dem Feld der letzten Kollision, dann wird dem Spieler ein Lebenspunkt abgezogen und das Spiel fortgesetzt. 11 12 13

Return False End If End If

Sollte kein Lebenspunkt mehr vor der Kollision übrig gewesen sein, dann beenden wir die Funktion mit der Rückgabe eine False-Wertes und signalisieren so das Ende des Spieles. 14

15 16

17 18 19 20 21 22 23 24 25 26

If (.StartPunkt.x = StructGegner(i).ZielPunkt.x) And _ (.StartPunkt.z = StructGegner(i).ZielPunkt.z) Then If intLeben >= 0 Then If (lastPunkt.x .StartPunkt.x) And _ (lastPunkt.z .StartPunkt.z) Then intLeben -= 1 lastPunkt.x = .StartPunkt.x lastPunkt.z = .StartPunkt.z End If Else Return False End If End If Next End With

Im Laufe der Entwicklung unseres Projektes haben wir festgestellt, dass die Kollisionsabfrage realistischer wird, wenn wir nicht nur das Zielfeld der Objekte abfragen, sondern auch das Startfeld. Wir wiederholen deshalb die gesamte Abfrage der Objekte mit den StartPunkten der einzelnen Elemente. Somit haben wir eine rudimentäre, aber funktionierende Kollision in unser Projekt integriert und wir können mit anderen Features unseres Projektes fortfahren.

44 Soundeffekte

Jetzt haben wir die grundlegenden Techniken zur Realisierung unseres Spieles zusammen. Wir können unsere Spielfigur durch das Labyrinth steuern und haben dank der Kollisionsabfrage auch ein Interesse daran, den Gegnern nicht zu nahe zu kommen. Aber wenn wir jetzt das Spiel starten, fehlt trotzdem noch etwas. Zu einem Computerspiel gehören nicht nur bunte Bilder, sondern auch eine Soundkulisse, die den Spieler an das Spiel fesselt und die Atmosphäre des Spieles erhöht. Deshalb wollen wir in unserem Spiel auch dieses Medium einfügen. Wir möchten eine generelle Hintergrundmusik während des Spieles ablaufen lassen und zusätzlich ein paar Soundeffekte realisieren. Zu diesem Zweck haben wir dem Projekt die DirectXSound-Klasse hinzugefügt. Diese Klasse haben wir ja bereits im zweiten Teil des Buches (siehe Kapitel 30) kennen gelernt. Wir werden deshalb die einzelnen Funktionen der Klasse nicht näher erläutern, sondern nur deren Anwendung. Wir fügen unserem Projekt also vier neue Ableitungen der Klasse DirectXSound im Deklarationsbereich der frmStart-Klasse hinzu. 1 2 3 4

Private Private Private Private

MainSound As DirectXSound = Nothing StepSound As DirectXSound = Nothing PillSound As DirectXSound = Nothing HeartSound As DirectXSound = Nothing

Damit wir die Sounds im Spiel benutzen können, müssen wir die einzelnen Klassen initialisieren und mit Sounddateien laden. Diese Methoden haben wir in der Funktion SoundsInitialisieren zusammengefasst. 1 2 3 4 5

6 7 8

Private Function SoundsInitialisieren() As Boolean Try MainSound = New DirectXSound MainSound.CreateDevice() MainSound.CreateSound(Me, _ DXUtilities.FindMediaFile("Sound\Sound1.wav")) MainSound.Volume(-500) ' -10000 (Min) to 0 = Max MainSound.Pan(0) ' -10000 to +10000 0 = Mitte MainSound.Frequency(0) ' 100 to 10000 0 = Default

494 9

Soundeffekte If MainSound.LoopSound() = False Then Throw New _ Exception("Sound konnte nicht gestartet werden")

Als Erstes initialisieren wir die Soundklasse für die Hintergrundmusik. Diese setzen wir mit Hilfe der Volume-Methode der Soundklasse auf -500. Da diese Soundklasse im Spiel ständig wiederholt werden soll, starten wir die Soundwiedergabe auch gleich an dieser Stelle mit der LoopSound-Funktion. 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

25 26 27

StepSound = New DirectXSound StepSound.CreateDevice() StepSound.CreateSound(Me, _ DXUtilities.FindMediaFile("Sound\step.wav")) StepSound.Volume(0) ' -10000 (Min) to 0 = Max StepSound.Pan(0) ' -10000 to +10000 0 = Mitte StepSound.Frequency(0) ' 100 to 10000 0 = Default PillSound = New DirectXSound PillSound.CreateDevice() PillSound.CreateSound(Me, _ DXUtilities.FindMediaFile("Sound\pill.wav")) PillSound.Volume(0) ' -10000 (Min) to 0 = Max PillSound.Pan(0) ' -10000 to +10000 0 = Mitte PillSound.Frequency(0) ' 100 to 10000 0 = Default HeartSound = New DirectXSound HeartSound.CreateDevice() HeartSound.CreateSound(Me, _ DXUtilities.FindMediaFile("Sound\heart.wav")) HeartSound.Volume(0) ' -10000 (Min) to 0 = Max HeartSound.Pan(0) ' -10000 to +10000 0 = Mitte HeartSound.Frequency(0) ' 100 to 10000 0 = Default

Alle anderen Soundobjekte werden abhängig von Situationen im Spiel gestartet. Aus diesem Grund brauchen wir sie an dieser Stelle nur initialisieren. Da diese Sounds die eigentliche Hintergrundmusik überlagern sollen, wird bei diesen Objekten die Lautstärke nicht gedämpft. Die Situationen, an denen wir die einzelnen Soundobjekte abspielen wollen, werden wir uns jetzt einmal ansehen. Der erste Sound, den wir auf diese Art abspielen wollen, ist das Geräusch für einen Schritt unserer Spielfigur. Dieser Sound ist genau so lange wie eine Schrittbewegung unseres Spielers und muss deshalb mit seiner Bewegung synchronisiert werden. Zu diesem Zweck benutzen wir die Zeitberechnung innerhalb der Renderfunktion. Diese ist so konzipiert, dass wir den Schrittsound einmal in der Sekunde abspielen können. Dabei werten wir zusätzlich noch die Variable StandForWall aus, steht der Spieler also vor einer Wand, spielen wir den Sound nicht ab. Das wirkt dann im Spiel insgesamt realistischer.

Kollision im Spiel

1 2 3 4

5 6

495

If intCurTime > 1000 Then intCurTime = 0 If StandForWall = False Then If StepSound.PlaySound() = False Then Throw New _ Exception("Sound konnte nicht gestartet werden") End If End If

Die beiden anderen Soundklassen benutzen wir, um bestimmte Ereignisse im Spiel akustisch darzustellen. Diese beiden Ereignisse sind das Aufsammeln einer Energiepille und das Verlieren eine Lebens des Spielers. Innerhalb der Funktion CheckGameStatus überprüfen wir den Status der Energiepillen und der Lebensanzeige des Spielers, sollte sich einer der beiden Werte geändert haben, wird der passende Sound abgespielt. Die Funktion CheckGameStatus wird dabei bei jedem Durchlauf der Renderfunktion aufgerufen. Das bedeutet, wir können an dieser Stelle in Echtzeit auf Ereignisse reagieren. 1 2 3 4 5 6 7 8 9 10 11 12

If CurrentHearts Nothing Then If CurrentHearts intLeben Then HeartSound.PlaySound() End If End If CurrentHearts = intLeben If CurrentEnergyPill Nothing Then If CurrentEnergyPill i Then PillSound.PlaySound() End If End If CurrentEnergyPill = i

45 Abschließende Funktionen

Zum Abschluss des Spieles wollen wir jetzt noch ein paar Funktionen erklären, die zwar nicht direkt zum Spielablauf gehören, aber ein Computerspiel abrunden und deshalb in keinem Spiel fehlen sollten.

45.1 Statusanzeigen erstellen und integrieren

Abb. 122. Statusanzeigen

Das erste zusätzliche Element, das wir eingefügt haben, ist eine Statusanzeige. Mit Hilfe dieser Anzeige können wir die für den Spieler wichtigen Informationen im Spielablauf sichtbar machen. Wir realisieren diese Anzeigen mit Ableitungen unserer DXSprites-Klasse. Wir initialisieren

498

Abschließende Funktionen

dazu die nötigen Objekte wieder einmal im Deklarationsbereich der frmStart-Klasse, um sie nachher weiterverarbeiten zu können 1 2 3 4 5 6 7 8

Private Private Private Private Private Private Private Private

clsFPSSprite_rot As DXSprites clsFPSSprite_gelb As DXSprites clsFPSSprite_gruen As DXSprites clsPlayerScore As DXSprites clsScoreTen As DXSprites clsScoreOne As DXSprites clsHeart(2) As DXSprites CurrentHearts As Integer = Nothing

Das eigentliche Einbinden der Objekte geschieht in der Funktion SpritesInitialisieren(). Hier werden die vorher definierten Klassen instanziert und mit Bilddateien gefüllt. 1 2 3 4 5 6 7

Try clsFPSSprite_rot = New DXSprites(D3DDevice) clsFPSSprite_gelb = New DXSprites(D3DDevice) clsFPSSprite_gruen = New DXSprites(D3DDevice) clsPlayerScore = New DXSprites(D3DDevice) clsScoreTen = New DXSprites(D3DDevice) clsScoreOne = New DXSprites(D3DDevice)

Für die Anzeige der Lebenspunkte haben wir ein kleines Herz als Symbol gewählt. Da wir am Anfang des Spieles drei Lebenspunkte haben, erstellen wir ein Array mit drei Elementen der DXSprites-Klasse und füllen jedes mit der vorher bestimmten Bilddatei. 8 9 10 11 12

13

Dim i As Integer For i = 0 To 2 clsHeart(i) = New DXSprites(D3DDevice) With clsHeart(i) .LadeMaskedTexture(D3DDevice,_ DXUtilities.FindMediaFile("Texturen\herz.bmp"),_ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle_ (0, 0, 60, 60)

Mit der Rectangle-Eigenschaft der Klasse legen wir fest, welchen Teil des geladenen Bildes wir darstellen wollen. 14 15 16

17 18

Select Case i Case 0 .Position = New DirectX.Vector3_ (Me.Width - 200, Me.Height - 175, 0) Case 1 .Position = New DirectX.Vector3_ (Me.Width - 140, Me.Height - 175, 0)

Statusanzeigen erstellen und integrieren 19 20

21 22 23

499

Case 2 .Position = New DirectX.Vector3_ (Me.Width - 80, Me.Height - 175, 0) End Select End With Next i

Da wir die drei Herzen nebeneinander anzeigen wollen, müssen wir die Positionen definieren, an denen die drei Objekte dargestellt werden sollen. Die restlichen Sprites werden genauso initialisiert und geladen wie die Sprites für die Lebensanzeige. In das clsPlayerScore-Objekt laden wir die Datei für die Energiepille und platzieren diese unterhalb der Lebensanzeige. 24 25

26 27

28

With clsPlayerScore .LadeMaskedTexture(D3DDevice, _ DXUtilities.FindMediaFile("Texturen\pill.bmp"), _ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle(0, 0, 75, 75) .Position = New DirectX.Vector3_ (Me.Width - 175, Me.Height - 100, 0) End With

Die beiden Objekte clsScoreTen und clsScoreOne laden die gleichen Bildinformationen. Mit Hilfe dieser beiden Klassen wollen wir im Laufe des Spieles die Anzahl der Energiepillen zweistellig anzeigen, die noch auf dem Spielfeld vorhanden sind und vom Spieler eingesammelt werden müssen. 29 30

31 32

33 34 35

36 37

38

With clsScoreTen .LadeMaskedTexture(D3DDevice,_ DXUtilities.FindMediaFile("Texturen\numbers.bmp"),_ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle(0, 0, 25, 50) .Position = New DirectX.Vector3_ (Me.Width - 100, Me.Height - 85, 0) End With With clsScoreOne .LadeMaskedTexture(D3DDevice, DXUtilities.FindMediaFile("Texturen\numbers.bmp"),_ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle(0, 0, 25, 50) .Position = New DirectX.Vector3_ (Me.Width - 75, Me.Height - 85, 0) End With

500


Die letzten Sprite Objekte, die wir benutzen wollen, helfen uns bei der Anzeige der Frames pro Sekunde. Wir haben für unser Spiel eine maximale Framerate von 50 Frames bestimmt. Mit Hilfe der Sprite-Objekte wollen wir dem Spieler anzeigen, wie nahe er dieser maximalen Framerate mit seiner ausgewählten Grafikeinstellung kommt. Mit Hilfe der Rectangle-Eigenschaft der Klasse legen wir die nachfolgenden SpriteObjekte in die linke obene Bildschirmecke. 39 40

41 42

43 44

45 46 47 48

49 50

With clsFPSSprite_rot .LadeMaskedTexture(D3DDevice, DXUtilities.FindMediaFile_ ("Texturen\fps_red_small.bmp"),_ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle(0, 0, 70, 40) End With With clsFPSSprite_gelb .LadeMaskedTexture(D3DDevice,DXUtilities.FindMediaFile_ ("Texturen\fps_yellow_small.bmp"), _ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle(0, 0, 70, 40) End With With clsFPSSprite_gruen .LadeMaskedTexture(D3DDevice, DXUtilities.FindMediaFile_ ("Texturen\fps_green_small.bmp"), _ Color.FromArgb(255, 255, 0, 255).ToArgb) .Rectangle = New System.Drawing.Rectangle(0, 0, 70, 40) End With

Wir wollen also mit unseren Sprite-Objekten den aktuellen Spielstand bei jedem Rendervorgang anzeigen. Dazu haben wir die Funktion DrawSprites in unser Projekt mit aufgenommen. Diese Methode wertetet den aktuellen Spielstand aus und zeigt dem Spieler die gewünschten Informationen an. 1

2 3 4 5 6 7 8

Private Sub DrawSprites(ByVal D3DDevice As _ Direct3D.Device) If iFrameRate > 40 Then clsFPSSprite_gruen.SpriteObjectRendern() ElseIf iFrameRate > 30 Then clsFPSSprite_gelb.SpriteObjectRendern() Else clsFPSSprite_rot.SpriteObjectRendern() End If

Als Erstes wollen wir die aktuelle Framerate auswerten und das zugehörige Sprite-Objekt darstellen. Wir prüfen dabei die Variable iFrameRate, diese enthält immer die Framerate der letzten vollendeten Sekunde.

Statusanzeigen erstellen und integrieren

9

501

clsPlayerScore.SpriteObjectRendern()

Danach rendern wir die Energiepille in unseren aktuellen Frame und anschließend die dazugehörigen Zahlen. Wir berechnen dazu als Erstes die Zehnerstelle der aktuellen Energiepillenanzahl. Mit dem Ergebnis dieser Rechnung ermitteln wir dann über eine Select-Case-End-SelectAbfrage den Teil des Sprites, der im nächsten Bild dargestellt werden soll. 10 11 12 13 14

15 16

17 18

19 20

21 22

23 24

25 26

27 28

29 30

31 32

33 34 35

With clsScoreTen Dim tmpInt = CurrentEnergyPill \ 10 Select Case tmpInt Case 0 .Rectangle = _ New System.Drawing.Rectangle(0, 0, 25, 50) Case 1 .Rectangle = _ New System.Drawing.Rectangle(25, 0, 25, 50) Case 2 .Rectangle = _ New System.Drawing.Rectangle(44, 0, 25, 50) Case 3 .Rectangle = _ New System.Drawing.Rectangle(68, 0, 25, 50) Case 4 .Rectangle = _ New System.Drawing.Rectangle(92, 0, 25, 50) Case 5 .Rectangle = _ New System.Drawing.Rectangle(115, 0, 25, 50) Case 6 .Rectangle = _ New System.Drawing.Rectangle(138, 0, 25, 50) Case 7 .Rectangle = _ New System.Drawing.Rectangle(160, 0, 25, 50) Case 8 .Rectangle = _ New System.Drawing.Rectangle(185, 0, 25, 50) Case 9 .Rectangle = _ New System.Drawing.Rectangle(210, 0, 25, 50) End Select .SpriteObjectRendern() End With

Genau wie bei der Darstellung der Zehnerstelle ermitteln wir auch für die Einerstelle den aktuell darzustellenden Wert und rendern diesen, wie vorher bereits gezeigt, in unser aktuelles Bild.

502

36 37 38 39 40

41 42 43

44 45 46


With clsScoreOne Dim tmpInt = CurrentEnergyPill Mod 10 Select Case tmpInt Case 0 .Rectangle = New System.Drawing.Rectangle(0, 0, 25, 50) ……… Case 9 .Rectangle = _ New System.Drawing.Rectangle(210, 0, 25, 50) End Select .SpriteObjectRendern() End With

45.2 Splash-Screens Eine weitere Komponente, die unser Spiel abrunden und interessanter machen soll, ist der Einsatz so genannter Splash-Screens. Der Sinn des Splash-Screens besteht darin dem Anwender einen ersten und hoffentlich auch bleibenden Eindruck von dem Produkt zu verschaffen. Hier können zum Beispiel Informationen über die Produktionsfirma des Spieles oder auch ein Logo der Entwickler platziert werden. So hat man die Möglichkeit, dem Spieler im Gedächtnis zu bleiben. Sollten Sie zu den SharewareProgrammierern gehören, können Sie den Spieler an dieser Stelle auch daran erinnern, sich bitte zu registrieren. Wenn Sie über eine Internetseite verfügen, sollten Sie diese auch an dieser Stelle platzieren, um den Anwender zu animieren, sich auch andere Produkte aus Ihrer Feder anzusehen. Dabei ist die Art des Screens, die wir gewählt haben wahrscheinlich die einfachste. Es wird dabei nämlich lediglich ein vorher gestaltetes Bild auf einer temporären Form dargestellt. 1 2

Dim Splashbmp As System.Drawing.Image Splashbmp = System.Drawing.Image.FromFile_ (DXUtilities.FindMediaFile("Texturen\splashscreen.bmp"))

Dazu erstellen wir in der Load Methode der frmStart Klasse, als erstes ein Objekt des Typs Image und füllen dieses mit der Bitmap Datei auf. 3 4

Dim SplashForm As System.Windows.Forms.Form SplashForm = New System.Windows.Forms.Form

Splash-Screens

503

Danach erzeugen wir eine temporäre Form und initialisieren diese sofort. Wir legen die Eigenschaften der Form fest, bevor wir diese dann einblenden. Die Einstellungen im Einzelnen sehen folgendermaßen aus: Wir stellen die Deckkraft (Opacity) der Form auf 0.0 ein. Danach legen wir die Dimensionen der Form fest. Sie sollen mit denen des Bildes übereinstimmen (Zeile 8/9). Anschließend legen wir in Zeile 10 das geladene Bild als Hintergrund für die Form fest. Wir bestimmen, dass die Form des Splash-Screens keine Kontrollelemente haben soll und in der Mitte des Bildschirmes positioniert werden soll. 5 6 7 8 9 10 11 12 13 14 15

sngOpacity = 0.0 With SplashForm .Opacity = sngOpacity .Height = Splashbmp.Height .Width = Splashbmp.Width .BackgroundImage = Splashbmp .ControlBox = False .StartPosition = FormStartPosition.CenterScreen .TopMost = True .Show() End With

In Zeile 14 blenden wir die Form dann ein und sehen, dass wir am Anfang erst einmal nichts sehen. Da wir ja die Opacity-Eigenschaft der Form auf 0.0 gesetzt haben. Jetzt müssen wir die Form also wieder sichtbar machen und dieses Einblenden soll möglichst „smooth“ geschehen. Dazu benutzen wir eine zeitgesteuerte While-End-While-Schleife. Diese durchlaufen wir 5 Sekunden lang. Dabei messen wir die Zeit mit der Environment.TickCount-Methode. Innerhalb der Schleife erhöhen wir dann die Deckkraft der Form bis zu ihrem Maximalwert. Um dem System die Möglichkeit zu geben, auf die Aktualisierung der Form zu reagieren, haben wir auch einen Application.DoEvents-Befehl mit in die Schleife aufgenommen. 16 17 18 19 20 21 22

Dim wait As Integer = Environment.TickCount While (wait + 5000) > Environment.TickCount sngOpacity += 0.005 If sngOpacity > 1 Then sngOpacity = 1 SplashForm.Opacity = sngOpacity Application.DoEvents() End While

Nachdem wir den Splash-Screen 5 Sekunden eingeblendet haben, löschen wir den Screen und fahren mit der Abarbeitung der Funktion Load fort. 23

SplashForm.Dispose()

504


Wir haben zwei Splash-Screens in das Spiel eingebaut, einen vor Beginn des Spiels und einen am Ende, der mit der gleichen Methode, wie die eben beschriebene, realisiert wird.

Abb. 123. Splashscreens in „Return From Orion”

Dabei müssen wir noch erwähnen, dass die Methode des Splash-Screens in der Spieleprogrammierung immer seltener wird. Durch die immer größeren Möglichkeiten der Computersysteme und Programmiersprachen wurde der Splash-Screen in der Spieleindustrie fast vollständig durch gerenderte Videosequenzen oder sogar komplette Filme abgelöst. Auch wir sehen darin die Zukunft und haben auch eine minimale Rendersequenz in das Spiel eingebaut.

45.3 Kamerafahrt am Anfang jedes Levels Rendersequenzen in einem Spiel sind vorher festgelegte Scripts, die mit Hilfe der Spielengine umgesetzt werden. Es werden also keine Zeichentrickfilme oder andere Animationen erstellt, sondern es wird direkt mit der Technik des Spieles gearbeitet. Für unser Spiel haben wir uns für einen Kameraschwenk über das Spielfeld entschieden. Dabei kann der Spieler vor dem Computer einen ersten Überblick über das nächste Level erhalten und sich die Anfangsstellungen der Gegner und die Lage der zu sammelnden Energiepillen einmal ansehen.

Kamerafahrt am Anfang jedes Levels

505

Abb. 124. Kamerafahrt am Anfang des Levels

Vor dem eigentlichen Start des Spieles wird während der Rendervorgangs die Funktion DoIntro aufgerufen. Diese führt eine Drehung der Kamera über das Spielfeld aus. 1 2 3 4 5 6

7 8

Private Function DoIntro() As Boolean Try Dim View As DirectX.Vector3 IntroAngle += 1 If IntroAngle

Spiele effektiv programmieren mit VB.NET und DirectX

Effektiv Java programmieren

3D-Spiele-Programmierung - Kompendium. Spiele planen und programmieren

Spiele und Tricks mit Münzen

NET Framework Developer's Guide. Effektiv programmieren mit den .NET-Sprachen

Jetzt lerne ich Spiele programmieren mit Blitz Basic GERMAN

Jetzt lerne ich Spiele programmieren mit Flash GERMAN

Programmieren mit ASP.NET AJAX

Programmieren mit R

Autocad programmieren mit VBA+

Programmieren lernen mit Java

Jetzt lerne ich Spiele programmieren mit Flash . Komplettes Starterkit für den einfachen und schnellen

Programmieren mit R

Brot und Spiele

Brot und Spiele

Brot und Spiele

Programmieren lernen mit Perl (Xpert.press)

Programmieren mit Kara, 2. Auflage

Brot und Spiele

Brot und Spiele

Programmieren lernen mit Java GERMAN

C. Mit einfachen Beispielen programmieren

Grundkurs Programmieren mit Delphi GERMAN

Spieleprogrammierung mit C++ und DirectX 9 in 21 Tagen

Spieleprogrammierung mit C++ und DirectX 9 in 21 Tagen

AntMe! Spielend programmieren lernen mit Visual Basic und den Ameisen

Java will nur spielen: Programmieren lernen mit Spaß und Kreativität

Programmieren mit Wolfram Mathematica® (eXamen.press) (German Edition)

Programmieren lernen mit Perl (Xpert.press) (German Edition)

Programmieren mit Wolfram Mathematica® (eXamen.press) (German Edition)

Programmieren lernen für Teens mit C GERMAN

Spiele effektiv programmieren mit VB.NET und DirectX

Effektiv Java programmieren

3D-Spiele-Programmierung - Kompendium. Spiele planen und programmieren

Spiele und Tricks mit Münzen

NET Framework Developer's Guide. Effektiv programmieren mit den .NET-Sprachen

Jetzt lerne ich Spiele programmieren mit Blitz Basic GERMAN

Jetzt lerne ich Spiele programmieren mit Flash GERMAN

Programmieren mit ASP.NET AJAX

Programmieren mit R

Autocad programmieren mit VBA+

Programmieren lernen mit Java

Jetzt lerne ich Spiele programmieren mit Flash . Komplettes Starterkit für den einfachen und schnellen

Programmieren mit R

Brot und Spiele

Brot und Spiele

Brot und Spiele

Programmieren lernen mit Perl (Xpert.press)

Programmieren mit Kara, 2. Auflage

Brot und Spiele

Brot und Spiele

Programmieren lernen mit Java GERMAN

C. Mit einfachen Beispielen programmieren

Grundkurs Programmieren mit Delphi GERMAN

Spieleprogrammierung mit C++ und DirectX 9 in 21 Tagen

Spieleprogrammierung mit C++ und DirectX 9 in 21 Tagen

AntMe! Spielend programmieren lernen mit Visual Basic und den Ameisen

Java will nur spielen: Programmieren lernen mit Spaß und Kreativität

Programmieren mit Wolfram Mathematica® (eXamen.press) (German Edition)

Programmieren lernen mit Perl (Xpert.press) (German Edition)

Programmieren mit Wolfram Mathematica® (eXamen.press) (German Edition)

Programmieren lernen für Teens mit C GERMAN

Recommend Documents