DirectX vs. OpenGL - · PDF file1.3 Bekannte Graﬁkengines Projekt Graphik Die Texturen...

Projektarbeit Computergraphik

DirectX vs. OpenGL

Fachbereich: 12. InformatikBetreut durch Prof. Dr. Xiaolin Zhou

von

Patrick Schmid, Christian Piwecki

4. Juli 2005

INHALTSVERZEICHNIS Projekt Graphik

Inhaltsverzeichnis

1 Grafikengines 2

1.1 Was ist eine Grafikengine ? . . . . . . . . . . . . . . . . . . . 2

1.2 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.3 Bekannte Grafikengines . . . . . . . . . . . . . . . . . . . . . 3

1.4 Meilensteine von 3D Grafik Engines . . . . . . . . . . . . . . 5

2 Schnittstellen fur Grafikengines 7

3 Bekannte Grafikschnittstellen 8

3.1 OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.1.1 Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.1.2 Was ist OpenGL ? . . . . . . . . . . . . . . . . . . . . 8

3.1.3 Leistungsfahigkeit . . . . . . . . . . . . . . . . . . . . 8

3.1.4 Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . 19

3.2 DirectX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2.1 Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2.2 Was ist DirectX ? . . . . . . . . . . . . . . . . . . . . 20

3.2.3 Leistungsfahigkeit . . . . . . . . . . . . . . . . . . . . 21

3.2.4 Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Unterschiede DirectX und OpenGL 32

5 Projekt-Fazit 34

6 Literaturverzeichnis 35

7 Anhang 36

7.1 Open GL Funktionsliste . . . . . . . . . . . . . . . . . . . . . 36

7.2 Realisierung eines Wurfels unter OpenGL . . . . . . . . . . . 38

7.3 Realisierung eines Wurfels unter DirectX . . . . . . . . . . . . 46

Abbildungsverzeichnis

1 Flag-Erklarung,Diffuse & Ambient Light . . . . . . . . . . . . 14

2 Eine Primitive mit 3 Vertices . . . . . . . . . . . . . . . . . . 24

3 Die Direct3D-Rendering-Pipeline . . . . . . . . . . . . . . . . 27

1

1. Grafikengines Projekt Graphik

1 Grafikengines

1.1 Was ist eine Grafikengine ?

Die Grafikengine ist ein eigenstandiger Programmteil. Sie ist zustandig furdie Darstellung von Computergrafik. Grafikengines sind fur Programmierereine große Hilfe, da sie oft benotigte Standardfunktionen besitzen um um-fangreiche Computergrafiken zu erstellen, ohne diese neu programmieren zumussen. Sie beinhalten meist allgemein folgende Funktionen:

• Geometrische Objektbeschreibung

• Oberflachentexturen

• Licht und Schatten

• Transparenz

• Spiegelungen

Daruber hinaus konnen Grafikengines auch weitere Aufgaben erfullen. Ei-ne Grafikengine zeichnet sich durch extrem aufwendige Optimierungen undBerechnungen aus.

Die Grafikengine ist eigentlich Bestandteil der Game Engine - wird aberseparat fur andere Applikationen verwendet, die 3D - Grafiken darstellenmussen.

1.2 Funktionen

Eine Grafik- bzw. 3D - Engine hat die Aufgabe Objekte, die sowohl zwei-als auch dreidimensional sein konnen, in einem 3D Raum zu erstellen, an-zuzeigen und zu bewegen. Der dreidimensionale, virtuelle Raum ist uberein Koordinatensystem mit x-, y- und z- Achse implementiert. Die x - Ko-ordinaten befinden sich im horizontalen Bereich des Bildschirms, die y -Koordinaten im vertikalen und die z - Koordinaten geben an wie tief einObjekt im Bildschirm liegt. Da fur eine umfangreichere dreidimensionaleDarstellung viel Rechenarbeit benotigt wird setzt man zusatzliche Hard-ware in Form von GPUs (Graphics Processing Unit) auf Grafikkarten einum die CPU zu entlasten. Mit diesem zweiten Prozessor wird es moglich,dass Algorithmen parallelisiert abgearbeitet werden. Die am haufigsten ver-wendeten Programmbibliotheken, die Grafikkarten ansprechen sind OpenGLund DirectX. Es gibt sicherlich sehr viele unterschiedliche Moglichkeiten ei-ne Grafikengine zu implementieren. Bewahrt hat sich aber, die Objekte mitHilfe von Polygonen aufzubauen, diese nach bestimmtem Schema zu verbin-den und die entstehenden Flachen mit einer Textur zu belegen. Polygonesind einfache Punkte im 3D - Raum. Jedes Polygon besitzt eine x -, eine y- sowie eine z - Koordinate.

2

1.3 Bekannte Grafikengines Projekt Graphik

Die Texturen konnen in weiterentwickelten 3D- Engines noch weiter mitBumpmaps uberzogen werden, die der Textur ein plastisches Aussehen ver-leihen. Daruber hinaus gibt es Partikeleffekte mit denen sich beispielsweiseExplosionen, Nebel, Feuer, Schmutz und Wasser realitatsnah darstellen las-sen. Ein Partikel ist ein kleines Teilchen - also ein einzelnes Polygon - das miteiner Textur uberzogen ist. Sie werden meist von Partikel - Emittern erzeugt,die eine großere Anzahl mit unterschiedlichen Eigenschaften wie Geschwin-digkeit, Richtung und Lebensdauer ausstoßen. Die neuste Entwicklung aufdiesem Gebiet sind Pixel- und Vertex - Shader. Ein Pixelshader ist ein As-semblerprogramm, das direkt auf der Grafikkarte ausgefuhrt wird. Sie sindalso hardwareabhangig. Mit ihrer Hilfe konnen Effekte wie Spiegelungen,Schattierungen, Falloff, Lensglow, Lensflares auf Basis von Materialeigen-schaft und Textur sehr realitatsnah implementiert werden. Ein Vertexshaderberechnet Anderungen von Form und Lichteinfall von/auf ein 3D - Objekt.Texturen und Oberflachen werden jedoch nicht berechnet. Nach dem Ver-texshader kommt der Pixelshader zum Einsatz.

1.3 Bekannte Grafikengines

Meist tragen Grafikengines den Namen seiner Anwendung. Dennoch wer-den oft Grafikengines programmiert, die eigene Namen tragen. Grafikengineswerden oft uber viele Jahre hinweg zum Einsatz kommen. Mit ihrem Altersinkt auch der Kaufpreis da auch die Moglichkeiten die man mit Grafikengi-nes hat zeitlich begrenzt sind. Ein kleiner Uberblick bekannter Grafikenginesund deren Verwendung verdeutlicht diese rasante Entwicklung:

• Quake-Engine (1996-1999)

Die Quake-Engine wurde erstmals 1996 im Spiel Quake verwendet. Als er-ste Grafikengine konnte sie 3D Polygonemodelle darstellen anstelle von 2DSprites. Dynamische Beleuchtungsmethoden wurden erstmals verwendet u.a.Lightmaps, Real-Time-Lightsourcing. Erstmals hatte man die Moglichkeiteinen 3D-Grafikkartenbeschleuniger zu verwenden. Sie wurde bis 1999 vonID-Software vertrieben und 1999 als Open Source herausgegeben. Die Qua-ke3 Engine war die meist verkaufteste Grafikengine jemals. Kaufpreis damalsca. 250 000 US Dollar

• Unreal-Engine (1998-2007?)

Von Epic Software kam 1998 die Unreal Engine. Sie sollte damals der QuakeEngine das Wasser reichen konnen. Noch heute ist diese Engine im Einsatzund wird noch weiterentwickelt. Kaufpreis ca. 350 000 - 500 000 US Dollar

3

1.3 Bekannte Grafikengines Projekt Graphik

• CryENGINE (2003)

CryTek veroffentlichte 2002 die CryENGINE, welche schon zuvor in kleine-ren Grafikdemos wie das X-Isle Demo zum Testeinsatz kam. Die CryEN-GINE ist die erste Grafikengine, welche aus Deutschland kam und im USMarkt eine echte Begeisterung ausloste. Als erste Engine hatte diese u.a. dieMoglichkeit physikalisch korrekt berechnete Effekte einzusetzen. Uber denKaufpreis gibt es derzeit keine Angaben.

• Source Engine (2004)

Valve Software veroffentlichte ihre neueste Engine 2004. Sie ist sozusagen wiedie CryENGINE State-of-the-Art. Unterstutzung aller DirextX Versionenvon 6-9, physikalische Effekte usw. Die Engine ist noch im Einsatz und wirdsehr oft lizenziert. Kaufpreis ca. 400 000 - 500 000 US Dollar

4

1.4 Meilensteine von 3D Grafik Engines Projekt Graphik

1.4 Meilensteine von 3D Grafik Engines

Dank ihrer Grafikengines verdanken viele Meilensteine der PC Spiele Ge-schichte ihr Dasein. Einige dieser als kurze Auflistung mit Spielname, Firmaund Erscheinungsjahr zum Uberblick:

• Doom (Id Software, 1993)

• Doom II (Id Software, 1994)

• Quake (Id Software, 1995) Quake II (Id Software, 1996)

• Unreal (Epic Games, 1998)

• Quake III (Id Software, 1999)

• Unreal Tournament 2003 (Epic Games, 2002)

• Far Cry (Crytek, 2004)

• Doom 3 (Id Software, 2004)

• Half-Life 2 (Valve, 2004)

Neben den großen und bekannten Grafikengines gibt es auch noch wenigerbekannte, aber dennoch auf dem Markt existente.

• 3DGM

• A6

• Blitz

• Cipher

• DB / DBPro

• Jamagic

• Jupiter

• Mad F/X 1.0

• PR

• Quest

• Radish

• RF

• TV3D

• Torque

5

1.4 Meilensteine von 3D Grafik Engines Projekt Graphik

Die bisher angegeben Engines sind rein kommerzieller Natur, aber es gibt aufdem Markt auch eine große Anzahl von Open Source Grafikengines. Einigedieser Engines in dieser Auflistung:

• Irrlicht Engine

• Nebula2EngineCrystalSpace3DEngine

•• zFXc Engine

• Ogre-Engine C++

• Axiom-Engine C# (.NET Portierung der Ogre-Engine)

6

2. Schnittstellen fur Grafikengines Projekt Graphik

2 Schnittstellen fur Grafikengines

Die Schnittstelle ist ein plattform- und programmiersprachenunabhangigesAPI (Application Programming Interface). Sie ist nur eine standardisierteProgrammbibliothek und somit keine Implementierungen. Die Befehle wer-den erst vom Betriebsystem ubersetzt und an den Grafikkartentreiber uber-mittelt. Der Treiber gibt die Befehle dann an die Grafikkarte bzw. an dieCPU weiter, falls die Grafikkarte fur einen bestimmten Befehl nicht qua-lifiziert ist. Der Grafikkartenhersteller muss also in Form des Treibers dieImplementierung gewahrleisten.

7

3. Bekannte Grafikschnittstellen Projekt Graphik

3 Bekannte Grafikschnittstellen

3.1 OpenGL

3.1.1 Geschichte

OpenGL (Open Graphics Library) entwickelte sich aus der sogenanntenIrisGL von SGI. Sie wurde entwickelt um Programme mit GL - Unterstut-zung portierfahiger zu machen da die IirisGL nur auf SGI - Computer lief.Um einen hohen Verbreitungsgrad zu erreichen hatte auch ARB (Architec-ture Review Board) Einfluss auf das Design der Programmbibliothek. DieARB ist ein Zusammenschluß von mehreren Soft- sowie Hardwarefirmendarunter 3D Labs, ATI, Apple, Dell, HP, Matrox, nVidia, IBM, Intel, Mi-crosoft (bis Marz 2003), Silicon Graphics, Digital Equipment (DEC), EvansSutherland und Intergraph, die sich vier mal im Jahr treffen um uber die Zu-kunft des Standards zu diskutieren. Die ARB entwickelte einen sogenanntenConformance Test. Jede neue Version von OpenGL muss diesen Test positivdurchlaufen um veroffentlicht zu werden und damit gewahrleistet werdenkann dass die verschiedenen Versionen kompatibel sind und gleiche Ergeb-nisse liefern.

Die Kosten fur diese Test sowie fur die Verwaltung werden uber Lizenzzah-lungen finanziert. Eine Lizenz kostet je nach Art zwischen 25000 und 100000Dollar einmalig und 5 Dollar pro verkaufter Kopie der Bibliothek. Das giltjedoch nur fur Versionen die den Conformance Test durchlaufen haben. An-dere OpenGl - Implementationen konnen ebenfalls veroffentlicht werden, furdiese mussen keine Lizenzen bezahlt werden - durfen sich aber auch nichtOpenGL nennen.

3.1.2 Was ist OpenGL ?

OpenGL ist neben DirectX eine der wichtigsten Schnittstellen fur Grafiken-gines. Im Gegensatz zu DirectX, das von Microsoft stammt ist OpenGL einOpen Source Projekt. Das heißt die OpenGL wird laufend weiterentwickeltund steht jedem kostenlos zur Verfugung.

3.1.3 Leistungsfahigkeit

OpemGL verfugt uber eine große Anzahl von Funktionen mit denen Anwen-dungen uber eine Ansammlung von Bibliotheken komfortabel und einfachergestaltet werden konnen. Die wichtigsten sind die Utility Library (GLU),deren Funktionen auf OpenGL aufbauen und das Werkzeug OpenInventor,das Szenenbeschreibungen als Text- oder Binardatei einlesen bzw. schreibenkann. Das Format mit dem OpenInventor arbeitet ist gleichzeitig grundla-ge fur den Standard VRML (Virtual Reality Modeling Language). VRMLwird fur Erstellung von 3D - Szenen im Internet verwendet. Weitere wichtigeBestandteile sind:

