Lehrheft OpenGL. Zur Veranstaltung Computergraphik I (Grundlagen) Prof. Dr. Stefan Schlechtweg-Dorendorf Hochschule Anhalt Fachbereich Informatik

Transkript

1 Lehrheft OpenGL Zur Veranstaltung Computergraphik I (Grundlagen) Prof. Dr. Stefan Schlechtweg-Dorendorf Hochschule Anhalt Fachbereich Informatik

2 Inhaltsverzeichnis 1 Grundlegendes zu OpenGL Einrichten des Arbeitsplatzes Microsoft Visual C Express Edition Eclipse für Java Arbeitsweise von OpenGL OpenGL-Rahmenprogramm C-Rahmenprogramm JAVA-Rahmenprogramm Einfache 3D-Ausgabe Transformationen Sichttransformation Modellierungstransformation(en) Projektionstransformation Bildschirmtransformation Zusammenfassung Transformationen Erzeugen eigener Geometrien Animationen Interaktion Tastatur Maus Beleuchtung und Materialien Oberflächennormalen Lichtquellen Materialbeschreibungen...35

3 1 Grundlegendes zu OpenGL OpenGL ist eine Bibliothek zur Programmierung von zwei- und dreidimensionalen graphischen Anwendungen. OpenGL ist plattformunabhängig, das heißt in diesem Fall, daß der Quellcode eines OpenGL-Programms auf verschiedenen Plattformen (Windows, Apple, UNIX) übersetzt werden kann und daß die Installation der kor rekten Bibliotheken vorausgesetzt die Programme sich auf den verschiedenen Plattformen gleich verhalten. OpenGL ist eine der ältesten Graphikbibliotheken. Ihre Spezifikation wurde bereits 1992 veröffentlicht. OpenGL hat sich zu einem Standard für die Graphikprogrammierung etabliert und wird heute von allen gängi gen Betriebssystemen unterstützt. Zur Vereinfachung der Programmierung gibt es zwei weitere Bibliotheken, die OpenGL erweitern und zusammen mit OpenGL häufig benutzt werden: Die OpenGL Utility Library GLU, die OpenGL um etwa 50 Befehle erweitert, insbesondere um Modellierungs-Funktionen Das OpenGL Utility Toolkit GLUT, einen Aufsatz auf OpenGL und GLU, der insbesondere Funktionen des Fenstersystems kapselt und für eine vereinfachte Ein- und Ausgabebehandlung sorgt. Weitere Informationen zu den hier verwendeten Graphikbibliotheken findet man in Internet unter Hier werden ständig aktuelle Informationen zu Entwicklung und Erweiterung von OpenGL bereitgestellt. Weiterhin können hier Dokumentationen eingesehen werden. Besonders wichtig sind hier das sogenannte Red Book (OpenGL Programming Guide) und das Blue Book (OpenGL Refernce Manual). Beide Titel sind auch online einsehbar. Die Adressen lauten: (siehe Abbildung 1). Weitere Dokumentationen findet man unter den entsprechenden Links auf der Seite, die Dokumente zu GLUT beispielsweise unter oder Die Namensgebung der (OpenGL-)Funktionen erfolgt nach einem einheitlichen Schema. Die Funktionsnamen beginnen mit einem Präfix, der die Bibliothek kennzeichnet, in der sie definiert sind. Dies sind gl für OpenGL- Basisfunktionen, glu für Funktionen aus der OpenGL Utility Library GLU und glut aus dem OpenGL Utility Toolkit GLUT. Darauf folgt der Name der eigentlichen Funktion. Bei einigen Funktionen, die es in verschiedenen Ausführungen gibt, schließt sich hier eine Zahl an, die die Anzahl der zu übergebenden Parameter bezeich net. Möglich sind hier: 2 für zweidimensionale Koordinaten (x, y) 3 für dreidimensionale Koordinaten oder Farbangaben (x, y, z) oder (r, g, b) 4 für vierdimensionale Koordinaten oder Farbangaben (x, y, z, w) oder (r, g, b, a) Im Falle der Angabe der Argumentanzahl folgt darauf ein Kürzel, das den Datentyp der Argumente spezifiziert. Aufgabe 1: Erklären Sie den Namen der folgenden Funktionen. Welche Parameter werden bei den ersten drei Funktionen erwartet? GlVertex2i(...) Abbildung 1: OpenGL-Dokumentationen Aufgabe 1 glvertex4f(...) glcolor3d(...) 3

