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
Die Entwicklungsumgebungen von VB.NET
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
Das Visual Studio .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
Die Entwicklungsumgebungen von VB.NET
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
Das Visual Studio .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
Die Entwicklungsumgebungen von VB.NET
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
Die Entwicklungsumgebungen von VB.NET
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
Die Entwicklungsumgebungen von VB.NET
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
Datentypen und Konstanten
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-
Datentypen und Konstanten
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
Datentypen und Konstanten
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
True
124 >= 12
True
389 >= 389
True
124 >= 125
False
<> (ungleich) < (kleiner als) > (größer als) <= (kleiner oder gleich)
>= (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 <= 100 'Hier ist alles in Ordnung Console.WriteLine("Der Preis von " &_ Preis & " € ist in Ordnung!") Case Else 'Hier ist der Preis zu hoch RaiseEvent ZuTeuer(Preis) End Select End Sub End Class
Wir möchten uns mit Events beschäftigen. Das von uns verwendete Ereignis wird in Zeile 3 benannt. In den Zeilen 4 -13 haben wir eine kleine Methode integriert. Diese soll unser Auktionsgebot auswerten. Ist der Preis zu hoch, soll das Ereignis ZuTeuer ausgelöst werden. Hier sehen Sie, dass das Event nicht nur festgelegt, sondern auch ausgelöst werden muss, um nicht nur ungenutzter Sourcecode zu sein.
Events
91
Bitte beachten Sie, dass das Event in der Klasse ausgelöst wird, aber dort keine Auswertung stattfindet. Die Auswertung erfolgt wir in einer anderen Routine. 15 16 17 18
19 20 21
22
Sub Main() Dim Assisten As New AuktionsAssistent Dim i As Integer AddHandler Assisten.ZuTeuer, AddressOf IstZuTeuer For i = 10 To 150 Step 10 Assisten.Bieten(i) Next End Sub
Die Sub Main() ist recht übersichtlich. Wir finden hier die Deklaration unserer Klasse und die der Variablen i. Interessant ist die Zeile 18. Mit dem Schlüsselwort AddHandler melden wir das Ereignis ZuTeuer an. Gleichzeitig teilen wir dem System mit, was es tun soll, wenn dieses Ereignis ausgelöst wird. In unserem Fall soll die Methode IstZuTeuer ausgeführt werden. Wichtig ist, dass die Methode die gleichen Parameter besitzt wie das Ereignis selbst. Dies ist notwendig, damit die übergebenen Werte auch transportiert werden können. 23 24
25 26 27 28 29
Sub IstZuTeuer(ByVal Preis As Double) Console.WriteLine("Leider ist der Preis von " & _ Preis & " € zu hoch!") Console.WriteLine("Auktion zu Ende - Drücken Sie Enter") Console.ReadLine() End End Sub End Module
Beim Ausführen dieses Beispiels bekommen wir die folgende Bildschirmausgabe. Der Preis von 10 ? ist in Ordnung! Der Preis von 20 ? ist in Ordnung! Der Preis von 30 ? ist in Ordnung! … Der Preis von 80 ? ist in Ordnung! Der Preis von 90 ? ist in Ordnung! Leider ist der Preis von 100 ? zu hoch! Auktion zu Ende - Drücken Sie Enter
92
Klassen
In der Methode IstZuTeuer wird das Event ZuTeuer ausgewertet. Subroutine und Event haben die gleichen Parameter. Nur so kann das Ereignis ausgewertet werden. Der Vorteil dieser Programmiertechnik liegt darin, dass Ereignisse nicht kontinuierlich überwacht werden müssen. Erst wenn das Ereignis ausgelöst wird, wird der entsprechende Sourcecode ausgeführt. Hierdurch ist die Hauptroutine eines Programms entlastet und der Sourcecode bleibt übersichtlicher.
11.8 Ein umfassendes Beispiel Zum Abschluss der Klassen möchten wir das Thema durch praktische Übung festigen und vertiefen. Wir werden eine Adressenklasse erstellen. Diese soll nicht nur die normalen Adressdaten aufnehmen, sondern etwas mehr Luxus bieten. Wir legen fest, welche Fähigkeiten unsere Adressenklasse besitzen soll: • Die Klasse soll in der Lage sein, normale Adressdaten aufzunehmen. • Dem Benutzer soll eine Auswahlhilfe bei der Anrede angeboten werden. • Die Klasse soll feststellen, ob das Alter in einem gültigen Bereich liegt. Zuerst müssen wir die Klasse Adresse erstellen. Diese wird folgende Properties enthalten: • • • • • • •
Name Vorname Straße PLZ Ort Anrede Alter
Neben den Properties verwenden wir noch die Enumeration enumAnrede. Diese Konstantenliste soll uns bei der Eingabe der Anrede behilflich sein. Sie können versuchen, den Sourcecode selbst zu erzeugen. Das Erstellen der Klasse sowie die Implementierung der Properties haben wir bereits in früheren Abschnitten des Buches besprochen, ebenso die Enumeration.
Ein umfassendes Beispiel
93
11.8.1 Erstellen der Klasse Wir beginnen das Beispiel mit der Einleitung der Routine Module1 und der Deklarierung der Klasse Adresse. 1 2 3
4 5
Module Module1 Class Adresse Dim strName, strVorname, strStraße, strPLZ, _ strOrt As String Dim enuAnrede As enumAnrede Dim intAlter As Integer
In den Zeilen 3 - 5 deklarieren wir die Felder, die für den Programmablauf benötigt werden. Hauptsächlich sind das Variablen, welche die zugewiesenen Werte über die Properties aufnehmen. 6 7 8 9 10
Enum enumAnrede Frau = 1 Herr = 2 Dr = 4 End Enum
Die Zeilen 6 - 10 sind für die kleine Enumeration reserviert. Hier werden ein paar Standardanreden gespeichert. Sie können die Auflistung beliebig erweitern. Zu dem eigentlichen Vorteil der Auflistung kommen wir, wenn wir die Klasse mit Daten füllen. Dann stehen uns genau diese Einträge in einer Auswahlliste zu Verfügung. 11 12 13 14 15 16 17 18
Property Name() Get Return strName End Get Set(ByVal Value) strName = Value End Set End Property
19 20 21 22 23 24 25 26 27
Property Vorname() Get Return strVorname End Get Set(ByVal Value) strVorname = Value End Set End Property
28 29 30
Property Straße() Get
94 31 32 33 34 35 36
Klassen Return strStraße End Get Set(ByVal Value) strStraße = Value End Set End Property
37 38 39 40 41 42 43 44 45
Property PLZ() Get Return strPLZ End Get Set(ByVal Value) strPLZ = Value End Set End Property
46 47 48 49 50 51 52 53 54
Property Ort() Get Return strOrt End Get Set(ByVal Value) strOrt = Value End Set End Property
55 56 57 58 59 60 61 62 63
Property Anrede() As enumAnrede Get Return enuAnrede End Get Set(ByVal Value As enumAnrede) enuAnrede = Value End Set End Property
64 65 66 67 68 69 70 71 72 73 74 75 76 77
Property Alter() As Integer Get Return intAlter End Get Set(ByVal Value As Integer) If Value < 130 And Value > 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
Mein erstes DirectX-Programm
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
Mein erstes DirectX-Programm
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
D3DDevice.Transform.World = wMatrix
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
D3DDevice.Transform.World = wMatrix
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
Multitexturing (Multi Texture Mapping)
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 r