8

3.1 OpenGL Projekt Graphik

• GLX -> Schnittstelle zwischen X - Window - System und OpenGL

• WGL -> Schnittstelle zwischen Windows und OpenGL

• AGL und CGL -> Schnittstelle zwischen MAC und OpenGL

• GLUT -> Bibliothek die auf den Paketen OpenGL, GLU, GLX undje nach Plattform auf GLX, WGL oder AGL aufbaut und daruberhinaus eine plattformunabhangige API fur Erstellung von Rendering-Contexten sowie fur Ein- und Ausgabe beinhaltet.

• Java3D -> API fur Java um 3D Anwendungen fur Java 2 Environmentszu entwickeln

• OpenAL -> Open Audio Library fur 3D - Raumklang

• GLSL -> OpenGL Shading Language fur direktes Programmieren derGrafikhardware

• SDL -> Simple DirectMedia Layer: freie Multimedia-Bibliothek

Um Unabhangigkeit zu Rechnertyp und Betriebsystem zu erhalten verzich-tet OpenGL komplett auf Funktionen, die Fenster verwaltet, Eingaben vonMaus/Tastatur verwaltet und Funktionen zur Dateiein- bzw. Ausgabe. Alldas muss vom Betriebsystem fur die jeweilige Plattform zur Verfugung ge-stellt werden. In OpenGL werden keine Objekte als Ganzes gezeichnet. Statt-dessen werden alle Punkte, Polygone und Linien (primitive genannt) sofortgezeichnet, nachdem sie der OpenGL ubergeben worden sind. Alle gezeich-neten primitives werden sofort “vergessen“. Die Applikation gibt also anwelche primitives gezeichnet werden und mit welchen Einstellungen. Nebenden primitives (also den Objekten bzw. was gezeichnet wird) gibt eine großeAuswahl von Eigenschaften an wie etwas gezeichnet werden soll. Diese Ein-stellungen konnen jederzeit geandert werden und wirken sich auf alle nach-folgenden Zeichenoperationen aus. Die aktuellen Einstellungen, die der Nut-zer verwendet bilden einen Kontext. Es konnen mehrere Kontexte erstelltwerden und man kann zwischen ihnen umschalten. Der aktuelle Kontextwird auch als State Machine bezeichnet, da er eine Art Statusinformationdarstellt.

Grundsatzliche Vorgehensweise beim Erstellen eines OpenGL - Programms:Als erstes mussen folgende Pakete includiert werden: gl.h, glu.h und glux.hDem Linker mussen folgende Bibliotheken bekannt gemacht werden:OpenGL32.lib GLu32.lib und GLaux.lib.Dann muss ein Kontext undein Fenster erzeugt werden. Diese beiden Objekte werden dann miteinanderverbunden. Wird die GLUT Bibliothek verwendet, hat man die Moglich-keit ohne Kenntnisse von WinAPI oder MFC sehr einfach ein Fenster zuerstellen. Hierfur verwendet man folgende Funktionen:

• glutInit(&argc, argv);Initialisiert die GLUT Library

9


• glutInitWindowSize(int width, int height);Setzt die Große des Fensters

• glutInitWindowPosition(int x, int y);Setzt die Position des Fensters

• glutCreateWindow(WindowTitle);Erstellt das Fenster mit dem Parameter als Titel

• glutDisplayFunc(display);Deklariert die Funktion die fur den Fensterinhalt verantwortlich ist

• glutReshapeFunc(reshape);Deklariert die Funktion die aufgerufen wird, wenn das Fenster in derGroße verandert, bewegt oder minimiert/maximiert wird.

• glutMainLoop();Ermoglicht Event-Handling und ruft entsprechende Callback-Funktionenauf.

Nun werden immer abwechselt am Kontext Einstellungen vorgenom-men und eine Reihe von primitives, die vorher spezifiziert wurden ge-zeichnet.

Am Ende der Applikation muss der Kontext wieder freigegeben werdenbevor das Fenster wie gewohnt geschlossen wird. Wie bereits erwahntgibt es drei Arten von primitives: Punkte, Linien und Polygone. Diesekonnen aber noch in weiteren 10 unterschiedlichen Arten spezifiziertwerden. Die am haufigsten benutzte ist sicherlich das Dreieck (Tri-angle).

Um in OpenGL bekannt zu geben, daß eine Reihe von primitives spezi-fiziert wird, wird die Funktion glBegin() aufgerufen. Die Art, wie dieprimitives verbunden werden sollen, wird der Funktion als Parameterubergeben:

– glBegin(GL TRIANGLES);Gibt an, daß immer 3 Punkte zu einem Dreieck verbunden werden

– glBegin(GL QUADS);Gibt an, dass immer 4 Punkte zu einem Viereck verbunden wer-den

– glBegin(GL POLYGON);Definiert einzelne Polygone

– glBegin(GL POINTS);Behandelt jeden Vertex als einzelnen Punkt

– glBegin(GL LINES);Behandelt immer jeweils 2 Vertexe als Endpunkte einer Linie

10


– glBegin(GL LINE STRIP);Zeichnet eine Gruppe von Liniensegmenten zwischen Anfang undEnde aller Vertexen

– glBegin(GL LINE LOOP);Zeichnet ebenfalls eine Gruppe von Liniensegmenten zwischen al-len Vertexen; Anfang und Ende sind jedoch verbunden.

– glBegin(GL TRIANGLE STRIP);Zeichnet eine Gruppe von verbundenen Dreiecken

– glBegin(GL TRIANGLE FAN);Zeichnet eine Gruppe von verbundenen Dreiecken, wobei alle einengemeinsamen Punkt besitzen (eine Art Kegel entsteht)

– glBegin(GL QUAD STRIPS);Zeichnet eine Gruppe von verbundenen Rechtecken. Immer 2 Punk-te des vorgehenden Rechtecks sind ebenfalls Punkte des folgendenRechtecks.

Innerhalb der Funktion glBegin kann man dann wiederum mit Funktio-nen jedes einzelne primitive (z.B. jeden einzelnen Punkt) sowie dessenEigenschaften (z.B. Farbe, Texturkoordinaten, Normalen usw.) eben-falls uber spezielle Funktionen spezifizieren.

Eine wichtige Funktion, die Eckpunkte fur Dreiecke (Triangles) sowiefur Vierecke (Quads) beschreibt ist glVertex(). Diese Funktion gibt esin 24 Ausfuhrungen - jeweils eine fur jeden Datentyp (von unsignedbyte bis double).

11


Die Gebrauchlichsten sind:

– glVertex2f(x, y) die 2 Float - Werte als Parameter aufnimmt

– glVertex3f(x, y, z) die 3 Float - Werte als Parameter aufnimmt

– glVertex2d(x, y) die 2 Double - Werte als Parameter aufnimmt

– glVertex3d(x, y, z) die 3 Double - Werte als Parameter aufnimmt.

Um einem Eckpunkt eine Eigenschaft zuzuordnen, z.B. eine Farbe lasstman die Applikation bevor das primitive definiert wird, uber die Funk-tion glColor() - von der ebenfalls je nach Datentyp mehrere Versionenverfugbar sind - eine Farbe fur den jeweils folgenden Eckpunkt festle-gen.

Auswahl von glColor() - Versionen:

– glColor3b(r, g, b) definiert eine Farbe uber 3 Byte - Parameter,die fur RGB stehen

– glColor3f(r, g, b) definiert eine Farbe uber 3 Float - Parameter,die fur RGB stehen

– glColor4d(r, g, b, a) definiert eine Farbe uber 4 Double - Para-meter, die fur RGB plus einem Alpha - Wert stehen

Um der OpenGL mittzuteilen, daß alle primitives beschreiben wurdenwird die Funktion glEnd() aufgerufen. Zwischen glBegin() und glEnd()kann nur auf eine begrenzte Auswahl der OpenGL - Funktionen zuge-griffen werden. Außerhalb stehen sie uneingeschrankt zur Verfugung.

Beispiel:

glBegin(GL TRIANGLES);glColor3f(1.0f, 1.0f, 1.0f);glVertex2f(0.0f, 0.0f);glVertex2f(1.0f, 0.0f);glVertex2f(0.0f, 1.0f);glEnd();

Zeichnet ein einfaches zweidimensionales Dreieck.

12