4 gluperspective(...) glutcreatewindow(...) Konstanten werden grundsätzlich groß geschrieben und die Teile ihrer Bezeichner durch Unterstrich voneinander getrennt. Alle Konstantenbezeichner beginnen mit GL_. OpenGL definiert eigene Datentypen, die die von den Programmiersprachen angebotenen Datentypen kapseln. Diese, mit GL beginnenden Typbezeichner, stellen die Portabilität sicher und sollten verwendet werden. 2 Einrichten des Arbeitsplatzes Die Beispiele in diesem Lehrheft werden sowohl in C(++) als auch in Java mit JOGL präsentiert. Zu Beginn müssen in beiden Fällen die Arbeitsumgebung eingerichtet werden. Im Folgenden wird davon ausgegangen, daß (a) Microsoft Visual C++ (2008) Express Edition und (b) Eclipse als Java Entwicklungsumgebung verwendet wird. Sollte eine andere Umgebung verwendet werden, sind die Ausführungen entsprechend anzupassen. 2.1 Microsoft Visual C Express Edition Nachdem Microsoft Visual C Express Edition gestartet wurde, wird ein neues Projekt angelegt. Unter Datei Neu Projekt... erscheint ein Dialog, in dem als Projekttyp Allgemein angegeben und dann die Leere Vorlage ausgewählt wird (siehe Abbildung 2). Danach wird das Projekt entsprechend benannt und ein Speicherort wird ausgewählt (standardmäßig werden Projekte unter Eigene Dateien\Visual Studio 2008\Projekts\ gespeichert. Microsoft Visual C++ legt daraufhin eine Verzeichnisstruktur an, in die die Dateien des Projektes gespeichert werden. Sollte auf dem Computer GLUT noch nicht installiert sein, kann das nachgeholt werden. Dazu laden ist die Abbildung 2: Projekteinstellungen für Microsoft Visual C Datei glut bin.zip von herunterzuladen und zu entpacken sie. Administratoren können der Anleitung in README-win32.txt zur Installation folgen. Sonst können auch alle Dateien einfach in das angelegte Projektverzeichnis kopiert werden. Dann können sie allerdings nur in dem einen Projekt verwendet werden. Damit ist die Arbeitsumgebung unter Microsoft Visual C Express Edition eingerichtet. Da die in diesem Lehrheft vorgestellten Aufgaben alle mit einer Quellcodedatei auskommen, reicht es, eine neu Datei anzule gen (z.b. opengl1.cpp). Dies erfolgt mittels Datei Neu Datei... und im dann erscheinenden Dialog mit der Vorlage C++-Datei (.cpp) unter Visual C++. Es wird zunächst ein Standardname vergeben (Quelle1.cpp). Die Datei wird dann mittels Datei Speichern unter... gespeichert und kann dann mit Datei Verschieben in <Projekt> in das Projekt aufgenommen werden. 2.2 Eclipse für Java Vorausgesetzt wird hier eine funktionierende Installation von Java, Eclipse und JOGL. Mithilfe von JOGL kann ein Java-Programmierer auf OpenGL-Funktionen zugreifen. Es werden spezielle Java-Wrapperklassen bereitgestellt, die Schnittstellen zu den nativen OpenGL-Funktionen bereitstellen. Die angebotenen Methoden führen dabei in der Regel einfach korrespondierenden nativen C-Code aus 1. Die Installation unter Eclipse wird wie folgt vorgenommen. Dabei entsteht am Ende ein Eclipse-Projekt, in dem die JOGL-Klassen korrekt eingebunden sind. Die JOGL-Klassen stehen allerdings nicht systemweit für andere Projekte zur Verfügung. 1 aus Wikipedia: JOGL 4

5 Zur Installation wird zunächst in Eclipse ein neues leeres Java-Projekt angelegt und entsprechend benannt, z.b. Jogl-Demo. Dann werden im Projektverzeichnis zwei Verzeichnisse angelegt mit Namen lib und native. Unter kann jetzt die aktuelle Distribution heruntergeladen werden (hier auf die Zielplattform achten, für Windows heißt die Datei jogl-2.0-windows-i586.zip). Aus der heruntergeladenen ZIP-Datei werden alle *.jar-dateien nach lib kopiert und alle *.dll-datein nach native. Mit F5 den Workspace aktualisieren und dann im lib-verzeichnis die beiden *.jar-dateien markieren und im Kontextmenü mittels Build Path Add to Buildpath zum Build-Pfad hinzufügen. Danach müssen die beiden Dateien im Projekt unter Referenced Libraries auftauchen. Danach den Eigenschaftendialog des Pro jektes öffnen im Kontextmenü des Projekts unter Properties. Dort die Seite Java Build Path Libraries suchen. Jetzt muß noch die Verbindung zu den nativen Bibliotheken hergestellt werden. Dazu gluegen-rt.jar markieren, den Eintrag mit dem + erweitern, Native Library Location markieren und mit Edit den Eingabe dialog für die Location öffnen. Hier wird das oben angelegte Verzeichnis native ausgewählt. Genauso wird bei jogl.jar vorgegangen. Die Angaben im Properties-Dialog müssen dann in etwa so aussehen, wie in Abbildung 3, das Projekt wie in Abbildung 4. Abbildung 3: Java-Build-Path für das JOGL-Projekt Abbildung 4: Java-Project für JOGL Jetzt kann JOGL und die entsprechenden Funktionen in diesem Java-Projekt genutzt werden. Weitere Informationen zu JOGL sind unter anderem unter folgenden Links erhältlich: die Hauptseite des JOGL-API-Projektes Informationen und einige Tutorials Weitere Tutorials finden sich unter dies sind Portierungen der bekannten NEHE-OpenGL-Tutorials ( Die herunterladbaren *.jar-dateien enthalten sowohl den Sourcecode als auch eine kompilierte Version (für den Sourcecode die *.jar-dateien einfach auspacken). 3 Arbeitsweise von OpenGL OpenGL arbeitet ereignisorientiert. Eingabegeräte oder das Betriebssystem erzeugen Ereignisse, die von OpenGL (bzw. GLUT) in einer Ereigniswarteschlange gesammelt und dann abgearbeitet werden. Dazu werden sogenannte Callbacks registriert. Dies sind spezielle Funktionen, die immer dann aufgerufen werden, wenn ein spezielles Ereignis abgearbeitet werden muß. Der Programmierer kann hier die programmspezifischen Reaktio nen auf die Ereignisse festlegen und damit den Ablauf des Programms steuern. GLUT bietet Registrierungsfunktionen für Callbacks für folgende Ereignisse an: Maus- und Tastatureingaben Neuzeichnen der Szene 5

6 Veränderung von Fensterposition und -größe Menüaktionen, usw. Weitere Callbacks für spezielle Eingabegeräte sind weniger gebräuchlich. OpenGL arbeitet nach dem Prinzip einer Zustandsmaschine. Die Ergebnisse sind abhängig von einer Reihe von Zustandsvariablen (die global definiert sind), d.h. die Operationen werden aufgrund von Zustandsvariablen interpretiert. Beispiele für solche Zustandsvariablen sind der Rendermodus, das Beleuchtungsmodell oder Zeichenattribute wie Farbe und Materialien. Für das Setzen und Löschen einiger boolescher Zustandsvariablen stehen die folgenden Funktionen bereit: glenable( attribut) Hiermit wird ein Zustand gesetzt bzw. eingeschaltet. gldisable( attribut) Hiermit wird ein Zustand gelöscht bzw. ausgeschaltet. Andere Zustandsvariablen werden nicht auf diese Art und Weise gesetzt sondern über normale OpenGL- Funktionen und gelten dann mit dem gesetzten Wert so lange, bis ein anderer Wert gesetzt wird. Beispiele hierfür sind Materialbeschreibungen oder Farben. 4 OpenGL-Rahmenprogramm 4.1 C-Rahmenprogramm Programm 2 stellt den Rahmen für einfache OpenGL-Programme in C dar. In der main-funktion werden die erforderlichen Initialisierungen vorgenommen und die Display-Callback registriert. Die eigentliche Callback-Funktion ist in Programm 2 noch nicht ausprogrammiert. Deshalb erscheint auch lediglich ein leeres Fenster mit dem Titel OpenGL auf dem Bildschirm (siehe Abbildung 5). Die Registrierung weiterer Callbacks erfolgt nach dem gleichen Schema in der main-funktion. Die einzelnen Callbacks und ihre Funktionen werden im weiteren Verlauf des Heftes gesondert behandelt. Zur besseren Übersicht wurden die beiden globalen Variablen screenheight und screen Width eingeführt, die die Breite und Höhe des Ausgabefensters beinhalten. Die Funktionsaufrufe in main haben folgende Bedeutung: glutinit( &argc, argv) initialisiert das GLUT-Toolkit. Dabei Abbildung 5: Ausgabe von Programm 2 wird unter anderem geprüft, ob das Programm auf der vorhandenen Hardware überhaupt lauffähig ist gegebenenfalls wird das Programm mit einer Fehlermeldung abgebrochen. Übergeben wird die Kommandozeile des Programms, da hier unter anderem auch GLUT-spezifische Parameter gesetzt werden können. glutinitdisplaymode( GLUT_DOUBLE GLUT_RGBA) setzt den initialen Darstellungs-modus für OpenGL. Parameter werden durch ODER-Verknüpfung miteinander kombiniert. glutinitwindowsize( screenwidth, screenheight) initialisiert die Fenstergröße auf den Wert der globalen Variablen screenwidth und screenheight. Hier wird noch kein Fenster erstellt. glutcreatewindow( "OpenGL") erzeugt und öffnet eine neues Fenster, wobei der Parameter des Funktionsaufrufes als Fenstername übergeben wird. glutdisplayfunc( mydisplay) registriert die Display-Callback für das aktuelle Fenster. Nach dem Erzeugen des Fensters besitzt dieses noch keine Display-Callback, es liegt also in der Verantwortung des Programmierers, diese bereitzustellen. Die Display-Callback wird immer dann aufgerufen, wenn der Fensterinhalt neu gezeichnet werden muß. In ihr erfolgt typischerweise die Bereitstellung der graphischen Ausgabe in Form von OpenGL-Funktionsaufrufen. glutmainloop() startet das eigentliche Programm und übergibt die Kontrolle an GLUT. Alle Ereignisse werden hier verarbeitet und mit Hilfe von Callbacks hat der Programmierer die Kontrolle darüber, wie das Programm auf Ereignisse reagieren soll. 6

7 Dieses Hauptprogramm ist bei nahezu allen OpenGL-Programmen in seinen Grundzügen gleich. Im weiteren Verlauf werden die Registrierung weiterer Callbacks hinzukommen. Programm 1: Schematischer Ablauf der Funktion glutmainloop() while (1) if (Graphik wurde verändert) call DISPLAY Callback; if (Fenster wurde verändert) call RESHAPE Callback; if (Tastatur betätigt oder Maus bewegt) call KEYBOARD/MOUSE Callback; call IDLE Callback Funktion; Der interne Ablauf bei der Ausführung eines nach diesem Muster aufgebauten Programms besteht darin, zu Beginn wichtige Variablen und Zustände zu initialisieren, die entsprechenden Callbacks zu registrieren und dann in die Hauptschleife zur Ereignisverarbeitung einzusteigen. Diese wird in der GLUT-Bibliothek bereitgestellt und nimmt dem Programmierer die Details der Ereignisverwaltung ab. Programm 1 zeigt schematisch den internen Ablauf in der Funktion glutmainloop(). Das Programm befindet sich also in einer Endlosschleife, in der Ereignisse entgegengenommen und diese verarbeitet werden. Der Programmierer muß dafür Sorge tragen, daß die Ereignisverwaltung in den Callbacks entsprechend der Aufgabe des Programms realisiert wird. Neben dem Hauptprogramm ist die Display-Callback die wichtigste Funktion eines OpenGL-Programmes. Hier wird die graphische Ausgabe erzeugt, indem OpenGL- Funktionen aufgerufen und damit graphische Primitive erzeugt, Transformationen durchgeführt oder andere Aufgaben erfüllt werden. Die Display-Callback wird immer dann aufgerufen, wenn der Inhalt eines Fensters neu gezeichnet werden muß und sollte rasch abgearbeitet werden. Obiges Programm 2 führt zu keiner graphischen Ausgabe, da die Display-Callback hier keinerlei Funktionsaufrufe enthält, die eine Ausgabe erzeugen. Die beiden vorhandenen Funktionen löschen lediglich den Fensterinhalt (glclear( GL_COLOR_BUFFER_BIT)) und forcieren die Ausgabe der Zeichenbefehle auf dem Fenster (glutswapbuffers()). Die Nutzung der Funktion glutswapbuffers() ist nur dann angebracht, wenn das Programm im DobleBuffering-Modus arbeitet. Ansonsten hat an dieser Stelle ein Aufruf der Funktion glflush() eine ähnliche Wirkung. Programm 2: OpenGL-Rahmenprogramm #include "glut.h" // globale Variablen int screenwidth = 600; // Breite des Anzeigefensters int screenheight = 600; // Hoehe des Anzeigefensters // /* Zeichenfunktion. Hier stehen die OpenGL-Befehle, die letztendlich die Darstellung auf dem Bildschirm erzeugen */ void mydisplay( void) glclear( GL_COLOR_BUFFER_BIT); // Bildschirm (Fensterinhalt) loeschen // Hier kommen die Zeichenbefehle hin glutswapbuffers(); // "Anzeige" des Bildes (DoubleBuffering) int main( int argc, char** argv) glutinit( &argc, argv); glutinitdisplaymode( GLUT_DOUBLE GLUT_RGBA); glutinitwindowsize( screenwidth, screenheight); glutcreatewindow( "OpenGL"); glutdisplayfunc( mydisplay); glutmainloop( ); exit( 0); // Initialisierung von GLUT // Einstellen des Anzeigemodus // Einstellen der Fenstergroesse // Fenster erzeugen // Setzen der Display-Funktion // glut-hauptschleife 4.2 Java-Rahmenprogramm Für die Programmierung in Java sieht der Quellcode wie in Java 1 aus. Die folgenden Programme benutzen Swing-Komponenten, daher ist die Klasse auch von JFrame abgeleitet. JOGL kann aber auch in Verbindung 7

8 mit AWT genutzt werden. Die Import-Deklarationen wurden aus Platzgründen weggelassen, sie ergeben sich aber durch die Verwendung der Klassen und Typen in den Programmen und werden außerdem von Eclipse selbsttätig eingefügt. Im Gegensatz zum nativen OpenGL verwendet JOGL die Java-Datentypen. Dementsprechend sind diese auch in den Programmen zu verwenden. Die in Java 1 angegebene Klasse ist vorerst bei allen JOGL-Programmen gleich. Java 1: Rahmenprogramm für eine JOGL-Anwendung (ohne Viewer-Klasse) public class JOGLMain extends JFrame final static int screenwidth = 600; final static int screenheight = 600; public JOGLMain() GLCapabilities glcaps = new GLCapabilities(); glcaps.setdoublebuffered( true); GLCanvas canvas = new GLCanvas( glcaps); JOGL0001 view = new JOGL0001(); canvas.addgleventlistener( view); // enthält Plattformparameter // DoubleBuffering einschalten // Viwer-Instanz erzeugen // und dem Canvas hinzufügen setsize( screenwidth, screenheight); // Fenstergröße setzen setfocusable( true); // Fenster fokussierbar machen settitle( "JOGL Beispielszene"); // Fenstertitel setzen getcontentpane().add( canvas, BorderLayout.CENTER); // GLCanvas einfügen addwindowlistener(new WindowAdapter() public void windowclosing(windowevent e) System.exit(0); ); public static void main(string[] args) final JOGLMain app = new JOGLMain(); SwingUtilities.invokeLater( new Runnable() public void run() app.setvisible(true); ); Die eigentliche Darstellung erfolgt in der Klasse JOGL0001, die das Interface GLEventListener implementieren muß 2. Im Hauptprogramm (Klasse GLMain) wird zunächst DoubleBuffering eingeschaltet und ein neuer GLCanvas erzeugt. Die Instanz der Viewer -Klasse wird erzeugt und zum Canvas hinzugefügt. Danach erfol gen noch einige Initialisierungen für Swing und Funktionen zum Erzeugen des Fensters. Die eigentliche OpenGL-Funktionalität ist in der Klasse JOGL0001 implementiert (siehe Java 2). Das Interface GLEventListener stellt einige der Funktionalitäten zur Verfügung, die mit den Callbacks in C realisiert werden können. Dies betrifft die OpenGL-Funktionen, Maus und Tastatureingaben werden über Java-Events abgefangen (dazu später mehr). Dementsprechend sind einige (abstrakte) Methoden zu überschreiben. Sollen die Funktionen nicht genutzt werden, können sie mit leerem Funktionskörper realisiert werden. Für das erste Beispiel ist nur die Methode display() notwendig. Sie entspricht der Display-Callback. Zunächst muß eine Instanz der Klasse GLDrawable bereitstehen. Diese wird bei der Initialisierung erzeugt. GLDrawable bietet Zugang zu GL- und GLU-Objekten, um die OpenGL Routinen aufzurufen. Alle OpenGL-Funktionen stehen in dieser Klasse über ein GL-Objekt zur Verfügung, daher muß der Aufruf mit der Instanzvariablen qualifiziert werden, also gl.glflush() anstelle von glflush(). Das Beispiel ist äquivalent zum entsprechenden C-Programm und führt dementsprechend auch zur gleichen Ausgabe. Zunächst wird der Fensterinhalt gelöscht (glclear()) und dann mit glflush() der Fensterinhalt angezeigt. Hier können keine GLUT-Funktionen verwendet werden, da kein Zugriff auf ein GLUT-Objekt besteht. Die in der Klasse noch vorhandenen Metho den displaychanged(...), init(...) und reshape(...) werden später besprochen. 2 Die Klassen werden ähnlich den C-Programmen mit Nummern benannt, so daß sie einfach ausgetauscht werden können. 8

9 Java 2: Viewer-Klasse für das äquivalente Beispiel zu Programm 2 public class JOGL0001 implements GLEventListener public void display( GLAutoDrawable drawable) GL gl = drawable.getgl(); // GL-Objekt holen gl.glclear( GL.GL_COLOR_BUFFER_BIT); // Bildschirm (Fensterinhalt) loeschen // Hier kommen die Zeichenbefehle hin gl.glflush(); // "Anzeige" des Bildes public void displaychanged( GLAutoDrawable drawable, boolean modechg, boolean devicechg) public void init(glautodrawable drawable) public void reshape(glautodrawable drawable, int x, int y, int width, int height) Aufgabe 2: Informieren Sie sich in der Dokumentation über die Bedeutung der Angaben und ergänzen Sie die folgende Aufzählung um diese Bedeutungen: GLUT_RGBA Aufgabe 2 GLUT_RGB GLUT_SINGLE GLUT_DOUBLE GLUT_DEPTH GLUT_STEREO Aufgabe 3: Informieren Sie sich, was DoubleBuffering bedeutet und was ein Aufruf von glutswapbuffers() in diesem Zusammenhang bewirkt. Was ist der Unterschied zu glflush()? Aufgabe 3 5 Einfache 3D-Ausgabe Eine einfache Möglichkeit, 3D-Objekte zu erzeugen und auszugeben, ist durch GLUT gegeben, da hier einige Grundkörper bereits vordefiniert sind. Diese können durch einfache Funktionsaufrufe eingebunden werden. Programm 3 zeigt als Beispiel die erweiterte Display-Callback aus Programm 2. Der Aufruf von glutwiresphere( 0.5, 10, 15) erzeugt eine Kugel mit dem Radius von 0.5 Einheiten. Die Kugel setzt sich aus 10 Segmenten zusammen, die wiederum jeweils in 15 Abschnitte unterteilt sind. Der Mittelpunkt der Kugel liegt 9

10 im Koordinatenursprung, die Achse, um die die Segmenteinteilung erfolgt, stimmt mit der z-achse überein. Programm 3: Kugel als GLUT-Funktion void mydisplay( void) glclear( GL_COLOR_BUFFER_BIT); glutwiresphere( 0.5, 10, 15); glutswapbuffers(); // Bildschirm (Fensterinhalt) loeschen // "Zeichnen" der Kugel // "Anzeige" des Bildes (DoubleBuffering) Um die gleiche Funktionalität in Java zu realisieren, benötigen wir Zugriff auf die GLUT-Funktionen. Dazu steht in JOGL die Klasse GLUT zur Verfügung, von der eine Instanz in der display()-methode benötigt wird. Der Einfachheit halber stellen wir diese Instanz als Variable in der Viewer-Klasse zur Verfügung. Im Gegensatz zu OpenGL für C implementiert JOGL nicht alle Funktionen der GLUT, da die Fensterbehandlung z.b. direkt von Java übernommen wird. In Java 3 ist die zu Programm 3 äquivalente Java-Klasse angegeben. Zu beachten ist, daß in der Hauptklasse (JOGLMain) die Klasse für den Viewer (jetzt: JOGL0002) ausgetauscht werden muß. Das Programm erzeugt wie oben eine Kugel mit einem Radius von 0.5 Einheiten im Koordinatenursprung. Zu beachten ist auch hier der Aufruf der GLUT-Routinen in der Instanz der Klasse GLUT, also z.b. mittels glut.glutwiresphere(...). Abbildung 6: Ausgabe von Programm 3 Java 3: Kugel als GLUT-Funktion public class JOGL0002 implements GLEventListener final GLUT glut = new GLUT(); public void display(glautodrawable drawable) GL gl = drawable.getgl(); // GLUT-Instanz global für diese Klasse // GL-Objekt holen gl.glclearcolor(0.0f, 0.0f, 0.0f, 0.0f); gl.glclear( GL.GL_COLOR_BUFFER_BIT); glut.glutwiresphere(0.5, 10, 15); gl.glflush(); // Hintergrundfarbe schwarz // Bildschirm (Fensterinhalt) loeschen // "Zeichnen" der Kugel // "Anzeige" des Bildes public void displaychanged( GLAutoDrawable drawable, boolean modechg, boolean devicechg) public void init(glautodrawable drawable) public void reshape(glautodrawable drawable, int x, int y, int width, int height) Aufgabe 4 Aufgabe 4: Ändern Sie Programm 2 so ab, daß die Display-Callback wie in Programm 3 angegeben aussieht. Führen Sie das Programm aus und vergleichen Sie die Ausgabe mit Abbildung 6. Ausgehend davon, erläutern Sie, wie das Standard-Koordinatensystem bei dreidimensionaler Ausgabe ohne weitere Änderungen der Ansicht aussieht: Position des Koordinatenursprungs: Verlauf der y-achse: Verlauf der x-achse: Verlauf der z-achse: Koordinaten in x-richtung gehen von bis Koordinaten in y-richtung gehen von bis Informieren Sie Sich in der GLUT-Dokumentation über die Funktionen zum Erstellen weiterer Grundkörper 10

11 und deren Parameter. Ergänzen Sie folgende Übersicht: Würfel Funktionsaufruf: Lage zum Koordinatenursprung: Parameter: Kegel Funktionsaufruf: Lage zum Koordinatenursprung: Parameter: Torus Funktionsaufruf: Lage zum Koordinatenursprung: Parameter: Dodekaeder Funktionsaufruf: Lage zum Koordinatenursprung: Größe: Oktaeder Funktionsaufruf: Lage zum Koordinatenursprung: Größe: Tetraeder Funktionsaufruf: Lage zum Koordinatenursprung: Größe: Ikosaeder Funktionsaufruf: Lage zum Koordinatenursprung: Größe: Teekanne 11

12 Funktionsaufruf: Lage zum Koordinatenursprung: Aufgabe 5 Parameter: Die verwendeten GLUT-Funktionen sind in zwei Versionen verfügbar: glutwire...(...) erzeugt ein Drahtgittermodell der Körper, glutsolid...(...) eine Variante mit definierten Seitenflächen. Die Solid-Versionen erzeugen momentan Silhouetten als graphische Ausgabe, da noch keine Shading-Funktionalität (Lichtquellen und Beleuchtung) implementiert ist. Aufgabe 5: Experimentieren Sie mit verschiedenen GLUT-Funktionen für geometrische Körper. 6 Transformationen Damit die Szene wie gewünscht auf dem Bildschirm erscheint, müssen die in der Viewing-Pipeline (Abbildung 7) enthaltenen Transformationen durchlaufen werden. Diese sind durch Standard-Werte voreingestellt, die allerdings nur eine sehr eingeschränkte Sicht auf die Objekte der Szene erlauben. Transformationen sind ebenfalls notwendig, um mehrere Objekte in einer Szene zu platzieren und gegeneinander auszurichten. Schließlich werden die internen Kameraparameter ebenfalls durch Transformationen modelliert und repräsentiert. Bei OpenGL werden Transformationen intern in zwei Transformationsmatrizen gespeichert, mit denen jeder Koordinatenwert vor der Darstellung multipliziert wird. Diese beiden Matrizen, die ModelView-Matrix und die Projection-Matrix können vom Programmierer durch spezielle Funktionen manipuliert werden. Um festzulegen, welche Matrix von den Funktionsaufrufen betroffen ist, wird in OpenGL der MatrixMode verwendet. Mit Hilfe der Funktion glmatrixmode(...) wird festgelegt, auf welche der beiden Transformationsmatrizen sich die folgenden Funktionen zur Manipulation von Transformationsmatrizen auswirken. Dabei sind folgende Parameter möglich: GL_MODELVIEW stellt die Modellierungstransformation ein. Alle folgenden Funktionen betreffen die ModelView-Matrix. GL_PROJECTION stellt die Projektionstransformation ein. Alle folgenden Funktionen betreffen die Projection-Matrix. MODELVIEW-Matrix PROJECTION-Matrix Modellierungs- Transformation Sicht- Transformation Projektions- Transformation Bildschirm- Transformation gltranslate glscale glrotate glulookat glfrustum glortho gluperspective glviewport Abbildung 7: Viewing-Pipeline und Transformationen in OpenGL Die Funktion glloadidentity() lädt die Einheitsmatrix in die jeweilige Transformationsmatrix und ist daher als Initialisierung nützlich. Jeder Eckpunkt v des darzustellenden Modells wird also zunächst mit der aktuell eingestellten ModelView-Matrix multipliziert und danach mit der aktuell eingestellten Projection-Matrix: v' = M P M MV v. Jede Funktion zur Matrixmanipulation (siehe Abbildung 7, grüne Rechtecke) wirkt sich dabei je nach MatrixMode auf die eingestellte aktuelle Matrix aus und multipliziert diese mit einer entsprechenden Transfor mationsmatrix, so daß eine zusammengesetzte Transformation entsteht. 6.1 Sichttransformation Die Funktion glulookat(...) dient dazu, die Kamera an eine bestimmte Position zu setzen und sie auszurichten. Die voreingestellte Standard-Position der Kamera befindet sich im Koordinatenursprung, die Blickrichtung entspricht der negativen z-achse und die Kamera ist so ausgerichtet, daß die y-achse nach oben weist. 12

13 Ein Aufruf der Funktion glulookat( posx, posy, posz, atx, aty, atz, upx, upy, upz) platziert die Kamera an die Position (posx, posy, posz). Die Kamera schaut auf den Punkt (atx, aty, atz) und der Vektor (upx, upy, upz) gibt eine Richtung an, die aus der Sicht der Kamera nach oben weist (siehe Abbildung 8). Programm 4 zeigt die Verwendung der Funktion glulookat(...). Um das Programm modular zu halten, wird die Kamera in einer separaten Funktion myinit() gesetzt, die an der entsprechenden Stelle in der main-funktion aufgerufen wird. Damit die Änderungen der Kamera besser sichtbar sind, wurde eine Teekanne als Modell in den Koordinatenursprung gesetzt. Die Kamera wird an die Position (0.4, 0.4, 0.4) gesetzt Abbildung 8: Parameter von glulookat und schaut auf den Koordinatenursprung (0, 0, 0). Die y-achse wird als Up-Vektor angegeben. Es muß noch beachtet werden, daß nur Objekte, die sich in einer Entfernung unter einer Einheit von der Kamera befinden, auch sichtbar sind. Dies läßt sich später mit den internen Kameraparametern ändern. Momentan wird dies durch entsprechende Größen der Objekte und eine entsprechende Postion der Kamera sichergestellt. In der Funktion my Init() wird zunächst die ModelView-Matrix als die zu verändernde Matrix festgelegt. Dann wird diese durch die Einheitsmatrix initialisiert und anschließend die Kamera positioniert. Programm 4: Anwendung der Funktion glulookat(...) #include <GL/glut.h> // globale Variablen int screenwidth = 600; // Breite des Anzeigefensters int screenheight = 600; // Hoehe des Anzeigefensters void mydisplay( void) glclear( GL_COLOR_BUFFER_BIT); glutwireteapot( 0.3); glutswapbuffers(); // Bildschirm (Fensterinhalt) loeschen // "Zeichnen" der Teekanne // "Anzeige" des Bildes (DoubleBuffering) void myinit( void) glmatrixmode( GL_MODELVIEW); // Einstellen der ModelView-Matrix glloadidentity(); // Initialisieren mit der Einheitsmatrix glulookat( 0.4, 0.4, 0.4, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); // Kamera positionieren int main( int argc, char** argv) glutinit( &argc, argv); glutinitdisplaymode (GLUT_DOUBLE GLUT_RGBA); glutinitwindowsize( screenwidth, screenheight); glutcreatewindow( "OpenGL"); glutdisplayfunc( mydisplay); myinit(); glutmainloop( ); exit( 0); // Initialisierung von GLUT // Einstellen des Anzeigemodus // Einstellen der Fenstergroesse // Fenster erzeugen // Setzen der Display-Funktion // Aufrufen der Initialisierungsfunktion // glut-hauptschleife Um in Java das gleiche Ergebnis zu erhalten, wird genauso vorgegangen. Die neue ViewerKlasse (JOGL0003) ist in Java 4 zu sehen. Hier wird die Methode init() verwendet und genauso wie die GLUT-Instanz zuvor eine Instanz von GLU erzeugt. Darin stehen alle GLU-Funktionen zur Verfügung. Wie bereits in den vorherigen Programmen werden auch hier Konstanten genutzt, die in den Klassen GL, GLU und GLUT zur Verfügung gestellt werden. Ihr Zugriff erfolgt auf der Klassenebene, also zum Beispiel GL.GL_COLOR_BUFFER_BIT oder GL.GL_MODELVIEW. Die init-methode wird beim ersten Initialisieren des OpenGL Kontextes aufgerufen. In ihr werden allgemeine Parameter zum Rendern der Szene eingestellt, die sich nicht verändern sollen. Dies können z. B. Voreinstellungen bezüglich der Lichter oder der Display Lists sein [ Von daher ist diese Methode eigentlich nicht der richtige Platz zum Einstellen von Kameraparametern, da es sich hier aber um die initialen Kameraeinstellungen handelt, können diese hier gesetzt werden. Sonst ist die Methode display() oder reshape() der bessere Ort. 13

14 Java 4: Kameraeinstellungen mit glulookat() public class JOGL0003 implements GLEventListener final GLUT glut = new GLUT(); final GLU glu = new GLU(); // GLU-Instanz holen public void display(glautodrawable drawable) GL gl = drawable.getgl(); gl.glclearcolor(0.0f, 0.0f, 0.0f, 0.0f); gl.glclear( GL.GL_COLOR_BUFFER_BIT); glut.glutwireteapot( 0.3); gl.glflush(); public void displaychanged( GLAutoDrawable drawable, boolean modechg, boolean devicechg) public void init(glautodrawable drawable) GL gl = drawable.getgl(); gl.glmatrixmode( GL.GL_MODELVIEW); // Einstellen der ModelView-Matrix gl.glloadidentity(); // Initialisieren mit der Einheitsmatrix glu.glulookat( 0.4, 0.4, 0.4, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); // Kamera positionieren public void reshape(glautodrawable drawable, int x, int y, int width, int height) Aufgabe 6 Aufgabe 6: Experimentieren Sie mit verschiedenen Kamerapositionen, d.h. ändern Sie die Parameter der Funktion glulookat(...) und beobachten Sie die Effekte auf die Ausgabe. Beachten Sie dabei, daß sich die Objekte maximal eine Einheit von der Kamera entfernt befinden dürfen, sonst werden sie teilweise oder ganz abgeschnitten. 6.2 Modellierungstransformation(en) Um Objekte an sich zu bewegen, bietet OpenGL die Standard-Transformationen Translation, Rotation und Skalierung an. Bei einem Aufruf einer der entsprechenden Funktionen wird die aktuelle Transformationsmatrix (in den meisten Fällen wird dies die ModelView-Matrix sein) mit einer der zu konstruierenden Transformation entsprechenden Matrix multipliziert und diese zusammengesetzte Matrix wird als neue aktuelle Transformationsma trix verwendet, sei also T die auszuführende Transformation (Skalierung, Rotation, Translation,...) und M MV die aktuelle ModelView-Matrix, dann ist nach dem Ausführen der Transformation M' MV =M MV T. Das bedeutet auch, daß die aktuelle Transformationsmatrix solange bestehen bleibt, bis sie erneut verändert wird. Die einzelnen OpenGL-Funktionen für Transformationen existieren in verschiedenen Varianten, die sich durch den Datentyp der Parameter und daher im letzten Buchstaben des Namens unterscheiden (d für double und f für float): gltranslate*( x, y, z) multipliziert die aktuelle Transformationsmatrix mit einer Matrix, die eine Translation um den Vektor (x, y, z) beschreibt. glscale*( x, y, z) multipliziert die aktuelle Transformationsmatrix mit einer Matrix, die eine Skalierung um die Faktoren x, y und z beschreibt. glrotate*( angle, x, y, z) multipliziert die aktuelle Transformationsmatrix mit einer Matrix, die eine Rotation um die durch den Vektor (x, y, z) beschriebene Achse um den Winkel angle beschreibt. Der Winkel wird in Grad angegeben und die Rotation erfolgt in einem rechtshändigen Koordinatensystem, das bedeutet, wenn die Achse zum Betrachter zeigt, erfolgt die Rotation egegen den Uhrzeigersinn. Aufgrund der internen Ausführung der Matrixmultiplikation wird die zuletzt spezifizierte Transformation zuerst ausgeführt. Dies ist bei der Programmierung zu beachten, da die Matrixmultiplikation bekanntlich nicht kommutativ ist. Als Beispiel soll folgender Codeausschnitt dienen: glscalef( 2.0, 2.0, 2.0); glrotatef( 45.0, 0.0, 1.0, 0.0) 14

15 gltranslatef( 5.0, 1.0, -3.0); glutwirecube( 0.5); Der Würfel wird hier zuerst um den Vektor (5.0, 1.0, -3.0) verschoben, dann um die y-achse rotiert und dann mit dem Faktor 2 uniform skaliert. Die Transformationsmatrix setzt sich dann wie folgt zusammen: M' MV = M MV M Skalierung M Rotation M Translation. Dies bedeutet, jeder Eckpunkt P des Würfels wird auf die folgende Weise transformiert: P' = M MV M Skalierung M Rotation M Translation P. Aufgabe 7: Schreiben Sie ausgehend von Programm 4 ein OpenGL-Programm, das die Ausgabe in Abbildung 9 erzeugt. Dazu setzen Sie zunächst die Kamera auf die Position (0, 0, 1), ihre Blickrichtung auf den Ursprung und die y-achse als Up- Vektor. Zeichnen Sie dann eine Kugel mit dem Radius 0.1 im Ursprung. Folgende Objekte sollen dann nacheinander gezeichnet werden: ein Würfel mit der Kantenlänge 0.1 an der Position (0.25, 0.25, 0.0) ein weitere Würfel mit der Kantenlänge 0.1 an der Position (-0.25, 0.25, 0) eine Teekanne der Größe 0.1 an der Position (-0.25, -0.25, 0) sowie ein Torus mit den beiden Radien 0.05 und 0.1 an der Position (0.25, -0.25, 0) Abbildung 9: Zu erzeugende Ausgabe Transformationen Beachten Sie dabei, daß die aktuelle Transformationsmatrix wie eine Statusvariable funktioniert und fortgesetzte Transformationen die vorhergehenden Transformationen nicht wieder rückgängig machen. Das Beispiel in obiger Aufgabe läßt sich auf verschiedene Weise lösen. Einerseits können die Transformationen relativ zur Position der vorherigen Objekte angegeben werden. Das bedeutet, daß der zweite Würfel um den Vektor (-0.5, 0, 0) verschoben werden muß usw. Eine zweite Möglichkeit besteht darin, die entsprechenden Transformationen nach dem Zeichnen des Objektes wieder rückgängig zu machen und dann die neue Transformation relativ zum Koordinatenursprung anzugeben. Dies ist insbesondere bei komplexen Transformationen aufwendig und fehleranfällig, da die inverse Transformation immer explizit angegeben werden muß. OpenGL bietet hierfür Matrixstacks an, um den aktuellen Status der Transformationsmatrix zu sichern und später wieder herzustellen. Die Funktion glpushmatrix() speichert den Zustand der aktuellen Transformationsmatrix auf dem Stack und verändert dabei die aktuelle Transformationsmatrix nicht Die Funktion glpopmatrix() setzt die aktuelle Transformationsmatrix auf die Matrix, die an oberster Stelle auf dem Stack liegt und entfernt diese Matrix vom Stack. Programm 5 zeigt als Beispiel für den Einsatz der beiden Funktionen eine Variante der Lösung obiger Aufgabe. Die Koordinaten können nun direkt angegeben werden, ohne explizit eine inverse Transformation zu definieren und ohne die Transformationen relativ anzugeben. Die Verwendung von glpushmatrix() und glpopmatrix() ist überall angebracht, wo geometrische Modelle oder Animationen hierarchisch definiert werden. Wenn z. B. ein Auto modelliert werden soll, dann kann eine Radmutter und eine Felge in einem eigenen Koordinaten system modelliert werden. Die Modellierung des Autos erfolgt dann auf folgende Weise: Man modelliert das Chassis im Koordinatenursprung, bewegt sich zur Position des linken Vorderrades, modelliert die Felge, bewegt sich zur Position der ersten Radmutter, modelliert die Radmutter, bewegt sich zurück zur Position des Rades, bewegt sich zur Position der zweiten Radmutter, modelliert die Radmutter, bewegt sich zurück zur Position des Rades,..., bewegt sich zurück zum Ursprung, bewegt sich zur Position des rechten Vorderrades,... Mit der Verwendung von glpushmatrix() und glpopmatrix() kann diese Art der Modellierung sehr einfach durchgeführt werden. Die Anwendung der beiden Funktionen bei Animationen wird später noch beschrieben. Aufgabe 7 15

16 Programm 5: Beispiel für glpushmatrix() und glpopmatrix() nur die Display-Callback void mydisplay( void) glclear( GL_COLOR_BUFFER_BIT); glutwiresphere( 0.1, 10, 10); glpushmatrix(); gltranslatef( 0.25, 0.25, 0.0); glutwirecube( 0.1); glpopmatrix(); glpushmatrix(); gltranslatef( -0.25, 0.25, 0.0); glutwirecube( 0.1); glpopmatrix(); glpushmatrix(); gltranslatef( -0.25, -0.25, 0.0); glutwireteapot( 0.1); glpopmatrix(); glpushmatrix(); gltranslatef( 0.25, -0.25, 0.0); glutwiretorus( 0.05, 0.1, 20, 20); glpopmatrix(); glutswapbuffers(); // Bildschirm (Fensterinhalt) loeschen // "Anzeige" des Bildes (DoubleBuffering) Die JOGL-Lösung ist äquivalent. Die entsprechende display()-methode ist in Java 5 amgegeben. Java 5: Beispiel für glpushmatrix() und glpopmatrix() nur die display()-methode public void display( GLAutoDrawable drawable) GL gl = drawable.getgl(); gl.glclearcolor(0.0f, 0.0f, 0.0f, 0.0f); gl.glclear( GL.GL_COLOR_BUFFER_BIT); glut.glutwiresphere( 0.1f, 10, 10); gl.glpushmatrix(); gl.gltranslatef( 0.25f, 0.25f, 0.0f); glut.glutwirecube( 0.1f); gl.glpopmatrix(); gl.glpushmatrix(); gl.gltranslatef( -0.25f, 0.25f, 0.0f); glut.glutwirecube( 0.1f); gl.glpopmatrix(); gl.glpushmatrix(); gl.gltranslatef( -0.25f, -0.25f, 0.0f); glut.glutwireteapot( 0.1f); gl.glpopmatrix(); gl.glpushmatrix(); gl.gltranslatef( 0.25f, -0.25f, 0.0f); glut.glutwiretorus( 0.05f, 0.1f, 20, 20); gl.glpopmatrix(); gl.glflush(); Aufgabe 8 Aufgabe 8: Erstellen Sie ein Programm, in dem Sie einen Tisch (Platte und Beine jeweils transformierte glut SolidCube()) modellieren, indem die Beine relativ zur Tischplatte positioniert werden und zum Abschluß der gesamte Tisch mit einer Ecke in den Ursprung verschoben wird. Beachten Sie dabei die korrekte Verwendung von glpushmatrix() und glpopmatrix() sowie die Reihenfolge des auszuführenden Transformationen. 6.3 Projektionstransformation Die weiteren Transformationen bestimmen die internen Parameter der Kamera und werden auch in OpenGL getrennt von der Modellierungs- und Sichttransformation behandelt. Die Projektions- und die Bildschirmtransformation werden typischerweise durch die Projection-Matrix repräsentiert. Dies ist ebenfalls eine 4 4 Matrix, mit der die Koordinatenwerte der Eckpunkte multipliziert werden. Die Manipulation dieser Matrix über entsprechende Funktionen wird mittels glmatrixmode(gl_projection) eingeschaltet. Danach wirken alle Funktionen zur Manipulation einer Transformationsmatrix (also auch gltranslate*(...), glscale*(...), glrotate*(...) usw.) auf die Projection-Matrix. Bei der Programmierung ist darauf zu achten, welche der 16

17 beiden Matrizen gerade manipuliert wird. Der Matrix-Mode bleibt jeweils bis zum nächsten Aufruf der Funktion glmatrixmode(...) bestehen. Zum Einstellen der Kameraparameter bietet OpenGL spezielle Funktionen an: glortho( left, right, bottom, top, near, far) erzeugt einen Sichtkörper für eine Parallelprojektion. Dabei liegt die linke Begrenzungsebene des Sichtkörpers left Einheiten von der Sichtachse entfernt, die rechte Begrenzungsebene right, die obere top und die untere bottom Einheiten. Die near clipping plane is near Einheiten entlang der Sichtachse entfernt und die far clipping plane far Einheiten. Der Sichtkörper hat die Form eines Quaders mit jeweils paarweise parallelen Seitenflächen. glfrustum( left, right, bottom, top, near, far) erzeugt einen Sichtkörper für eine perspektivische Projektion. Dabei liegt die linke Begrenzungsebene des Sichtkörpers left Einheiten von der Sichtachse entfernt, die rechte Begrenzungsebene right, die obere top und die untere bottom Einheiten. Die near clipping plane is near Einheiten entlang der Sichtachse entfernt und die far clipping plane far Einheiten. gluperspective( fovy, aspect, near, far) spezifiziert ebenfalls einen Sichtkörper für eine perspektivische Projektion. Dabei gibt fovy den vertikalen Öffnungswinkel der Kamera in Grad an und aspect das Seitenverhältnis. Eine Angabe von 2.0 als aspect erzeugt beispielsweise einen Sichtkörper der doppelt so breit wie hoch ist. Die near clipping plane is near Einheiten entlang der Sichtachse entfernt und die far clipping plane far Einheiten. Abbildung 10: Parameter von glortho Abbildung 11: Parameter von glfrustum Abbildung 12: Parameter von gluperspective Ebenso wie die oben behandelten Funktionen zur Modell- und Sichttransformation wird intern die aktuelle Projection-Matrix mit den entsprechenden Matrizen multipliziert. Da aber typischerweise die Kameraparameter nur einmal eingestellt werden, spielt die Hintereinanderausführung der Funktionen zur Projektionstransformation weniger eine Rolle. Aufgabe 9: Wie müßten folgende Sichtkörper definiert werden? Geben Sie jeweils den Funktionsaufruf der entsprechenden OpenGL-Funktion und die zu übergebenden Parameter an. Sichtkörper einer Parallelprojektion mit einem 7 Einheiten breiten und 5 Einheiten hohen Ausgabebereich. Die Sichtachse der Kamera geht mittig durch diesen Bereich und alle Koordinaten, die zwischen 10 und 20 Einheiten von der Kamera entfernt sind, sollen dargestellt werden.... Sichtkörper einer perspektivischen Projektion mit einem 8 Einheiten breiten Ausgabebereich. Der Ausgabebereich soll ein Viertel so hoch sein wie breit und alle Koordinaten, die zwischen 1 und 100 Einheiten von der Kamera entfernt sind, sollen dargestellt werden.... Sichtkörper einer perspektivischen Projektion mit einem Ausgabebereich, der sich horizontal von -4 bis 10 erstreckt, vertikal halb so hoch ist und bei dem die Sichtachse vertikal mittig verläuft. Nur der kleine Bereich von Koordinaten zwischen 12 und 13 Einheiten entfernt vom Kamerastandpunkt soll dargestellt werden.... Aufgabe 9 17

18 6.4 Bildschirmtransformation Nach der Anwendung der aktuellen Projection-Matrix liegen intern Koordinaten im Bereich zwischen 0 und 1 vor. Die Funktion glviewport(...) bildet diese auf eine Bereich von Pixelkoordinaten auf dem Bildschirm ab. Der Punkt (-1, -1) wird dabei auf (xmin, ymin) abgebildet, der Punkt (1,1) auf (xmin+width, ymin+height). Dabei kann es unter Umständen zu einer Verzerrung kommen, wenn das Ausgabefenster bzw. der Ausgabebereich ein anderes Seitenverhältnis wie das Seitenverhältnis der Kamera hat. Aufgabe 10 Aufgabe Zusammenfassung Transformationen Die Transformationen in OpenGL, also Modellierungs-, Sicht-, Projektions- und Bildschirmtransformation sind eng miteinander verbunden und bilden eine Kette, durch die alle Eckpunkte des Modells transformiert werden. Um ein korrektes Bild zu erzeugen, sollte man sich das Zusammenspiel der Matrizen deutlich machen und ent sprechend ausnutzen. Wird die synthetische Kamera (also die Projektions- und die Sichttransformation) im Verlauf der Anwendung nicht verändert, bietet sich die Reshape-Callback als Platz zur Initialisierung der Matrizen an. Diese wird immer dann aufgerufen, wenn sich die Form, Größe oder Position des Ausgabefensters ändert. In dieser Callback sind auch Informationen über die Größe des Ausgabefensters verfügbar, so daß eine Anpassung des Kameramodells an die Größe und das Seitenverhältnis des Ausgabefensters erfolgen kann. In Programm 6 ist ein Beispiel für eine solche Reshape-Callback gegeben. Da die Kameraparameter jetzt in myreshape(...) geändert werden, müssen die Aufrufe der entsprechenden Funktion in der bisherigen Initialisierungsfunktion myinit() natürlich entfallen. In myreshape(...) wird zunächst die Projection-Matrix eingestellt und mit der Einheitsmatrix initialisiert. Danach erfolgt mit der Funktion glfrustum(...) die Konstruktion eines Sichtkörpers für eine perspektivische Projektion. Im Beispiel sind die linke und rechte Begrenzungsebene des Sichtkörpers jeweils eine Einheit vom Koordinatenursprung entfernt, ebenso die obere und untere Begrenzungsebene. Die near clipping plane liegt 1 Einheit vom Kamerastandpunkt entlang der Sichtachse gesehen entfernt, die far clipping plane 15 Einheiten. Da die Kamera bisher noch im Ursprung steht und keine weiteren Anpassungen vorgenommen wurden, wird der Punkt (-1, -1, -1) auf die linke untere Ecke des Ausgabefensters und der Punkt (1, 1, -1) auf die rechte obere Ecke des Ausgabefensters abgebildet. Die Kamera schaut standardmäßig in Richtung der negativen z-achse und da die near clipping plane eine Einheit vom Kamerastandpunkt entfernt ist, sind alle Punkte mit einer z-koordinate von -1 die vordersten Punkte, die in der Ausgabe dargestellt werden. Alle Punkte mit einer z-koordinate von -15 wären dann die am weitesten entfernten Punkte, die noch dargestellt werden würden (Entfernung der far clipping plane beträgt 15 Einheiten). Nach dem Einstellen des Sichtkörpers kann die Kamera platziert werden. Dazu wird auf die ModelView-Matrix gewechselt und diese mit der Einheitsmatrix initialisiert. Die Kamera wird dann an die Position (0, 0, 1) und ihre Blickrichtung auf den Ursprung gelegt. Dabei wird der gesamte oben definierte Sichtkörper in seiner Position und Ausrichtung nicht aber in seiner Größe verändert. Die near clipping plane liegt jetzt also eine Einheit vom Punkt (0, 0, 1) entfernt senkrecht zum Vektor (0, 0, -1), also in der yx-ebene. Diese Vorgehensweise, zunächst die Kamera, also den Sichtkörper, in Standardposition zu definieren und dann mittels glulookat(...) zu positionieren ist relativ eingängig und empfehlenswert. Schließlich wird in myreshape(...) der Ausgabebereich auf dem Bildschirmfenster festgelegt Dies erfolgt über glviewport(...). Im Beispiel wird der linke untere Punkt der Ausgabe auf den Fensterkoordinaten (0, 0) und der rechte obere Punkt auf den Fensterkoordinaten (w, h), also in der rechten oberen Fensterecke abgebildet. Das hat bei Größenänderungen des Fensters zur Folge, daß sich die Ausgabe ebenfalls in ihrer Größe und eventuell auch im Seitenverhältnis ändert. Aufgabe 10: Wie müßten die Parameter der Kamera in Programm 6 aussehen, wenn die Ausgabe im Fenster doppelt so groß erscheinen soll? Begründen Sie Ihre Antwort. Aufgabe 11: Experimentieren Sie mit verschiedenen Kameras und Sichtkörpern. Beobachten Sie dabei insbesondere die Effekte, die durch die Clipping planes entstehen. 18

19 Programm 6: Initialisierung der synthetischen Kamera in der Reshape-Callback #include <GL/glut.h> // globale Variablen int screenwidth = 600; // Breite des Anzeigefensters int screenheight = 600; // Hoehe des Anzeigefensters void mydisplay( void) glclear( GL_COLOR_BUFFER_BIT); glutwiresphere( 0.1, 10, 10); gltranslatef( 0.25, 0.25, 0.0); glutwirecube( 0.1); gltranslatef( -0.5, 0.0, 0.0); glutwirecube( 0.1); gltranslatef( 0.0, -0.5, 0.0); glutwireteapot( 0.1); gltranslatef( 0.5, 0.0, 0.0); glutwiretorus( 0.05, 0.1, 20, 20); glutswapbuffers(); void myreshape( GLsizei w, GLsizei h) glmatrixmode(gl_projection); glloadidentity(); glfrustum( -1, 1, -1, 1, 1.0, 15.0); // Bildschirm (Fensterinhalt) loeschen // "Anzeige" des Bildes (DoubleBuffering) // Projection-Matrix einstellen // Initialisieren mit der Einheitsmatrix // Sichtkörper der perspekt. Projektion glmatrixmode(gl_modelview); // ModelView-Matrix einstellen glloadidentity(); // Initialisieren mit der Einheitsmatrix glulookat( 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); // Kameraposition... glviewport(0, 0, w, h); // Bildschirmtransformation = Viewport int main( int argc, char** argv) glutinit( &argc, argv); glutinitdisplaymode (GLUT_DOUBLE GLUT_RGBA); glutinitwindowsize( screenwidth, screenheight); glutcreatewindow( "OpenGL"); glutdisplayfunc( mydisplay); glutreshapefunc( myreshape); glutmainloop( ); exit( 0); // Initialisierung von GLUT // Einstellen des Anzeigemodus // Einstellen der Fenstergroesse // Fenster erzeugen // Setzen der Display-Funktion // Setzen der Reshape-Callback // glut-hauptschleife Das gleiche Beispiel in Java findet sich in Java 6. Die Viewer-Klasse heißt jetzt JOGL0005 und ist noch einmal vollständig angegeben. Die einzelnen im Interface GLEventListener angebenen und damit zu implementierenden Methoden werden hier noch einmal zusammengefasst: void init( GLAutoDrawable drawable) wird direkt nach der Initialisierung des OpenGL- Kontextes einmalig aufgerufen. Hier sollten initiale Einstellungen (z.b. für Beleuchtung, etc.) vorgenommen werden. void display( GLAutoDrawable drawable) wird immer aufgerufen, wenn das Fenster (der OpenGL-Kontext) neu gezeichnet werden muß. Diese Methode entspricht damit der Display-Callback in C und sollte die gewünschte Ausgabe herstellen. void displaychanged( GLAutoDrawable drwb, boolean modechg, boolean devchg) wird immer dann aufgerufen, wenn sich der Displaymode oder das Ausgabegerät ändert für die hier angegebenen Beispiele wird diese Methode nicht verwendet. void reshape(glautodrawable drawable, int x, int y, int width, int height) wird aufgerufen direkt nach einer Änderung der Position oder der Größe des Fensters während des ersten Neuzeichnens des Inhaltes. Das schließt auch das erstmalige Öffnen des Fensters ein. Hier kön nen und sollten Änderungen des Viewports vorgenommen werden. Die Methode reshape ruft allerdings automatisch glviewport(x, y, width, height) auf, so daß (wenn man keinen anderen Viewport benötigt und wenn man die Kameraeinstellungen nicht ändert) dieser nicht neu gesetzt werden muß. 19