Um wirklich etwas sehen zu konnen muss das Objekt auf der z-Achsenach hinten, also in den Bereich gebracht werden, den der Bildschirmdarstellt. Um Objekte zu verschieben - bzw. den Ausgangspunkt fest-zulegen, von dem aus das Objekt gezeichnet werden soll, verwendetman die Funktion glTranslatef() (z.B.). glTranslatef() werden 3 Float- Werte ubergeben von denen der z - Wert negativ sein sollte. DieseFunktion muss vor glBegin() ausgefuhrt werden ! Es gibt viele Funktio-nen die vor einem glBegin() ausgefuhrt werden konnen. Eine vollstan-dige Liste mit allen Funktionen befindet sich auf der Seite X. Detai-lierte Informationen uber die Funktionen kann man in jeder Referenznachlesen (z.B. auf http://www.rush3d.com/reference/opengl-bluebook-1.0/). Besonders hervorzuheben sind aber folgende

Allgemeine Funktionen

– glClear(red, green, blue, alpha); Leert Buffer, die in der Parame-terliste angegeben werden.

– glLoadIdentity(x,y,z); Ersetzt aktuelle Matrix durch Identitats-matrix. D.h. es wird zum Ursprung zuruckgesprungen.

– glRotatef(angle,x,y,z); Multipliziert die aktuelle Matrix mit einerRotationsmatrix -> das Objekt dreht sich. Als Parameter sindangle, x, y und z. Angle gibt den Winkel an mit dem gedrehtwerden soll. x, y und z definieren den Vektor, um den gedrehtwerden soll.

– glShadeModel(GL SMOOTH); Wahlt eine Shadingtechnik aus,die angibt, wie ein Objekt gefarbt werden soll. Wahlt man denParameter GL SMOOTH (Standard), wird der Farbverlauf zwi-schen den einzelnen Punkten (primitives) berechnet. Bei GL FLATwird das gesamte Objekt in der Farbe des letzten Vertexes ge-farbt.

– glClearColor(red, green, blue, alpha); Definiert die Loschfarbe

Lichtorientierte Funktionen

– glLightf(light, pname, param);Diese Funktion setzt Lichtquellen - Eigenschaften.

– lightGL LIGHTi wobei i fur die Nummer der Lichtquelle steht.Es gilt i <= GL MAX LIGHTS.

– pnameGL SPOT DIRECTION Definiert die Richtung der Haupt-achse des Lichtkegels.

– GL SPOT POSITION Definiert die Position der Lichtquelle.

– GL SPOT EXPONENT Definiert den Wert der Verteilungder Leuchtintensitat innerhalb des Lichtkegels. Je hoher der Wert,desto gebundelter der Lichtstrahl.

13


– GL SPOT CUTOFF Definiert den Winkel zwischen Haupt-achse und Rand des Lichtkegels. Werte zwischen 0 und 90 sindmoglich.

– GL AMBIENT Definiert die RGBA Werte fur ambientes Licht

– GL DIFFUSE Definiert die RGBA Werte fur diffuses Licht

– GL SPECULAR Definiert die RGBA Werte des reflektierendenLichts

– GL CONSTANT ATTENUATION Definiert den konstan-ten Wert zur Berechnung der Lichtdampfung

– GL LINEAR ATTENUATIONDefiniert den linearen Wertzur Berechnung der Lichtdampfung

– GL QUADRATIC ATTENUATION Definiert den quadra-tischen Wert zur Berechnung der Lichtdampfung

Abbildung 1: Flag-Erklarung,Diffuse & Ambient Light

14


Texturorientierte Funktionen

– GenTextures(n, &zeigerauftextur[0]);Erstellt einen Texturnamen

– glBindTexture(GL TEXTURE 2D, textur[0]);Bindet die Textur an das angegebene Ziel. Mogliche Ziele:GL TEXTURE 1D -> 1 dimensionale TexturGL TEXTURE 2D -> 2 dimensionale TexturGL TEXTURE 3D -> 3 dimensionale Textur

– glTexImage2D(target,level,components,width,height,depth,border,format,type,pixels);Legt Einstellungen fur die Textur fest wie die Textur gezeichnetwerden soll.Alternativ: glTexImage1D() oder glTexImage3D()targetGL TEXTURE 1D -> eindimensionale TexturGL TEXTURE 2D -> zweidimensionale TexturGL TEXTURE 3D -> dreidimensionale Textur Level Detailgradfur die Textur level 0 ist das Basisbild. Level n ist die n-te Mipma-preduzierung des Bildes. Mipmap = gleiche Textur mit geringererAuflosung, also in großerer Entfernung components1 fur R2 fur R und A3 fur RGB4 fur RGBA

width Anzahl der Pixel pro Zeile (muss in 2er Potenz angege-ben werden)height Anzahl der Zeilen (muss in 2er Potenz angegeben werden)depth Tiefe (muss in 2er Potenz angegeben werden)border Breite des Rahmens 0 oder 1 format Format der Pixel-daten.

Folgende Parameter stehen zur Auswahl:GL COLOR INDEX, GL RED, GL GREEN, GL BLUE,GL ALPHA, GL RGB, GL RGBA, GL LUMINANCE,und GL LUMINANCE ALPHA TYPE

Type = Pixeltyp des Inhalts von pixels.

15


Folgende Typen werden unterstutzt:GL UNSIGNED BYTE, GL BYTE, GL UNSIGNED SHORT,GL SHORT, GL UNSIGNED INT, GL INT, GL FLOAT,GL BITMAPpixels Textur-Image Daten oder Array wo die Pixel gespeichertsind

– glTexParameter(target, pname, params);Legt Eigenschaften der Textur fest. target -> siehe oben pname

– GL TEXTURE MIN FILTERVerkleinerungsfunktion, die eine zu große Textur auf eine kleinereFlache abbildet.

– GL TEXTURE MAG FILTERVergroßerungsfunktion, die eine zu kleine Textur auf eine großereFlache abbildet. GL TEXTURE WRAP S Textur geht uberGrenzen hinaus - sie umwickelt das Objekt.

Es stehen folgende params zur Verfugung:

– GL CLAMP:Umwicklung mit begrenzter Reichweite der Texturkoordinate s.

– GL REPEAT:Umwicklung mit unbegrenzter Reichweite der Texturkoordinates.

– GL TEXTURE WRAP T Wie GL TEXTURE WRAP S je-doch bezogen auf Texturkoordinate t.

– GL TEXTURE BORDER COLORSetzt die Randfarbe. Der Parameter params enthalt vier Werte,die den RGBA-Farbwert fur den Texturenrand darstellen.params liefert folgende Funktionen zur Verkleinerung von Textu-ren:

– GL NEARESTDer Wert des Texturelements, welches am nachsten zum Zentrumdes zu texturierenden Pixels liegt wird verwendet

– GL LINEARDer Mittelwert der vier Texturenelemente die dem Zentrum deszu texturierenden Pixels am nachsten liegen wird verwendet.

– GL NEAREST MIPMAP NEARESTWahlt Mipmap, die der Große des zu texturierenden Pixels ambesten entspricht, und nutzt die Kriterien von GL NEARESTum den Texturenwert zu generieren.

– GL LINEAR MIPMAP NEARESTWahlt Mipmap, die der Große des zu texturierenden Pixels ambesten entspricht, und nutzt die Kriterien von GL LINEAR umden Texturenwert zu generieren.

16


– GL NEAREST MIPMAP LINEARVerwendet den gewichteten Mittelwert der zwei Mipmaps, die derGroße des zu texturierenden Pixels am besten entsprechen, undnutzt die Kriterien von GL NEAREST um den Texturenwertzu generieren.

– GL LINEAR MIPMAP LINEARVerwendet den gewichteten Mittelwert der zwei Mipmaps, die derGroße des zu texturierenden Pixels am besten entsprechen, undnutzt die Kriterien von GL LINEAR um den Texturenwert zugenerieren.

– glTexCoord2f(0.0f, 0.0f);Setzt die Texturkoordinaten. Sie stehen im Zusammenhang mitden Eckpunkten der Polygone. Alternativ: glTexCoord1f, glTex-Coord2d(), glTexCoord3f(), usw.

Funktionen zur Konfiguration der OpenGL - Engine

– glEnable(FLAG);Mit glEnable() und dem entsprechenden Flag lassen sich ver-schiedene Einstellungen und Optimierungen vornehmen bzw. ak-tivieren, die sich direkt auf die Anzeigemethoden auswirken. Ei-nige Flags sind:

– GL ALPHA TESTBei Aktivierung wird Alphatest durchgefuhrt.

– GL BLENDBei Aktivierung werden RGBA - Farben mit den Farben im Farb-puffer gemischt.

– GL COLOR MATERIALBei Aktivierung werden Materialparameter durch die aktuelleFarbeinstellung.

– GL CULL FACEBei Aktivierung werden Polygone entsprechend ihrer Laufrich-tung ausgeschlossen

– GL DEPTH TESTBei Aktivierung wird der Tiefenpuffer (z-Buffer) aktiviert.

– GL DITHERDithering wird aktiviert.

– GL FOGBei Aktivierung wird die Nebelfarbe in den Farbwert der Texturgemischt.

– GL LIGHTiLichtquelle i wird aktiviert.

– GL LIGHTINGBei Aktivierung werden die aktuellen Beleuchtungsparameter ver-wendet um Vertex-/Indexfarbe zu berechnen.

17


– GL LINE SMOOTHBei Aktivierung wird die Linie als echtes Rechteck gezeichnet,ansonsten als Parallelogramm mit einem Winkel ungleich 90◦.

– GL LINE STIPPLEBei Aktivierung werden Linien gepunktelt oder gestrichelt darge-stellt.

– GL NORMALIZEBei Aktivierung werden Normalenvektoren auf Einheitslange ska-liert.

– GL POINT SMOOTHBei Aktivierung werden Punkte gefiltert gezeichnet.

– GL SCISSOR TESTBei Aktivierung werden Elemente verworfen die außerhalb einesdurch glScissor() definierten Bereich liegen.

– glDisable(FLAG);glDisable() funktioniert analog zu glEnable(). Es werden dieals Parameter angegebenen Flags wieder zuruckgesetzt.

Die Grafik-Pipeline von OpenGL

Nachdem die Koordinaten eines Vertexes uber die Funktion glVer-tex() definiert wurden wird der Vertex durch die Modelview-Matrixtransformiert, die unter anderem Informationen uber die Kameraein-stellung enthalt. Als Ergebnis erhalt man einen Punkt im Raum mitsogenannten Augenkoordinaten. Nun werden die Lichteffekte, die aufihn wirken berechnet und anschließend nochmals von der Projektions-matrix (entweder Parallelprojektion oder Zentralprojektion) transfor-miert. Als Ergebnis erhalt man die sogenannten Clipkoordinaten diedann durch die Window-Transformation in Fensterkoordinaten umge-rechnet werden. Aus mehreren so erzeugten Punkten bildet OpenGLdann das entsprechend gewahlte primitive. Durch Rasterung wird die-ses primitive dann in einzelne Fragmente, den Pixeln zerlegt. JedesPixel besitzt Informationen wie z.B. Farbe, Entfernung zum Betrach-ter, Texturkoordinaten, usw. Die durch Rasterung entstandenen Pixeldurchlaufen bevor sie endgultig auf dem Bildschirm angezeigt werdennoch einen Z-Buffertest und das Dithering.

18


3.1.4 Entwicklung

Die zurzeit aktuelle Version der OpenGL ist OpenGL 2.0, die erst-mals direkt in den Kern implementierte, programmierbare Shader un-terstutzt. Neu dafur entwickelt wurde die so genannte OpenGL Sha-ding Language. Daruber hinaus gibt es weitere Varianten wie zumBeispiel die OpenGL ES. Dieser offene API Standard wird zur Er-zeugung von 2D/3D - Grafiken fur mobile Multimedia Applikationenauf Palms und Smartphones verwendet. Ein weiterer Ableger ist dieOpenML, die sich auf Audio-, Video- und Grafikfunktionen speziali-siert.

Angesichts der zwolf stimmberechtigten Mitgliedern der OpenGL ARB:3Dlabs, Apple, ATI, Dell, Evans Sutherland, Hewlett-Packard, IBM,Intel, Matrox Graphics, Nvidia, Sun und Silicon Graphics daruber hin-aus Adobe, Discreet, NEC, Quantum 3D, S3 Graphics und id Software,die sich um die Entwicklung von OpenGL kummern, ist es sehr wahr-scheinlich, dass OpenGL auch in Zukunft eine prioritare Stelle nebenDirectX einnehmen wird.

19

3.2 DirectX Projekt Graphik

3.2 DirectX

3.2.1 Geschichte

Als Windows 3.0 im Jahr 1990 eingefuhrt wurde, begann der Sieges-zug der grafischen Bedienoberflachen. Schnell erkannten Entwicklerdie Vorteile dieser Entwicklung und programmierten fast alle Anwen-dungen unter Windows. Lediglich Spiele wurden nach wie vor fur DOSprogrammiert. Windows hatte bis zu diesem Zeitpunkt nicht die Funk-tionen um die Performance die von den Entwicklern benotigt wurdebereitzustellen. Desweiteren fehlten Moglichkeiten aufwandige Grafik-und Soundeffekte darzustellen.

Um Spieleprogrammierer dazu zu bewegen ihre Spiele fur Windows zuentwickeln begann Microsoft die Multimediafunktionen in Windows,speziell die der Grafik- und Soundausgabe zu verbessern. Microsoftmusste auch eine Plattform schaffen um evtl. Hardwareprobleme ausdem Weg zu raumen wie z.B. Probleme mit der Grafik- oder Sound-karte oder dem Joystick.

So entstand WinG, welches eine Ansammlung von Funktionen bot undperformanter war als die herkommliche Windows GDI. Leider fandauch dies wenig Beachtung, sodass mit Windows 95 das Game SDKsein Debut feierte. Spater wurde das Game SDK in DirectX SDK 1.0umbenannt. DirectX war geboren !

Bis zu DirectX 3 gab es keine 3D-Unterstutzung, welche aber Micro-soft bald darauf von der Firma Render Morphics erwarb, weiterent-wickelte um sie dann schlußendlich in eine neue Komponente namensDirect3D zu implementieren.

3.2.2 Was ist DirectX ?

Unter DirectX versteht man eine Ansammlung von Komponenten undTechnologien, die Entwicklern die Erstellung von Multimedia-Applikationenund Spielen unter Windows erleichtert. Weiterhin bietet DirectX eineeinheitliche, gerateunabhangige Schnittstelle, um den Zugriff aufHardware wie Grafikkarte, Soundkarte und Eingabegerate und derenFunktionalitat zu erhalten. Entwickelt wurde es von Microsoft unterdem Gesichtspunkt, dass Entwickler sicher sein konnen, dass ihr An-wendungen auf jedem Windows-PC ohne Anderungen und ohneBerucksichtigung auf verschiedene Hardwarekonfigurationen lauffahigist.

20


3.2.3 Leistungsfahigkeit

DirectX besteht im Wesentlichen aus zwei Schichten:

– HAL (Hardware Abstraction Layer)HAL bietet Funktionen an, die direkt von der Hardware unter-stutzt werden.

– HEL (Hardware Emulation Layer)HEL bietet Funktionen an, die keine Unterstutzung der Hardwarebieten und somit kann HEL diese bis zu einem gewissen Grademulieren, indem die Funktionen dann z.B. vom GDI (GraphicalDevice Interface) ausgefuhrt werden.

Wenn nun ein DirectX-Objekt fur ein bestimmtes Gerat erzeugt wird,z.B. fur die Grafikkarte, dann werden zunachst die Fahigkeiten abge-fragt und gespeichert. Wenn dann bestimmte Funktionen durch dieGrafikkarte ausgefuhrt werden sollen, pruft DirectX, ob diese Funktio-nen von der Hardware (HAL) abgedeckt werden konnen oder ob dieFunktionen durch HEL emuliert werden mussen. Jedoch ist zu bemer-ken, dass Funktionen die von der HAL ausgefuhrt werden wesentlichschneller sind als die der HEL, die nur softwareseitig arbeitet. Leiderkann aber auch HEL nicht alle Funktionen emulieren, sodass es einigeFunktionen in HEL einfach nicht gibt.

DirectX besteht aus vielen Komponenten, von denen jede eine be-stimmte Aufgabe ubernimmt. Die Folgende Auflistung enthalt einekurze Beschreibung der einzelnen Komponenten:

– DirectDrawDirectDraw war die erste DirectX-Komponente. Sie erlaubt dendirekten Zugriff auf Grafikkarte und Bildspeicher. Die großte Star-ke von DirectDraw ist es jedoch, Speicherbereiche schnell zwi-schen Haupt- und Grafikkartenspeicher schieben zu konnen.

– Direct3DDirect3D ist die großte und auch komplexeste Komponente vonDirectX. Sie besteht aus einer Sammlung von Funktionen, mitdenen Geometrietransformationen (Bewegung, Skalierung, Rotie-rung) sowie Beleuchtung und Texturierung ausgefuhrt werdenkonnen.

Mit DirectX 8 wurden DirectDraw und Direct3D zu einer Komponentezusammengefasst. DirectX Graphics.

Zu DirectX gehoren aber ausser Grafikkomponenten auch noch folgen-de Komponenten, auf die ich aber aufgrund des Grafikprojektes nichtweiter eingehen werde.

21


– Direct3DX Utility LibraryDirect3DX Bibliothek, bietet Funktionen, die das Arbeiten mitDirect3D erleichtern.

– DirectSoundMit dieser Komponente provitiert man von den Hardwarebeschleu-nigern beim Mixen von Soundeffekten

– DirectMusicIm Gegensatz zu DirectSound kann man hier auch komplette Mu-sikstucke abspielen und komponieren

– DirectInputIst fur alle Eingaben zustandig die von Eingabegeraten kommenwie Maus, Joystick...

– DirectPlayUnterstutzung von Netzwerkverbindungen

– DirectShowMit DirectShow kann man z.B. Multimediadateien abspielen wieVideos oder Sounddateien

Grundsatzliche Vorgehensweise zum Erstellen eines DirectX-Programms

Bevor man ein DirectX-Programm beginnen kann, benotigtman ein Fenster. Dieses kann man mit MFC oder WinAPIerzeugen. Dem Linker sollten ausserdem die Include-Dateien alsauch die Library-Dateien bekannt gemacht werden, was das DirectXSDK im Normalfall selbst erledigt. Sollte es jedoch nicht automatischpassieren, sollte man es von Hand selbst machen.

Schritt 1: Direct3D einbinden

Um Direct3D nutzen zu konnen muss man zuerst den Header d3d9.hund die Library d3d9.lib einbinden.

Schritt 2: Direct3D Variablen deklarieren

Fur die ganze Sache sind erstmal zwei Zeiger vom großeren Interesse.Einmal das HauptObjekt von Direct3D. Es ist dafur verantwortlich,dass die richtigen Header eingebunden sind, fur die Version, die wirnutzen und es erstellt den Device. Das ist der zweiter Zeiger. Er hatZugriff zur Hardware kann somit Regisseur in unserer kleinen 3D-Weltspielen.

Schritt 3: Direct3D einrichten

Mit D3D SDK VERSION, stellt man sicher, dass auch die richti-gen Header-Dateien von Direct3D genutzt werden. Es muss aber einegleichgroße oder großere Version von DirectX installiert sein, weil sonstdie Schnittstelle in der DirectX-DLL nicht vorhanden ist, deshalb pruftdieser Aufruf ob dieses der Fall ist. Wenn nicht schlagt sie fehl und esbricht ab.

22


Es ist fur eine Direct3D-Anwendung im Desktopmodus notwendig, die-selben Einstellungen fur unser Programm zu nutzen, wie der Desktop.Es ist zum Beispiel nicht moglich eine Anwendung mit 32-Bit Farbtiefeauf 16-Bit Farbtiefe des Desktops laufen zu lassen. Mit der FunktionGetAdapterDisplayMode() kann man sich die Einstellungen desGrafikAdapters holen, denn bevor man in Windows eine Anwendungstartet, befindet man sich im Desktopmodus, demzufolge ist die Gra-fikadaptereinstellung gleich der Desktopeinstellung.

Als nachstes legt man die beiden Einstellungen der BackBuffer undFrontBuffer fest. Der FrontBuffer ist das Bild, was man sieht und da-mit immer das aktuelle Bild, der Backbuffer ist nicht sichtbar und er istdas nachfolgende Bild. Das Bild wird im BackBuffer zusammengeschu-stert und ersetzt dann das Bild im FrontBuffer. Der Vorteil an dieserTechnik ist das storendes Flimmern wegfallt und man ( glucklicher-weise ) nicht sieht wie das Bild in seinen Bestandteilen nacheinanderaufgebaut wird, sondern es gleich vollstandig auf einen Schlag erhalt.Entscheidend fur die Art des Kopiervorgangs zwischen Backbuffer undFrontbuffer, ist der SwapEffect, also wie die Buffer kopiert werden sol-len. Hierfur benutzt man die Funktion D3DSWAPEFFECT DISCARD.Es ist zu empfehlen diesen Flag weiterhin zu verwenden, denn er istder einzige Modus der FullScene-Antialising unterstutzt und ist vonder Methode her am schnellsten und saubersten.

Als nachstes muss man die Initialisierung vornehmen, und zwar dieEinrichtung des Device, der Schnittstelle zwischen uns und der Hard-ware, der Instanz, der die Grafikkarte beherrscht. Hierfur wird der FlagD3DDEVTYPE HAL benotigt. Er steht dafur, das man hierfur dieHAL benutzt. Mit HAL ist es moglich, die Hardwarebeschleunigungals auch Transform & Lighting zu nutzen. Um TL zu nutzen, setztman den FlagD3DCREATE HARDWARE VERTEXPROCESSING

Als letztes mussen die Objekte von Direct3D aus dem Arbeitsspeicherwieder entfernt werden.

Grundlegende Funktionen

– LPDIRECT3D9Erstellung eines Direct3D Objekts

– LPDIRECT3DDEVICE9Rendering-Schnittstelle definieren

– D3DPRESENT PARAMETERSUm die Rendering-Schnittstelle zu erstellen, muss diese Funktionmit Parametern gefullt werden

– UINT AdapterGibt an, welche Grafikkarte benutzt wird

– D3DDEVTYPE HALBenutzen der Hardwarebeschleunigung

23


– D3DDEVTYPE REFBenutzen des Referenz Software-Rasterizer

– DrawPrimitiveDiese Funktion zeichnet das uber Vertices angegebene geometri-sche Objekt

Um die Funktion DrawPrimitive korrekt anzuwenden sollte man wis-sen, dass Direct3D Vektordaten in einem Vertex Buffer speichert unddann zum Rendern fur primitive Formen verwendet. Man hat die Aus-wahl von 6 verschiedenen Primitivarten:

– PunktlistenJeder Punkt wird einzeln ausgegeben

– LinienlistenJe zwei Punkte werden durch eine Linie verbunden

– Linienstreifenalle Punkte werden der Reihe nach durch eine Linie verbunden

– DreieckslistenJe drei Punkte werden zusammen als Dreieck dargestellt

– Dreiecksstreifenalle Punkte werden der Reihe nach als breiter Streifen aus Drei-ecken dargestellt

– Dreiecksfacheralle Punkte spannen mit dem ersten einen Facher aus Dreieckenauf

Abbildung 2: Eine Primitive mit 3 Vertices

Da einzelnen Vektoren auch Farb-oder Texturwerte zugewiesen werdenkonnen, werden bei den Primitiven die dazwischen liegenden Werteinterpoliert.

24


Folgender Quellcode-Ausschnitt wurde z.B. ein Dreieck zeichnen

D3DVERTEX g pvTriangleVertices[3];

D3DVEKTOR p1{0.0f,3.0f,0.0f};D3DVEKTOR p2{3.0f,-3.0f,0.0f};D3DVEKTOR p3{-3.0f,-3.0f,0.0f};

g pvTriangleVertices[0]=D3DVERTEX(p1, vNormal,0,0);g pvTriangleVertices[1]=D3DVERTEX(p2, vNormal,0,0);g pvTriangleVertices[2]=D3DVERTEX(p3, vNormal,0,0);

pd3dDevice->DrawPrimitive(D3DPT TRIANGLELIST,D3DFVF VERTEX,g pvTriangleVertices,3,NULL);

Die Eckpunkte des Dreiecks sind mit D3DVEKTOR gegeben.

Das Flexible Vertex Format (FVF)

Uber das FVF hat man die Moglichkeit, eine eigene Datenstrukturfur Vertices auszudenken und dieses dann Direct3D mitzuteilen. Manmuss angeben, welche Information man einem Vertex bereitstellen willund wie man diese dann verarbeiten mochte. Programmtechnisch istdas FVF ein DWORD, das sich aus der OR-Verknupfung von Flagsergibt.

Denkbar waren u.a. folgende Flags:

– D3DFVF DIFFUSEDas Vertex beinhaltet einen diffusen Farbwert, welcher in denKoordinaten angegeben werden muss

– D3DFVF XYZVertex Koordinate ist noch untransformiert

– D3DFVF NORMALEs wird ein Normalvektor verwendet

Direct3D stellt eine Vielzahl von Funktionen bereit mit denen manu.a. Licht-und Texturen darstellen kann. Hier eine Auflistung der

Texturorientierten Funktionen

– LPDIRECT3DTEXTURE9Texturschnittstelle definieren

– D3DXCreateTextureFromFileLadt Textur aus einer angegebenen Datei

25


– D3DXCreateTextureFromFileExAhnlich wie ...FromFile aber mochte man Techniken wie Mip-Mapping, Color-Keying oder ahnliches anwenden benotigt mandiese Funktion

In Zusammenhang mit den oben genannten Funktionen stehen u.a.auch noch folgende Paramter zur Auswahl die man definieren kann.

– FilterGibt an, wie die Pixel der Bilddatei gefiltert werden sollen. Be-sonders interessant wenn die Textur skaliert werden soll

– Mip-LevelsGibt an wieviel Mip-Map Levels generiert werden sollen

– MipFilterGibt an, wie die Texturen beim Generieren von Mip-Maps be-handelt werden sollen

Wenn man in Direct3D Licht verwenden mochte, muss die Vektor-struktur um Oberflachennormalen erweitert werden, um die Lichtstar-ke uber dem Einfallswinkel bestimmen zu konnen.

struct Customvertex

{D3DXVECTOR position;

D3DXVECTOR normal;

};

Danach kann das Licht erstellt werden und einige Werte konnen fest-gelegt werden wie die Farbe, die Art und evlt. Position und Richtung.

D3DLIGHT9 light

light.type = D3DLIGHT DIRECTIONAL;

light.Diffuse.r=1.0f;

light.Diffuse.g=1.0f;

light.Diffuse.b=1.0f;

light.Direction=D3DXVECTOR3 (1.0f,1.0f,1.0f);

light.Range=1000.0f;

Jetzt kann das Licht an das Gerat ubergeben und aktiviert werden.Materialien haben Einfluss darauf, wie Licht von der Oberflache desObjekts reflektiert werden und somit beinflussen sie auch die Texturen.

26


Die Rendering-Pipeline

Direct3D bedient sich dem Pipelining-Prinzip zur Verarbeitung derGeometriedaten. Die Rohdaten gelangen sozusagen in die erste Stu-fe, in der sie bearbeitet und anschließend an die nachsthohere Stu-fe weitergegeben werden. Nachdem die Geometriedaten die Direct3D-Pipeline vollstandig durchlaufen haben, erhalten Sie eine fertig ge-renderte Szene. Abbildung 11 zeigt eine schematische Darstellung derPipeline.

Abbildung 3: Die Direct3D-Rendering-Pipeline

Tesselation

Zwar nimmt die Leistungsfahigkeit der Computer stetig zu, dennochsind im 3D-Bereich viele Grenzen gesetzt. Rundungen werden durcheine Vielzahl von Dreiecken realisiert. Desto mehr Dreiecke verwendetwerden, desto ansehnlicher sind die Ergebnisse. Zum einen erhoht sichder Zeitaufwand zum Rendern der vielen Dreiecke und zum anderen- was viel entscheidender ist - mussen Sie mehr Daten uber den Busschicken. Seit DirectX 8.0 besteht die Moglichkeit, so genannte Cur-ved Surfaces bzw. High Order Surfaces darzustellen, indem ein Dreieckwahrend der Laufzeit unterteilt wird. Moderne Grafikkarten fuhrendiesen Prozess, der im Fachjargon Tesselation genannt wird, im Gra-fikchip durch. Daraus resultiert eine Reduzierung der Bus-Belastung.Naturlich bleibt der erhohte Aufwand zum Rendern der Primitive nichtaus. Nach dem vierten Tag wissen Sie die Tesselation zu nutzen, umden Detailgrad eines 3D-Objekts zu erhohen.

Transformation & Lighting

Direct3D stellt im Rahmen der so genannten Fixed-Function-Pipelinedie Funktionalitaten zur Transformation und zur Beleuchtung der Pri-mitive zur Verfugung. Diverse Methoden und Eigenschaften eroffnendem Programmierer, wie die Vertex-Daten zu verarbeiten sind. DieFixed-Function-Pipeline bietet keine Moglichkeit zur Erweiterung desgegebenen Funktionsumfangs. Als Alternative, nicht etwa als zusatz-liche Option, gelten die Vertex Shader. Shader sind kleine Program-me, die vom Grafikprozessor ausgefuhrt werden (insofern die Hardwa-re Vertex Shader unterstutzt). Wahlt der Programmierer diesen Weg,kann oder besser muss er die Transformationen und die Beleuchtungder Vertices vornehmen. Ein klarer Vorteil zeichnet sich in der hohenFlexibilitat ab. Vertex Shader zahlen zu der Programmable Pipeline.

27


Clipping, Culling und Rasterization

Zwischen einer dreidimensionalen virtuellen Welt und deren Darstel-lung auf dem Monitor besteht ein Konflikt, denn die Koordinaten las-sen sich nicht direkt ubertragen. Wie bereits besprochen, durchlauftdie Geometrie deshalb mehrere Transformationen, bis die Koordinatennach der Projection-Transformation in 2D-Koordinaten vorliegen.

Naturlich ist nicht sichergestellt, dass sich alle in die Pipeline gejagtenPrimitive voll im sichtbaren Bereich befinden. Schließlich ist die Fla-che zum Anzeigen der Szene begrenzt und wird durch den Viewportbeschrieben. Als Viewport gilt in diesem Fall ein Rechteck, welchesdie Große des Sichtbereichs absteckt. Primitive, die sich außerhalb desangegebenen Bereichs befinden, werden geclippt. Direct3D unterstutztaußerdem von Haus aus das Back Face Culling. Jene Option sorgt imaktiven Zustand dafur, dass wahlweise die Primitive mit im oder gegenden Uhrzeigersinn angeordneten Vertices entfernt werden. Dadurch sollDirect3D verhindern, dass vom Betrachter abgewandte Primitive aufdem Monitor erscheinen. Wenn die Sichtbarkeit der Dreiecksrucksei-ten erwunschst ist, muss lediglich das Back Face Culling deaktiviertwerden.

Nun konnen die Daten im Rasterisations-Prozess (engl. rasterization)in entsprechende Farbwerte ubertragen werden, sprich Direct3D be-rechnet die Pixel an den jeweiligen Flachen und speichert die Wertein einem so genannten Surface. Ein Surface ist lediglich ein sequenziellaufgebauter Speicherbereich, vergleichbar mit einem Bitmap.

Multitexturing-Einheit vs. Pixel Shader

Die Einheit zur Transformation und Beleuchtung der Vertices ist nurein Bestandteil der Fixed-Function-Pipeline gewesen. Jene Einheit zumHinzufugen von Texturen bildet den zweiten Bestandteil. Analog zurgesamten Architektur von Direct3D ist die Multitexturing-Einheit auf-gebaut, d.h. sie besitzt ebenfalls mehrere Bearbeitungsstufen. MehrereBearbeitungsstufen sind deshalb von Belang, damit der Programmie-rer die Moglichkeit zur Kombination unterschiedlicher Texturen erhalt.Wie Sie spater kennen lernen werden, sind solche Bitmaps selbst zurBeleuchtung anderer Texturen zu gebrauchen.

Das Pendant zur Multitexturing-Einheit stellt der Pixel Shader dar.Wie beim Vertex Shader obliegt es dem Programmierer, die Funktio-nalitaten der Fixed-Function-Pipeline zu implementieren (insofern dieserwunscht bzw. erfordert ist). Vorteile sind wieder in der Flexibilitaterkennbar. So ermoglichen Pixel-Shader die dynamische Beleuchtungwahrend des Texturierungs-Prozess.

28


Tiefen- und Alpha-Test

Bevor der aktuelle Pixel auf das Ziel-Surface ubertragen wird, mussdieser sich dem Tiefen- und dem Alpha-Test unterziehen. Letztererbewirkt den Verfall solcher Pixel, deren Farbwert in den als transpa-rent definierten Farbbereich fallt. Der Tiefentest verhindert, dass jenePixel in das Surface geschrieben werden, die eigentlich durch andereverdeckt werden. Wir nehmen uns des Tiefenproblems spater an unddemonstrieren den Unterschied zwischen aktiviertem und deaktivier-tem Tiefentest.

Fog Blending

In Abhangigkeit von der Distanz zwischen einem Objekt und der Po-sition der Kamera oder allein durch die Stelle des Objekts auf derZ-Achse werden dessen Pixel zu guter Letzt mit dem Farbwert des Ne-bels kombiniert. Korper außerhalb eines definierten Bereichs sind beiaktiviertem Fog Blending ganzlich unsichtbar und werden vom Nebeluberdeckt. In diesem Fall wird der Farbwert des Nebels in das Surfacegeschrieben.

3.2.4 Entwicklung

Windows Graphics Foundation (WGF) - Der DirectX9 Nachfolger

WGF - Einfuhrung

WGF wird der Nachfolger von Microsoft’s aktueller Grafik API Direc-tX9. Aus gutem Grund entschied Microsoft das neue Grafik API nichtDirectX10 zu nennen, sondern Windows Graphics Foundation (WGF),was auf tiefgreifende Anderungen im bisherigen Konzept von DirectXschliessen lasst. WGF wurde von Grund auf neu durchdacht mit denZielen einer optimalen Betriebssystem-Integration und einer ausrei-chenden Flexibilitat fur zukunftige 3D-Applikationen mit der entspre-chenden Stabilitat und Leistung. Microsoft mochte hier einen Grund-stein fur ein Next-Generation-API legen, was sowohl Performance tech-nisch als auch in Sachen Flexibilitat einiges verspricht. WGF ist daserste API unter Windows, das Direct3D (3D-Graphik) mit DirectDraw(2D-Graphik) vereint, die beide bislang uber getrennte Schnittstellenanzusteuern waren. Mit der Vereinigung dieser beiden Schnittstellenwill Microsoft eine klar definierte Grafikkomponente schaffen und ver-einfacht somit auch das Entwickeln und Warten von 3D-Applikationenund Grafik-Treibern sowie die Behandlung grafikhardware-basierterFehler im Betriebssystem. Fur die Desktop-Prasentation halt sich Mi-crosoft offen, zudem die 2D-Schnittstelle um einige noch nicht genannteBesonderheiten und Effekte zu erweitern.

29


Die neue WGF Grafik-Pipeline

Eines der wichtigsten Neuerungen in WGF ist die Grafik-Pipeline, dieim wesentlichen durch den Common Shader Core ansprechbar ist.Das Prinzip des Common Shader Core ist es Vertex- und Pixel-Shader zu vereinen, um Flexibilitat in der Programmierung der Pi-peline zu erlauben. Als Beispiel sind hier gridbasierte physikalischeSimulationen zu nennen, die Geschwindigkeitswerte im Pixel-Shadererzeugen, und gleich dem Vertex-Shader als Input dienen, d.h. Pixel-buffer, die als Vertexbuffer genutzt werden und erneut den Weg durchdie Pipeline machen. In Sachen Flexibilitat wartet WGF zusatzlich miteinem neuen Feature auf, namlich den sogenannten Geometry- oderPrimitive-Shadern, die in der Lage sind innerhalb der Grafik-PipelinePrimitive, wie Lines, Triangles, Quads, etc zu generieren, womit Al-gorithmen die ohnehin auf einer Generierung von zusatzlicher Geome-try angewiesen waren, wesentlich effizienter ablaufen konnen. Bisherwar es nicht moglich zusatzliche Geometry-Daten innerhalb der Pi-peline zu erzeugen, d.h. es konnte nur ein Vertex die Vertex-Pipelineverlassen, wenn ein Vertex hinunter gesendet wurde. Mit Sicherheitwird es hierfur weitreichende neue Anwendung geben, die Primitive-Shader nutzen werden. Aktuelle Algorithmen, die sich hierfur eignen,waren beispielsweise GPU Shadow und Light Volumes, Triangulie-rung parametrischer Flachen, Billboard-Rendering oder dynamisch er-zeugte Geometrie-Stucke von explodierenden Fassern oder ahnlichem.WGF wird das Shader Model 4.0 unterstutzen, und Technologien wie,Normal-Map Komprimierung, verbessertes Zustandsmanagement oderHigh Dynamic Range Rendering Formate integrieren. Vertex-Lighting,Fog, Alpha-Test, Triangle-Fans und Point-Sprites werden als Altla-sten aus der Fixed-Function Pipeline herausgenommen, wobei dieseFunktionalitat stattdessen uber programmierbare Shader unterstutztwird. Dies unterstutzt den Trend, dass Grafikhardware immer mehrauf programmierbare Shader Pipelines optimiert wird, und die Fixed-Function Pipeline langsam ihren Ruckzug bestreitet.

WGF und Longhorn WGF soll hervorragend in Longhorn integriertsein. So wird beispielsweise mittels der Longhorn Avalon Technologiedas komplette Desktop-Rendering in Longhorn mittels 3D-HardwareBeschleunigung durchgefuhrt. Longhorn Avalon ist der Codename furdas neue Grafik Subsystem, welches das Entwickeln von Grafikapplika-tionen erleichtern soll. Im Gegensatz zu herkommlichen Grafik-Konzeptenist Avalon vektorbasiert, und nicht auf Pixelbasis. Unterstutzt wirddies zusatzlich durch das neue Programmiermodell XAML, das vorallem fur den Entwurf von User-Interfaces geschaffen wurde. DassWGF tief im Betriebsystem verankert ist, zeigt auch das Managementvon WGF-Applikationen, welches in der Lage sein wird mehrere 3D-Applikationen nach Batches und Kontexten zu sortieren, um ein opti-males Scheduling zu garantieren. Hier soll auch ein sogenanntes Pre-emptive Context Scheduling zum Einsatz kommen, welches auf

30


der Idee des bekannten preemptiven Multitaskings basiert. Ein weite-res wichtiges Feature ist die Virtualisierung von GPU-Speicher. D.h. inWGF gibt es intern prinzipiell nur virtuellen GPU-Speicher, von demsowohl Teile auf der Grafikkarte als auch Teile im System-Speicher re-sidieren konnen, jedoch als zusammenhangender Block adressiert wer-den. Die Speicherverwaltung konzentriert sich im Wesentlichen auf dasLaden in Form von Preloading und On-Demand-Loading von Grafik-Speicherblocken, wofur entsprechende Caching-Mechanismen bereit-stehen sollen. In diesem Zusammenhang spielt auch das kommendeLonghorn Display Driver Model (LDDM) eine große Rolle, dessenHauptziel es ist, Absturze, die vom Grafik-Treiber ausgelost werden,vollstandig abzufangen und moglichen resultierenden Datenverlust zuvermeiden.

WGF - Release Termin? Eine genauer Release Termin ist wohl nochnicht in Sicht. Fur Hardwarehersteller ist jedoch bereits die WGF-Spezifikation in der Version 0.99 erhaltlich, wobei im Moment an derWGF-Spezifikation 1.0 gearbeitet wird. Somit sind die Hersteller in derLage rechtzeitig ihre Grafikkarten auf die neue WGF-Architektur undderen Moglichkeiten anzupassen und erste Tests zu fahren. WGF wirdvoraussichtlich im nachsten Jahr (2006) fur Entwickler benutzbar sein,jedoch spatestens mit dem Erscheinen des Longhorn-Betriebssystemsim selben Jahr, und dann auch fest im Longhorn Betriebssystem inte-griert.

31

4. Unterschiede DirectX und OpenGL Projekt Graphik

4 Unterschiede DirectX und OpenGL

Grundlegende Unterschiede von DirectX und OpenGL

OpenGL

– Nutzt die Hardware optimal aus, durch spez. Anpassungen

– Lauft auf unterschiedlichen Plattformen

– Lauft nicht sofort auf den meisten 3D-Chips mit fast allen 3DFeatures, ohne spez. Anpassungen

– Lauft auf verteilten Systemen mit Client-Server-Architektur

– Open Source Referenzimplementierung

– Meist bessere Treiber fur professionelle Grafikhardware

DirectX

– nutzt die Hardware nicht optimal aus, durch spez. Anpassungen,da an DirectX Funktionsset gebunden

– Lauft nicht auf unterschiedlichen Plattformen, nur auf Windows

– lauft sofort auf den meisten 3D-Chips mit fast allen 3D Features,ohne spez. Anpassungen

– lauft nicht auf verteilten Systemen

– programmiersprachenunabhangig (unmanaged DirectX, COM)

– arbeitet mit World und View-Matrix, Objekt daher unabhangigvom Betrachter verschiebbar durch Anderung der World-Matrix

– nicht notig, eigene Routinen zum Laden von Texturen zu schrei-ben

– Alpha-Operationen beim Blending unabhangig definieren von denColor-Operationen

– zusatzliches Ambient-Lighting

– DirectX bzw. D3DX-Bibliothek bietet die Moglichkeit, Mesh-Dateienzu laden und darzustellen

32

4. Unterschiede DirectX und OpenGL Projekt Graphik

Feature OpenGL 1.2 Core Direct3D 8

System Mechanik

OS Support Windows,MacOS,BeOS,others WindowsAPI Definition Control OpenGL ARB Microsoft

API Specification OGL Specification SDK DocumentationAPI Mechanism includes und libraries COM

Software Emulation Ja NeinExtension Mechanism Ja JaSource Implementation Ja Nein

FixedFunction Vertex Blending Nein JaProgramm. Vertex Blending Nein JaParametric Curves Primitives Ja JaParametric Surface Primitives Ja Ja

Hierarchical Display Lists Ja Nein

Rendering

2-Seiten Belichtung Ja NeinPoint Size Rendering Attribute Ja JaLine Width Rendering Attribute Ja Nein

Programmable Pixel Shading Nein JaTriadic Texture Blending Nein Ja

Cube Environment Mapping Nein JaVolume Textures Ja Ja

Multitexture Cascade Nein JaTexture Temp. Result Register Nein Ja

Mirror Texture Addressing Nein JaTexture Wrapping Nein JaRange-Based Fog Nein JaBump Mapping Nein Ja

Modulate 2X Texture Blend Nein JaModulate 4X Texture Blend Nein JaAdd Signed Texture Blend Nein Ja

Frame Buffer

HW Independent Z Buffer Access Ja NeinFull-Screen Antialiasing Ja Ja

Motion Blur Ja JaAccumulation Buffers Ja Nein

33

5. Projekt-Fazit Projekt Graphik

5 Projekt-Fazit

Ob man sich nun fur DirectX oder fur OpenGL entscheidet, jedesSystem hat seine Vor- und Nachteile. Fur Anfanger ist jedoch unse-rer Meinung nach OpenGL wesentlich einfacher zum Einstieg geeignetals DirectX, da es viele Funktionen vereinfacht. Was die Performanceangeht, sticht keines der beiden heraus. Es kommt jedoch auf den Her-steller des Anwendungsprogramms an, wie weit er seinen Code auf dasjeweilige System optimiert. So konnte es durchaus sein, dass einmalDirectX, ein anderes Mal OpenGL die Nase vorn hat.

Die Vorteile von OpenGL liegen vor allem in der Plattforumunabhan-gigkeit und der Open-Source-Referenzimplementierung. Jedoch dauertein neuer Standard sehr lange und man konnte in ein Extension Chaosgeraten.

Bei DirectX ist der Vorteil, dass sehr schnelle Standards verfugbar sindund dieser dann meist weiter ist als die Hardware-Entwicklung. Dergroßte Nachteil wird wohl in der plattformabhangigkeit liegen und denoft starken Veranderungen bei neuen Versionen.

Gruppeninternes Fazit

Mit diesem Projekt lernten wir vor allem eines: Einarbeiten!

Kein anderes Projekt verlangte in so kurzer Zeit soviel Materie zu ver-stehen. Aber im Gegensatz dazu machte es uns eine Menge Spaß, vorallem als gegen Ende unser Programmierbeispiel endlich funktionier-te. Es kam zwischendurch beim DirectX Beispiel zu Komplikationen,welche aber nach einigen Stunden intensiven Recherchierens bewaltigtwurden.

Auch das Erstellen von Windows Fenstern dauerte eine Zeit, wurdeaber dank Internet Tutorials und Buchern auch gemeistert. So habenwir nun auch einen Einblick in WinAPI bekommen.

In der Gesamtbetrachtung haben wir bei diesem Projekt bis jetzt vonallen Projekten am meisten gelernt und wir sind froh es genommenzu haben, denn so haben wir nun einen kleinen Einblick sowohl inOpenGL als auch in DirectX erhalten und wollen nun darauf aufbauen.

Zeitlich schafften wir alles in geplanter Zeit, unserer selbst gesetzenDeadline, sodass wir noch genug Zeiten hatten fur den Fall das wasschief laufen wurde oder wir noch etwas andern wollten.

34

6. Literaturverzeichnis Projekt Graphik

6 Literaturverzeichnis

Jetzt lerne ich DirectX und Visual C++Christian Rousselle, Markt & Technik

DirectX GE-PACKTJoachim Rohde, mitp Verlag

Unterschiede zwischen DirectX 7 und DirectX 8http://www.hardtecs4u.com/reviews/2001/directx7 vs 8

Erklarungen uber Grafik-Engineshttp://www.computerbase.de/lexikon/Grafik-Engine

Infos aus 1.Hand von Microsoft besonderer Dank an Gesa Ehmsen(CommunityManagement) und Dirk Primbs(DirectX Technologieberater)http://www.msdn.microsoft.com/directx

ComputerspielePeter Dobrovka, mitp Verlag

OpenGL Tutorials und Erklarungenhttp://www.lighthouse3d.com

OpenGL Informationen und Tutorialshttp://www.open-gl.de

OpenGL Hauptseitehttp://www.opengl.org

Viele Informationen uber OpenGLhttp://nehe.gamedev.net

GLUT 3.0 Specification

The OpenGL Bluebook

The OpenGL Redbook

35

7. Anhang Projekt Graphik

7 Anhang

7.1 Open GL Funktionsliste

OpenGl-Funktionen im Uberblick

GLX commands

glXCopyContext glXChooseVisual glXCreateGLXPixmap glXCreateContextglXDestroyGLXPixmap glXDestroyContext glXGetCurrentContextglXGetConfig glXIntro glXGetCurrentDrawable glXMakeCurrentglXIsDirect glXQueryVersion glXQueryExtension glXUseXFontglXSwapBuffers glXWaitX glXWaitGL

GL commands

glAlphaFunc glAccum glBitmap glBegin glCallList glBlendFuncglClear glCallLists glClearColor glClearAccum glClearIndexglClearDepth glClipPlane glClearStencil glColorMask glColorglCopyPixels glColorMaterial glDeleteLists glCullFace glDepthMaskglDepthFunc glDisable glDepthRange glDrawPixels glDrawBufferglEnable glEdgeFlag glEndList glEnd glEvalMesh glEvalCoordglFeedbackBuffer glEvalPoint glFlush glFinish glFrontFace glFogglGenLists glFrustum glGetClipPlane glGet glGetLight glGetErrorglGetMaterial glGetMap glGetPolygonStipple glGetPixelMapglGetTexEnv glGetString glGetTexImage glGetTexGenglGetTexParameter glGetTexLevelParameter glIndex glHintglInitNames glIndexMask glIsList glIsEnabled glLightModel glLightglLineWidth glLineStipple glLoadIdentity glListBase glLoadNameglLoadMatrix glMap1 glLogicOp glMapGrid glMap2 glMatrixModeglMaterial glNewList glMultMatrix glOrtho glNormal glPixelMapglPassThrough glPixelTransfer glPixelStore glPointSize glPixelZoomglPolygonStipple glPolygonMode glPopMatrix glPopAttribglPushAttrib glPopName glPushName glPushMatrix glReadBufferglRasterPos glRect glReadPixels glRotate glRenderMode glScissorglScale glShadeModel glSelectBuffer glStencilMask glStencilFuncglTexCoord glStencilOp glTexGen glTexEnv glTexImage2D glTexImage1DglTranslate glTexParameter glViewport glVertex

36

7.1 Open GL Funktionsliste Projekt Graphik

GLU commands

gluBeginPolygon gluBeginCurve gluBeginTrim gluBeginSurfacegluBuild2Dmipmaps gluBuild1DMipmaps gluDeleteNurbsRenderergluCylinder gluDeleteTess gluDeleteQuadric gluEndCurve gluDiskgluEndSurface gluEndPolygon gluErrorString gluEndTrimgluLoadSamplingMatrices gluGetNurbsProperty gluNewNurbsRenderergluLookAt gluNewTess gluNewQuadric gluNurbsCallback gluNextContourgluNurbsProperty gluNurbsCurve gluOrtho2D gluNurbsSurfacegluPerspective gluPartialDisk gluProject gluPickMatrixgluQuadricCallback gluPwlCurve gluQuadricNormalsgluQuadricDrawStyle gluQuadricTexture gluQuadricOrientationgluSphere gluScaleImage gluTessVertex gluTessCallback gluUnProject

37

7.2 Realisierung eines Wurfels unter OpenGL Projekt Graphik

7.2 Realisierung eines Wurfels unter OpenGL

#include <stdlib.h> #include <windows.h> #include <stdio.h>

// Header File fur Standard Input/Output #include <gl\gl.h>

// Header File fur die OpenGL32 Library #include <gl\glu.h>

// Header File fur die GLu32 Library #include <gl\glaux.h>

// Header File fur die Glaux Library

HDC hDC=NULL; // Private GDI Device Context HGLRC

hRC=NULL; // Permanent Rendering Context HWND

hWnd=NULL; // Window Handle HINSTANCE hInstance; //

Instanz der Applikation

bool keys[256]; // Key-Array bool active = TRUE;

// Window Active Flag Set To TRUE By Default bool fullscreen =

TRUE; // fullscreen flag bool light; // light

flag bool lp; // L gedruclt? bool fp;

// F gedruckt? bool zp; // Z gedruckt? bool

zbuffer = FALSE; // Z - Buffer

GLfloat xrot; // X Rotation GLfloat yrot;

// Y Rotation GLfloat xspeed; // X Rotation Speed

GLfloat yspeed; // Y Rotation Speed GLfloat z=-5.0f;

// Anzeige nach hinten legen

GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f }; GLfloat

LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f }; GLfloat

LightPosition[]= { 0.0f, 0.0f, 2.0f, 1.0f };

GLuint filter; // aktuell benutzter Filter GLuint

texture[3]; // Speicher fur 3 Texturen

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); //

Declaration For WndProc

//////////////////////////////////////////////////////////////////////////////////////

// //

// BMP aus Datei laden ... //

// //

//////////////////////////////////////////////////////////////////////////////////////

AUX_RGBImageRec *LoadBMP(char *Filename) // Ladt

ein Bitmap {

FILE *File=NULL; // Zeiger auf File

if (!Filename) // Falls Datei nicht existiert

{

return NULL;

}

File = fopen(Filename,"r");

if (File) // Falls Datei existiert

{

fclose(File); // File Handle schließen

return auxDIBImageLoad(Filename); // Ladt das Bitmap und ubergibt einen Zeiger

}

return NULL; // -> falls Fehler auftrat

}

//////////////////////////////////////////////////////////////////////////////////////

// //

// Konvertiert das geladene Bitmap in eine Textur //

// //

//////////////////////////////////////////////////////////////////////////////////////

int LoadGLTextures() {

int Status=FALSE;

AUX_RGBImageRec *TextureImage[1]; // Speicherplatz fur Textur reservieren

memset(TextureImage,0,sizeof(void *)*1);

if (TextureImage[0]=LoadBMP("Data/kiste.bmp"))

{

Status=TRUE;

glGenTextures(3, &texture[0]); // Erstellt 3 Texturen, die mit "f" durchsprungen werden konnen

// Filter 1: Nearest Filtered Texture

glBindTexture(GL_TEXTURE_2D, texture[0]);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);

38


glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

// Filter 2: Linear Filtered Texture


glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

// Filter 3: MipMapped Texture


glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);

gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

}

if (TextureImage[0])

{

if (TextureImage[0]->data)

{

free(TextureImage[0]->data); // loscht von Textur belegter Speicher

}

free(TextureImage[0]); // loscht Image Struktur

}

return Status; // Erfolg ?

}

//////////////////////////////////////////////////////////////////////////////////////

// //

// Initialisiert und Resized das Fenster //

// //

//////////////////////////////////////////////////////////////////////////////////////

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) {

if (height==0)

{

height=1;

}

glViewport(0,0,width,height); // Reset The Current Viewport

glMatrixMode(GL_PROJECTION); // wahlt die Projektionsmatrix

glLoadIdentity(); // Resetet die Matrix

gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

glMatrixMode(GL_MODELVIEW); // wahlt ModelMatrix

glLoadIdentity();

}

//////////////////////////////////////////////////////////////////////////////////////

// //

// OpenGL SetUp //

// //

//////////////////////////////////////////////////////////////////////////////////////

int InitGL(GLvoid) {

if (!LoadGLTextures()) // Textur - Routine wird gestartet

{

return FALSE;

}

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping

glShadeModel(GL_SMOOTH); // Enable Smooth Shading

glClearColor(0.1f, 0.5f, 0.8f, 0.5f); // Hintergrund- bzw. Loschfarbe

glClearDepth(1.0f); // Depth Buffer Setup

if(!zbuffer) glEnable(GL_DEPTH_TEST); // z - Buffer aktivieren

else glDisable(GL_DEPTH_TEST); // z - Buffer deaktivieren

//glEnable(GL_LINE_SMOOTH);

glEnable(GL_POLYGON_SMOOTH);

//glEnable(GL_CULL_FACE);

glEnable(GL_DITHER);

glEnable(GL_STENCIL_TEST);

glDepthFunc(GL_LEQUAL); // Depth Testing

glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Perspective Berechnungen

glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // Einstellungen fur Ambient Light

glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); // Einstellungen fur Diffuse Light

glLightfv(GL_LIGHT1, GL_POSITION,LightPosition); // Position des Lichts

glEnable(GL_LIGHT1); // Enable Licht1

return TRUE;

}

39


//////////////////////////////////////////////////////////////////////////////////////

// //

// Eigentliche Zeichenoperation //

// //

//////////////////////////////////////////////////////////////////////////////////////

int DrawGLScene(GLvoid) {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Leert Farb- und Tiefenpuffer

glLoadIdentity(); // View zurucksetzten

glTranslatef(0.0f,0.0f,z); // Ausgangspunkt um z nach hinten verschieben

glRotatef(xrot,1.0f,0.0f,0.0f); // Rotation um X-Achse

glRotatef(yrot,0.0f,1.0f,0.0f); // Rotation um Y-Achse

glBindTexture(GL_TEXTURE_2D, texture[filter]);

glBegin(GL_QUADS); // Punkte werden zu Vierecken verbunden

// vorne

glNormal3f( 0.0f, 0.0f, 1.0f); // Normalenvektor der Textur

glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Texturkoordinate und dazugehoriger Vertex

glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);

glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);

glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);

// hinten

glNormal3f( 0.0f, 0.0f,-1.0f);

glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);

glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);

glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);

glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);

// oben

glNormal3f( 0.0f, 1.0f, 0.0f);





// unten

glNormal3f( 0.0f,-1.0f, 0.0f);




glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);

// rechts

glNormal3f( 1.0f, 0.0f, 0.0f);





// links

glNormal3f(-1.0f, 0.0f, 0.0f);


glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);



glEnd();

xrot+=xspeed;

yrot+=yspeed;

return TRUE;

}

//////////////////////////////////////////////////////////////////////////////////////

// //

// Funktion, die aufgerufen wird wenn man das Fenster beendet //

// //

//////////////////////////////////////////////////////////////////////////////////////

GLvoid KillGLWindow(GLvoid) {

if (fullscreen)

{

ChangeDisplaySettings(NULL,0); // Falls im Vollbildmodus - switch zu Desktop

ShowCursor(TRUE); // zeigt Maus Cursor wieder an

}

// Kontexte wieder freigeben:

if (hRC) // Falls Rendering Context vorhanden...

{

if (!wglMakeCurrent(NULL,NULL)) // Falls DC und RC nicht freigegeben werden konnen

{

MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

}

if (!wglDeleteContext(hRC))

{

MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

}

40


hRC=NULL;

}

if (hDC && !ReleaseDC(hWnd,hDC))

{

MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

hDC=NULL;

}

if (hWnd && !DestroyWindow(hWnd))

{

MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

hWnd=NULL;

}

if (!UnregisterClass("OpenGL",hInstance))

{

MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

hInstance=NULL;

}

}

/* This Code Creates Our OpenGL Window. Parameters Are:

*

* title - Title To Appear At The Top Of The Window *

* width - Width Of The GL Window Or Fullscreen Mode *

* height - Height Of The GL Window Or Fullscreen Mode *

* bits - Number Of Bits To Use For Color (8/16/24/32) *

* fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */

BOOL CreateGLWindow(char* title, int width, int height, int bits,

bool fullscreenflag) {

GLuint PixelFormat; // Holds The Results After Searching For A Match

WNDCLASS wc; // Windows Class Structure

DWORD dwExStyle; // Window Extended Style

DWORD dwStyle; // Window Style

RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values

WindowRect.left=(long)0; // Set Left Value To 0

WindowRect.right=(long)width; // Set Right Value To Requested Width

WindowRect.top=(long)0; // Set Top Value To 0

WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height

fullscreen=fullscreenflag; // Set The Global Fullscreen Flag

hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window

wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.

wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages

wc.cbClsExtra = 0; // No Extra Window Data

wc.cbWndExtra = 0; // No Extra Window Data

wc.hInstance = hInstance; // Set The Instance

wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon

wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer

wc.hbrBackground = NULL; // No Background Required For GL

wc.lpszMenuName = NULL; // We Don’t Want A Menu

wc.lpszClassName = "OpenGL"; // Set The Class Name

if (!RegisterClass(&wc)) // Attempt To Register The Window Class

{

MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE; // Return FALSE

}

if (fullscreen) // Attempt Fullscreen Mode?

{

DEVMODE dmScreenSettings; // Device Mode

memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory’s Cleared

dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure

dmScreenSettings.dmPelsWidth = width; // Selected Screen Width

dmScreenSettings.dmPelsHeight = height; // Selected Screen Height

dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel

dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.

if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)

{

// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.

if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)

{

fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE

}

else

{

// Pop Up A Message Box Letting User Know The Program Is Closing.

MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);


}

}

}

if (fullscreen) // Are We Still In Fullscreen Mode?

41


{

dwExStyle=WS_EX_APPWINDOW; // Window Extended Style

dwStyle=WS_POPUP; // Windows Style

ShowCursor(FALSE); // Hide Mouse Pointer

}

else

{

dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style

dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style

}

AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size

// Create The Window

if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window

"OpenGL", // Class Name

title, // Window Title

dwStyle | // Defined Window Style

WS_CLIPSIBLINGS | // Required Window Style

WS_CLIPCHILDREN, // Required Window Style

0, 0, // Window Position

WindowRect.right-WindowRect.left, // Calculate Window Width

WindowRect.bottom-WindowRect.top, // Calculate Window Height

NULL, // No Parent Window

NULL, // No Menu

hInstance, // Instance

NULL))) // Dont Pass Anything To WM_CREATE

{

KillGLWindow(); // Reset The Display

MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be

{

sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor

1, // Version Number

PFD_DRAW_TO_WINDOW | // Format Must Support Window

PFD_SUPPORT_OPENGL | // Format Must Support OpenGL

PFD_DOUBLEBUFFER, // Must Support Double Buffering

PFD_TYPE_RGBA, // Request An RGBA Format

bits, // Select Our Color Depth

0, 0, 0, 0, 0, 0, // Color Bits Ignored

0, // No Alpha Buffer

0, // Shift Bit Ignored

0, // No Accumulation Buffer

0, 0, 0, 0, // Accumulation Bits Ignored

16, // 16Bit Z-Buffer (Depth Buffer)

0, // No Stencil Buffer

0, // No Auxiliary Buffer

PFD_MAIN_PLANE, // Main Drawing Layer

0, // Reserved

0, 0, 0 // Layer Masks Ignored

};

if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?

{


MessageBox(NULL,"Can’t Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?

{


MessageBox(NULL,"Can’t Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?

{


MessageBox(NULL,"Can’t Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?

{


MessageBox(NULL,"Can’t Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context

{


MessageBox(NULL,"Can’t Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

42


ShowWindow(hWnd,SW_SHOW); // Show The Window

SetForegroundWindow(hWnd); // Slightly Higher Priority

SetFocus(hWnd); // Sets Keyboard Focus To The Window

ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen

if (!InitGL()) // Initialize Our Newly Created GL Window

{


MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

return TRUE; // Success

}

LRESULT CALLBACK WndProc( HWND hWnd, // Handle For

This Window

UINT uMsg, // Message For This Window

WPARAM wParam, // Additional Message Information

LPARAM lParam) // Additional Message Information

{

switch (uMsg) // Check For Windows Messages

{

case WM_ACTIVATE: // Watch For Window Activate Message

{

if (!HIWORD(wParam)) // Check Minimization State

{

active=TRUE; // Program Is Active

}

else

{

active=FALSE; // Program Is No Longer Active

}

return 0; // Return To The Message Loop

}

case WM_SYSCOMMAND: // Intercept System Commands

{

switch (wParam) // Check System Calls

{

case SC_SCREENSAVE: // Screensaver Trying To Start?

case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?

return 0; // Prevent From Happening

}

break; // Exit

}

case WM_CLOSE: // Did We Receive A Close Message?

{

PostQuitMessage(0); // Send A Quit Message

return 0; // Jump Back

}

case WM_KEYDOWN: // Is A Key Being Held Down?

{

keys[wParam] = TRUE; // If So, Mark It As TRUE


}

case WM_KEYUP: // Has A Key Been Released?

{

keys[wParam] = FALSE; // If So, Mark It As FALSE


}

case WM_SIZE: // Resize The OpenGL Window

{

ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height


}

}

// Pass All Unhandled Messages To DefWindowProc

return DefWindowProc(hWnd,uMsg,wParam,lParam);

}

int WINAPI WinMain( HINSTANCE hInstance, // Instance

HINSTANCE hPrevInstance, // Previous Instance

LPSTR lpCmdLine, // Command Line Parameters

int nCmdShow) // Window Show State

{

MSG msg; // Windows Message Structure

BOOL done=FALSE; // Bool Variable To Exit Loop

MessageBox(NULL,"Pfeiltasten fur Bewegung\n l - Licht\n f - Filter\n z - Buffer", "Tastaturbelegung", MB_OK);

// Ask The User Which Screen Mode They Prefer

if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)

{

43


fullscreen=FALSE; // Windowed Mode

}

// Create Our OpenGL Window

if (!CreateGLWindow("PiCube3D",640,480,16,fullscreen))

{

return 0; // Quit If Window Was Not Created

}

while(!done) // Loop That Runs While done=FALSE

{

if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?

{

if (msg.message==WM_QUIT) // Have We Received A Quit Message?

{

done=TRUE; // If So done=TRUE

}

else // If Not, Deal With Window Messages

{

TranslateMessage(&msg); // Translate The Message

DispatchMessage(&msg); // Dispatch The Message

}

}

else // If There Are No Messages

{

// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()

if ((active && !DrawGLScene()) || keys[VK_ESCAPE]) // Active? Was There A Quit Received?

{

done=TRUE; // ESC or DrawGLScene Signalled A Quit

}

else // Not Time To Quit, Update Screen

{

SwapBuffers(hDC); // Swap Buffers (Double Buffering)

if (keys[’L’] && !lp)

{

lp=TRUE;

light=!light;

if (!light)

{

glDisable(GL_LIGHTING);

}

else

{

glEnable(GL_LIGHTING);

}

}

if (!keys[’L’])

{

lp=FALSE;

}

if (keys[’F’] && !fp)

{

fp=TRUE;

filter+=1;

if (filter>2)

{

filter=0;

}

}

if (!keys[’F’])

{

fp=FALSE;

}

if (keys[’Z’] && !lp)

{

zp=TRUE;

zbuffer=!zbuffer;

if (!zbuffer)

{

glEnable(GL_DEPTH_TEST);

}

else

{

glDisable(GL_DEPTH_TEST);

}

}

if (!keys[’Z’])

{

zp=FALSE;

}

if (!keys[’F’])

{

fp=FALSE;

}

if (keys[VK_PRIOR])

{

44


z-=0.02f;

}

if (keys[VK_NEXT])

{

z+=0.02f;

}

if (keys[VK_UP])

{

xspeed-=0.001f;

}

if (keys[VK_DOWN])

{

xspeed+=0.001f;

}

if (keys[VK_RIGHT])

{

yspeed+=0.001f;

}

if (keys[VK_LEFT])

{

yspeed-=0.001f;

}

if (keys[VK_F1]) // Is F1 Being Pressed?

{

keys[VK_F1]=FALSE; // If So Make Key FALSE

KillGLWindow(); // Kill Our Current Window

fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode

// Recreate Our OpenGL Window

if (!CreateGLWindow("PiCube3D",640,480,16,fullscreen))

{

return 0; // Quit If Window Was Not Created

}

}

}

}

}

// Shutdown

KillGLWindow(); // Kill The Window

return (msg.wParam); // Exit The Program

}

\end{document}

45

7.3 Realisierung eines Wurfels unter DirectX Projekt Graphik

7.3 Realisierung eines Wurfels unter DirectX

Der folgende Quellcode generiert einen in Direct3D9 erzeugten, rotie-renden Wurfel

#include <windows.h> #include <d3dx9.h> #include <d3d9.h>

//Definition vom Vertex Koord.i.Modelspace Texturkoord.

#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE |

D3DFVF_TEX1)

// Private GDI Schnittstelle

HDC hDC = NULL; HWND hWnd = NULL;

// Haltet die Instanz der Applikation

HINSTANCE hInstance;

// DirectX 3D Version 9 Objekt

LPDIRECT3D9 pD3D = NULL;

// DirectX 3D Render Schnittstelle

LPDIRECT3DDEVICE9 pD3DDevice = NULL;

// DirectX Textur Schnittstelle

LPDIRECT3DTEXTURE9 pTexture = NULL;

bool keys[256]; // Array fur Keyboard Routine bool

active=TRUE; // Window Active Flag Set TRUE By Default bool

fullscreen=TRUE; // Fullscreen Flag Set To Fullscreen Mode

// Vertex Buffer

IDirect3DVertexBuffer9 *pVertexBuffer = NULL;

struct my_vertex{ FLOAT x, y, z; // untransformierte Position vom

Vertex. DWORD Diffuse; // Diffuse Komponent FLOAT tu, tv; //

Texturkoordinaten };

//* Wurfelkoordinaten *

my_vertex g_vertices[] ={

// Wurfelkoordinaten | Texturkoordinaten

// X Y Z Diffuse Wert X Y

{ -1.0f, -1.0f, -1.0f,0, 0.0f, 1.0f }, //Front face

{ -1.0f, 1.0f, -1.0f,0, 0.0f, 0.0f },

{ 1.0f, 1.0f, -1.0f,0, 1.0f, 0.0f },

{ 1.0f, 1.0f, -1.0f,0, 1.0f, 0.0f },

{ 1.0f, -1.0f, -1.0f,0, 1.0f, 1.0f },

{ -1.0f, -1.0f, -1.0f,0, 0.0f, 1.0f },

{ 1.0f, -1.0f, 1.0f,0, 0.0f, 1.0f }, //Back face

{ 1.0f, 1.0f, 1.0f,0, 0.0f, 0.0f },

{ -1.0f, 1.0f, 1.0f,0, 1.0f, 0.0f },

{ -1.0f, 1.0f, 1.0f,0, 1.0f, 0.0f },

{ -1.0f, -1.0f, 1.0f,0, 1.0f, 1.0f },

{ 1.0f, -1.0f, 1.0f,0, 0.0f, 1.0f },

{ -1.0f, 1.0f, -1.0f,0, 0.0f, 1.0f }, //Top face

{ -1.0f, 1.0f, 1.0f,0, 0.0f, 0.0f },

{ 1.0f, 1.0f, 1.0f,0, 1.0f, 0.0f },

{ 1.0f, 1.0f, 1.0f,0, 1.0f, 0.0f },

{ 1.0f, 1.0f, -1.0f,0, 1.0f, 1.0f },

{ -1.0f, 1.0f, -1.0f,0, 0.0f, 1.0f },

{ 1.0f, -1.0f, -1.0f,0, 0.0f, 1.0f }, //Bottom face

{ 1.0f, -1.0f, 1.0f,0, 0.0f, 0.0f },

{ -1.0f, -1.0f, 1.0f,0, 1.0f, 0.0f },

{ -1.0f, -1.0f, 1.0f,0, 1.0f, 0.0f },

{ -1.0f, -1.0f, -1.0f,0, 1.0f, 1.0f },

{ 1.0f, -1.0f, -1.0f,0, 0.0f, 1.0f },

{ -1.0f, -1.0f, 1.0f,0, 0.0f, 1.0f }, //Left face

{ -1.0f, 1.0f, 1.0f,0, 0.0f, 0.0f },

{ -1.0f, 1.0f, -1.0f,0, 1.0f, 0.0f },

{ -1.0f, 1.0f, -1.0f,0, 1.0f, 0.0f },

{ -1.0f, -1.0f, -1.0f,0, 1.0f, 1.0f },

46


{ -1.0f, -1.0f, 1.0f,0, 0.0f, 1.0f },

{ 1.0f, -1.0f, -1.0f,0, 0.0f, 1.0f }, //Right face

{ 1.0f, 1.0f, -1.0f,0, 0.0f, 0.0f },

{ 1.0f, 1.0f, 1.0f,0, 1.0f, 0.0f },

{ 1.0f, 1.0f, 1.0f,0, 1.0f, 0.0f },

{ 1.0f, -1.0f, 1.0f,0, 1.0f, 1.0f },

{ 1.0f, -1.0f, -1.0f,0, 0.0f, 1.0f },

};

#define NUM_VERTICES (sizeof(g_vertices)/sizeof(my_vertex))

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); //

Deklaration fur WndProc

void ReSizeD3DScene(int width, int height) // Resize

und Initialisierung vom D3D Fenster {

if (height==0) // Vorbeugen Nulldivision

{

height=1; // Height 1 setzen

}

D3DXMATRIX projection_matrix;

D3DXMatrixPerspectiveFovLH(&projection_matrix, 45.0f,(float)width/(float)

height, 0.1f, 100.0f );

pD3DDevice->SetTransform( D3DTS_PROJECTION, &(D3DMATRIX)projection_matrix );

D3DXMatrixIdentity(&projection_matrix);

}

int InitD3D() // Setup

Fur D3D {

pD3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE ); // ZBUFFER

pD3DDevice->SetRenderState(D3DRS_CULLMODE, FALSE); // Backface Culling

pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE); // Licht

pD3DDevice->SetTextureStageState(0,D3DTSS_COLOROP, D3DTOP_SELECTARG1);

pD3DDevice->SetTextureStageState(0,D3DTSS_COLORARG1, D3DTA_TEXTURE);

pD3DDevice->SetTextureStageState(0,D3DTSS_ALPHAOP, D3DTOP_DISABLE);

pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);

pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);

pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_ANISOTROPIC);

D3DXCreateTextureFromFile( pD3DDevice, "stein.jpg",&pTexture);

pD3DDevice->CreateVertexBuffer( 36*sizeof(my_vertex),0, D3DFVF_CUSTOMVERTEX,

D3DPOOL_DEFAULT, &pVertexBuffer, NULL );

unsigned char *pVertices = NULL;

pVertexBuffer->Lock( 0, sizeof(g_vertices), (void**)&pVertices, 0 );

memcpy( pVertices, g_vertices, sizeof(g_vertices) );

pVertexBuffer->Unlock();

return TRUE; //Initialisierung OK

}

int DrawD3DScene() //

Zeichnen {

pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, // Clear Screen

D3DCOLOR_COLORVALUE(0.0f,0.0f,0.0f,0.0f), 1.0f, 0 );

static float rotqube = 0.0f; //Rotationsgeschwindigkeit

rotqube += 0.4f;

D3DXMATRIX matWorld; // World Matrix

D3DXMATRIX matTranslation; // Translation Matrix

D3DXMATRIX matRotX; // X Achse Rotations Matrix

D3DXMATRIX matRotY; // Y Achse Rotations Matrix

D3DXMATRIX matRotZ; // Z Achse Rotations Matrix

D3DXMATRIX matRotXYZ; // XYZ Rotations Matrix

47


D3DXMatrixTranslation( &matTranslation, 0.0f, 0.0f, 5.0f );

D3DXMatrixRotationY(&matRotY, D3DXToRadian(rotqube)); // Rotation in Y Richtung

D3DXMatrixRotationX(&matRotX, D3DXToRadian(rotqube)); // Rotation in X Richtung

D3DXMatrixRotationY(&matRotY, D3DXToRadian(rotqube)); // Rotate In Z Richtung

D3DXMatrixRotationZ(&matRotZ, D3DXToRadian(rotqube));

D3DXMatrixRotationYawPitchRoll( &matRotX, D3DXToRadian(rotqube),

D3DXToRadian(rotqube), D3DXToRadian(rotqube) );

matWorld = (matRotY * matRotX * matRotZ) * matTranslation;

pD3DDevice->SetTransform( D3DTS_WORLD, &matWorld ); // Setup Transformation

pD3DDevice->BeginScene(); // Begin der Direct3D Szene

pD3DDevice->SetStreamSource( 0, pVertexBuffer, 0, sizeof(my_vertex) );

pD3DDevice->SetFVF( D3DFVF_CUSTOMVERTEX );

pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,NUM_VERTICES/3); //Wurfel zeichnen

pD3DDevice->EndScene(); // Ende der Direct3D Szene

pD3DDevice->Present( NULL, NULL, NULL, NULL );// Ergebnis anzeigen

pD3DDevice->SetTexture( 0, pTexture );

return TRUE;

}

void KillD3DScene() {

if( pVertexBuffer != NULL )

{

pVertexBuffer->Release(); // Vertex Buffer freimachen

pVertexBuffer = NULL;

pTexture->Release();

pTexture=NULL;

}

}

void KillD3DWindow() // Fenster

schliessen {

if (pD3DDevice != NULL) pD3DDevice->Release(); // D3D Schnittstelle freimachen

if (pD3D != NULL) pD3D->Release(); // D3D Schnittstelle freimachen

if (fullscreen) // Vollbildabfrage

{

ChangeDisplaySettings(NULL,0); // Wenn ja, zuruck zum Desktop

ShowCursor(TRUE); // Mauszeiger anzeigen

}

if (hDC && !ReleaseDC(hWnd,hDC)) // Kann DC freigemacht werden

{

MessageBox(NULL,"Release Device Context Fehlgeschlagen.","SHUTDOWN ERROR",

MB_OK | MB_ICONINFORMATION);

hDC=NULL; // DC NULL setzen

}

if (hWnd && !DestroyWindow(hWnd)) // Kann man Fenster schliessen

{

MessageBox(NULL,"Fenster konnte nicht entfernt werden -> hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

hWnd=NULL; // hWnd NULL setzen

}

if (!UnregisterClass("Direct3D",hInstance)) // Kann man Klasse unregistrieren

{

MessageBox(NULL,"Programm konnte nicht korrekt abgemeldet werden.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

hInstance=NULL; // hInstance NULL setzen

}

}

//============================================================================================

// Fenstergenerierung

//===========================================================================================

BOOL CreateD3DWindow(char* title, int width, int height, bool

48


fullscreenflag) {

WNDCLASS wc;

DWORD dwExStyle; // Fenster Extended Style

DWORD dwStyle; // Fenster aussehen

RECT WindowRect; // Werte Dreieck oben links / unten rechts

WindowRect.left=(long)0; // Linkswert 0

WindowRect.right=(long)width; // Rechtswert auf angeforderte Breite

WindowRect.top=(long)0; // Wert oben 0

WindowRect.bottom=(long)height; // Wert oben auf angeforderte Hohe

fullscreen=fullscreenflag; // Globaler Fullscreen Flag

hInstance = GetModuleHandle(NULL);

wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

wc.lpfnWndProc = (WNDPROC) WndProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = hInstance;

wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Icon

wc.hCursor = LoadCursor(NULL, IDC_CROSS); // Mauszeiger

wc.hbrBackground = NULL; // Hintergrund D3D aber 0

wc.lpszMenuName = NULL; // Menu, aber 0

wc.lpszClassName = "Direct3D"; // Klasse

if (!RegisterClass(&wc)) // Fenster registrieren

{

MessageBox(NULL,"Registrieren der Window Klasse fehlgeschlagen.","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

if (fullscreen) // Vollbild?

{

dwExStyle=WS_EX_APPWINDOW;

dwStyle=WS_POPUP;

ShowCursor(FALSE); // Mauszeiger verstecken

}

else

{

dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;

dwStyle=WS_OVERLAPPEDWINDOW;

}

AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Fenster einstellen auf angeforderte Große

// Create The Window

if (!(hWnd=CreateWindowEx( dwExStyle,

"Direct3D", // Klassenname

title, // Fenstername

dwStyle | // Definierter Fenster Style

WS_CLIPSIBLINGS | // Benotigter Fenster Style

WS_CLIPCHILDREN, // Benotigter Fenster Style

0, 0, // Fenster Position

WindowRect.right-WindowRect.left, // Fenster Breite anpassen

WindowRect.bottom-WindowRect.top, // Fenster Hohe anpassen

NULL, // Kein parent Window

NULL, // Kein Menu

hInstance,

NULL)))

{

KillD3DWindow(); // Reset Anzeige

MessageBox(NULL,"Fenstererzeugungsfehler.","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

if (!(hDC=GetDC(hWnd))) // Schnittstellen Context ?

{

KillD3DWindow();

MessageBox(NULL,"Kann keinen Schnittstellen Contex erzeugen.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

pD3D = Direct3DCreate9(D3D_SDK_VERSION); // Abfrage DX Version

if ( pD3D == NULL )

{

KillD3DWindow();

MessageBox(NULL,"Kann DirectX SDK Version 9.x nicht finden","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

D3DPRESENT_PARAMETERS d3dpp= // d3dpp ubergibt Paramter Windows

{

width, // Back Buffer Breite

height, // Back Buffer Hohe

D3DFMT_R5G6B5, // Back Buffer Format (Farbtiefe)

49


1, // Back Buffer Zahlen (Double Buffer)

D3DMULTISAMPLE_NONE,

0,

D3DSWAPEFFECT_DISCARD,

hWnd,

!fullscreen, // Fenster oder Vollbild

TRUE,

D3DFMT_D16, // 16Bit Z-Buffer (Depth Buffer)

0,

D3DPRESENT_RATE_DEFAULT, // Refresh Rate auf default

D3DPRESENT_INTERVAL_DEFAULT

};

// Surface Format uberprufen

if ( FAILED( pD3D->CheckDeviceFormat( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,

d3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,

D3DRTYPE_SURFACE, d3dpp.AutoDepthStencilFormat ) ) )

{

KillD3DWindow(); // Reset The Display

MessageBox(NULL,"Surface Format nicht gefunden.","ERROR",MB_OK|MB_ICONEXCLAMATION);


}

// DirectX 3D Schnittstelle uberprufen

if(FAILED( pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,

D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pD3DDevice ) ) )

{

KillD3DWindow();

MessageBox(NULL,"Kann DirectX 3D Schnittstelle nicht erzeugen.","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

ShowWindow(hWnd,SW_SHOW); // Fenster anzeigen

SetForegroundWindow(hWnd);

SetFocus(hWnd); // Focus setzen

ReSizeD3DScene(width, height); // Perspektive setzen

if (!InitD3D()) // D3D Fenster initialisieren

{

KillD3DWindow();

MessageBox(NULL,"Initialisierung fehlgeschlagen.","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

return TRUE;

}

LRESULT CALLBACK WndProc( HWND hWnd,

UINT uMsg,

WPARAM wParam,

LPARAM lParam )

// MESSAGEHANDLER

{

switch( uMsg )

{

case WM_ACTIVATE: // Aktive Nachricht ?

{

if (!HIWORD(wParam)) // Minimiert ?

{

active=TRUE; // Programm aktiv

}

else

{

active=FALSE; // Programm inaktiv

}

return 0;

}

case WM_SYSCOMMAND:

{

switch (wParam)

{

case SC_SCREENSAVE: // Screensaver start ?

case SC_MONITORPOWER: // Energiemodus aktiv ?

return 0;

}

break;

}

case WM_CLOSE: // Close Nachricht erhalten?

{

50


PostQuitMessage(0); // Quit Message senden

return 0;

}

case WM_KEYDOWN: // Taste gedruckt?

{

keys[wParam] = TRUE; // Falls ja TRUE

return 0;

}

case WM_KEYUP: // Taste nicht gedruckt?

{

keys[wParam] = FALSE; // Falls ja FALSE

return 0;

}

case WM_SIZE: // Direct3D Fenster neue Große

{

if(!fullscreen)

ReSizeD3DScene(LOWORD(lParam), HIWORD(lParam)); // LoWord=Breite, HiWord=Hohe

return 0;

}

}

// Alle unbehandelten Nachrichten an DefWindowProc senden

return DefWindowProc(hWnd,uMsg,wParam,lParam);

}

int WINAPI WinMain( HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPSTR lpCmdLine,

int nCmdShow

)

{

MSG msg;

BOOL done=FALSE; // Bool Variable um aus Schleife zu kommen

// Welcher Bildschirmmodus ?

if (MessageBox(NULL,"F1 - Vollbildmodus \nF2 - ZBUFFER aus\nF3 - ZBUFFER an\nF4 - Wireframe\nESC - Programm beenden", "Funktionstasten",MB_OK|MB_ICONINFORMATION|MB_DEFBUTTON2==IDNO)==IDOK)

{

fullscreen=FALSE; // Fenstermodus

}

// Create Our DirectX 3D Window

if (!CreateD3DWindow("Projekt Graphik (C) 2005 by Christian Piwecki",1024,768,fullscreen))

{

return 0; // Quit wenn Fenster nicht erzeugt

}

while(!done) // Schleife done=FALSE

{

if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Wartet Nachricht ?

{

if (msg.message==WM_QUIT) // Quit Nachricht ?

{

done=TRUE; // If So done=TRUE

}

else

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}

else // Wenn keine Nachrichten vorhanden

{

// Zeichnen der Szene. Abfragen von ESC Key und DrawD3DScene()

if ((active && !DrawD3DScene()) || keys[VK_ESCAPE]) // Active? Quit erhalten?

{

done=TRUE; // ESC DrawD3DScene

}

// Vollbild F1

if (keys[VK_F1]) // F1 gedruckt ?

{

keys[VK_F1]=FALSE; // Wenn ja key = false

KillD3DWindow();

fullscreen=!fullscreen; // Vollbild / Fenstermodus

// D3D Fenster neu machen

if (!CreateD3DWindow("Projekt Graphik (C) 2005 by Christian Piwecki",1024,768,fullscreen))

{

return 0; // Quit wenn kein Fenster erzeugt wurde

}

}

51


// ZBUFFER aus F2

if (keys[VK_F2])

{

pD3DDevice->SetRenderState(D3DRS_ZENABLE, FALSE ); // ZBUFFER AUS

pD3DDevice->SetRenderState(D3DRS_CULLMODE, FALSE); // Backface Culling aus

pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE); // Licht an











}

// ZBUFFER mit F3 einschalten

if (keys[VK_F3])

{

pD3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE ); // ZBUFFER AN













}

// Wireframe aktivieren

if (keys[VK_F4])

{

pD3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE ); // ZBUFFER AN






pD3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME); // Wireframes AN








}

}

}

// Shutdown

KillD3DWindow();

return (msg.wParam); // Exit

}

52


\end{document}

53

DirectX vs. OpenGL - · PDF file1.3 Bekannte Graﬁkengines Projekt Graphik Die Texturen...

Documents

Transcript of DirectX vs. OpenGL - · PDF file1.3 Bekannte Graﬁkengines Projekt Graphik Die Texturen...