Prof. Stefan Schlechtweg-Dorendorf
Hochschule Anhalt (FH) K¨othen Fachbereich Informatik
Wintersemester 2010/2011
Teil II
CG-Programmierung und OpenGL
Inhalt
1. Computergraphik-Programmierung 2. OpenGL-API
Einf¨ uhrung
Dokummentation und Materialien Bibliotheken
Funktionen und Bezeichner Arbeitsweise
3. OpenGL-Beispiel
Uberblick ¨ Callbacks
Ereignisorientierte Architektur
Wo sind wir?
1. Computergraphik-Programmierung 2. OpenGL-API
3. OpenGL-Beispiel
Computergraphik-Programmierung
Anwendung Graphik-
system I/O-Ger¨ ate
Funktionsaufruf Output
Daten Input
Anwendung kommuniziert nicht direkt mit dem Graphiksubsystem verschiedene Bibliotheken
”dazwischengeschaltet“
OpenGL DirectX
Bibliotheken stellen High-Level-Schnittstelle f¨ur Datenaustausch und Funktionsaufrufe zur Verf¨ugung
Computergraphik-Programmierung
Betriebssystem Treiber / Systemprogramme
OpenGL andere API
Anwendung
Bibliotheken k¨onnen auch aufeinander aufbauen
Wo sind wir?
1. Computergraphik-Programmierung 2. OpenGL-API
Einf¨uhrung
Dokummentation und Materialien Bibliotheken
Funktionen und Bezeichner Arbeitsweise
3. OpenGL-Beispiel
OpenGL-API
Low-level Bibliothek f¨ur 2D- und 3D-Graphik Uberlegung bei Low-Level-Bibliotheken:¨
Vorrat an vordefinierten Primitiven. Open GL: relativ gering.
Auf OpenGL aufbauende Extensions erweitern den Vorrat.
Aufs¨atze: OpenInventor, Performer, GLUT, GLU-Bibliothek (OpenGL Utility Library)
Hardwareunabh¨angig (Mindestfunktionalit¨at auf allen Plattformen – evtl. in Software)
Unabh¨angig vom Fenstermanager (X11, Win32, Mac) Client-Server Unterst¨utzung (X11)
¨
ahnlich zu anderen Graphik-APIs (Java3D, DirectX, . . . )
OpenGL-API
einer der
”¨alteren“ Graphikstandards (erste Ver¨offentlichung 1992) seit dem zum Quasi-Standard aufgestiegen
st¨andige aber langwierige Weiterentwicklung Einbau programmierbaren Shadings
Unterst¨utzung mobiler Ger¨ate mit OpenGL ES Entwicklung von WebGL
vielf¨altige Aufs¨atze und Erweiterungen verf¨ugbar nicht Szenegraphen-basiert
Dokumentation und Materialien
Homepage:www.opengl.org Dokumentationen
Red Bookwww.glprogramming.com/red/
Blue Book
www.glprogramming.com/blue/
sehr gute Tutorials unter http://nehe.gamedev.net/
Weitere Bibliotheken
OpenGL selber stellt nur grudlegende Funktionen zur Verf¨ugung zus¨atzlich zwei weitere Bibliotheken:
GLU – OpenGL Utility Library vordefinierte Objekte
vereinfachte Betrachtungstransformationen bzw.
Kameradefinitionen GLUT – GL Utility Toolkit
erm¨oglicht Systemunabh¨angige OpenGL-Programme mehrere OpenGL-Fenster
Callback-Ereignisverarbeitung Idle-Routine, Timer
Funktionen f¨ur verschiedene Objekte Fensterverwaltung, Overlay
OpenGL-Funktionen
sieben große Gruppen von Funktionen:
Primitiv-Funktionen: definieren low-level-Objekte (Punkte, Liniensegmente, Pixel, Text, Oberfl¨achen, . . . ) Attribut-Funktionen: spezifizieren, wie die Primitive auf der
Ausgabe erscheinen (Farbe, Linienstil, Transparenz, Font, . . . )
Betrachtungs-Funktionen: definieren die synthetische Kamera (Position, Orientierung, Kameraparameter, . . . ) Transformations-Funktionen: zur Transformation von Objekten
(Rotation, Verschiebung, Skalierung, . . . )
Eingabe-Funktionen: f¨ur interaktive Applikationen zur Behandlung verschiedener Eingabeger¨ate (Tastatur, Maus, . . . ) Kontroll-Funktionen: zur Kommunikation mit dem Fenstersystem,
Initialisierung, Fehlerbehandlung, . . .
Abfrage-Funktionen: zur Abfrage eingestellter Parameter im API
OpenGL-Funktionen und Bezeichner
alle Bibliotheken definieren eine Reihe von Funktionen und Bezeichnern (Konstanten)
erkenntlich durch einen Pr¨afix
glbzw.GLf¨ur GL-Funktionen und -Bezeichner glubzw.GLUf¨ur GLU-Funktionen und -Bezeichner glutbzw.GLUTf¨ur GLUT-Funktionen und -Bezeichner ansonsten
”sprechende“ Namen
meist nach einem einheitlichen Schema aufgebaut gl<name><anz><typ>()
name– Funktionsname (Vertex, Color) anz– Anzahl der Argumente (2, 3, 4)
– Datentyp der Argumente (i, f, d, . . . )
OpenGL als Zustandsmaschine
Arbeitsweise von OpenGL durch Zust¨ande gesteuert Zust¨ande sind ¨ahnlich globaler Variablen
Operationen aufgrund von Zustandsvariablen interpretiert Beispiele:
Rendermodus Beleuchtungsmodell Zeichenattribute
einmal gesetzter Zustand gilt solange, bis er ge¨andert wird (auch
¨uber mehrere Aufrufe einer Funktion hinweg) Setzen und l¨oschen der Variablen:
void glEnable( GLenum attribut);
void glDisable( GLenum attribut);
Wo sind wir?
1. Computergraphik-Programmierung 2. OpenGL-API
3. OpenGL-Beispiel Uberblick¨ Callbacks
Ereignisorientierte Architektur Display-Callback
Zusammenfassung
OpenGL-Beispiel
# i n c l u d e " g l u t . h "
/* Z e i c h e n f u n k t i o n . H i e r s t e h e n d i e O p e n G L - B e f e h l e , d i e l e t z t e n d l i c h d i e D a r s t e l l u n g a u f d e m B i l d s c h i r m e r z e u g e n */
v o i d m y D i s p l a y( v o i d) {
g l C l e a r( G L _ C O L O R _ B U F F E R _ B I T); // B i l d s c h i r m ( F e n s t e r i n h a l t ) l o e s c h e n // H i e r k o m m e n d i e Z e i c h e n b e f e h l e h i n
g l u t S w a p B u f f e r s(); // " A n z e i g e " d e s B i l d e s ( D o u b l e B u f f e r i n g ) }
int m a i n( int argc, c h a r** a r g v) {
g l u t I n i t( &argc, a r g v); // I n i t i a l i s i e r u n g v o n G L U T
g l u t I n i t D i s p l a y M o d e( G L U T _ D O U B L E | G L U T _ R G B A); // E i n s t e l l e n d e s A n z e i g e m o d u s g l u t I n i t W i n d o w S i z e( 600 , 6 0 0 ) ; // E i n s t e l l e n d e r F e n s t e r g r o e s s e
g l u t C r e a t e W i n d o w( " O p e n G L " ); // F e n s t e r e r z e u g e n
g l u t D i s p l a y F u n c( m y D i s p l a y); // S e t z e n d e r D i s p l a y - F u n k t i o n
g l u t M a i n L o o p( ); // glut - H a u p t s c h l e i f e
e x i t( 0);
}
Die main-Funktion
initialisieren des GLUT-Toolkits Initialisieren des Anzeigemodus
Einstellen der Fenstergr¨oße (600 ×600) Fenster mit dem Titel
”OpenGL“ erzeugen Registrieren der Display-Callback
Eintreten in die GLUT-Hauptschleife
Callbacks
spezielle Funktionen, die von OpenGL (GLUT) zur¨uckgerufen werden
Programmierer stellt Funktion bereit, ruft sie aber nicht direkt auf Callbacks m¨ussen registriert (angemeldet) werden
Beispiel: Display-Callback
registriert mitglutDisplayFunc() Ubergeben den Funktionsnamen¨
immer dann aufgerufen, wenn die Ausgabe neu gezeichnet werden muss
Funktion muß vor Registrierung deklariert sein
g l u t D i s p l a y F u n c( m y D i s p l a y);
Callbacks
weitere wichtige Callbacks:
Reshape-Callback – aufgerufen, wenn sich Geometrie oder Position des Fensters ¨andert
Keyboard-Callback – aufgerufen, wenn eine Taste gedr¨uckt oder losgelassen wird
Mouse-Callback – aufgerufen beim Dr¨ucken und Loslassen der Maustasten
Motion-Callback – aufgerufen bei Mausbewegungen Idle-Callback – aufgerufen, wenn der Rechner Zeit hat Time-Callback – aufgerufen in bestimmbaren Zeitintervallen generelles Konzept: Ereignisorientierte Architektur
Ereignisorientierte Architektur
oft verwendet (heute fast ausschließlich) bei Fenstersystemen und anderen gr¨oßeren Systemen, insb. in der Computergraphik bei interaktiven Anwendungen
Eingabeger¨ate, die Anwendung, das Betriebssystem usw. erzeugen Ereignisse (events)
Ereignisse werden in einerEreigniswarteschlange(event queue) nach dem FIFO-Prinzip gespeichert
Anwendung arbeitet die Ereigniswarteschlange ab
Anwendung beinhaltet Funktionen, die auf unterschiedliche Ereignisse entsprechend reagieren
Programmierer ruft Funktionen nicht explizit auf sondern System erzeugt Funktionsaufruf
bei OpenGL: Callbacks
Die GLUT-Hauptschleife
Programm fragt st¨andig Ereigniswarteschlange ab
entsprechend dem Ereignistyp wird Callback aufgerufen (sofern eine registriert wurde)
sind alle typisierten Ereignisse abgearbeitet, wird die Idle-Callback aufgerufen
w h i l e (1) {
if (G r a p h i k w u r d e v e r ¨a n d e r t) {
c a l l D I S P L A Y C a l l b a c k F u n k t i o n;
}
if (F e n s t e r w u r d e v e r ¨a n d e r t) {
c a l l R E S H A P E C a l l b a c k F u n k t i o n;
}
if (T a s t a t u r b e t ¨a t i g t o d e r M a u s b e w e g t) { c a l l K E Y B O A R D/M O U S E C a l l b a c k F u n k t i o n;
Die Display-Callback
wichtigste Callback
erzeugt die graphische Ausgabe
aufgerufen, wann immer ein Neuzeichnen des Ausgabefensters notwendig ist
v o i d d i s p l a y(v o i d) {
g l C l e a r(G L _ C O L O R _ B U F F E R _ B I T);
// F u n k t i o n s a u f r u f e z u m E r z e u g e n d e r g r a p h i s c h e n A u s g a b e h i e r g l u t S w a p B u f f e r s();
}
glClear(...)l¨oscht den Ausgabebereich glutSwapBuffers(...)kennzeichnet
”Ende“ der Ausgabe und erzwingt damit eine Ausgabe auf dem Ger¨at (auch mit
Die Display-Callback
Erzeugen graphischer Ausgaben:
direkte zweidimensionale Ausgabe auf dem Bildschirm (nicht mit OpenGL – ger¨ateabh¨angig)
”Modellieren“ zwei- oder dreidimensionaler Objekte durch Angabe der Geometrie und Topologie (folgt in Teil III)
Attributieren der erzeugten Geometrie Einstellen der virtuellen Kamera Ausgabe
zun¨achst: Verwenden vordefinierter Geometrien und einer Standardansicht
v o i d d i s p l a y(v o i d) {
Die Display-Callback
glClearColor( red, green, blue, alpha)setzt die Hintergrundfarbe als RGBα-Tupel
glClear(...)l¨oscht den Hintergrund mit der spezifizierten Hintergrundfarbe
glutWireSphere( radius, slices, stacks) vordefinierte Geometrie aus der GLUT-Library Drahtgitterkugel im Koordinatenursprung radius= Radius der Kugel
slices= Anzahl der
”L¨angengrade“
stacks= Anzahl der
”Breitengrade“
Standard-Koordinatensystem
OpenGL nutzt ein flexibles System der Koordinatentransforma- tionen, um die genaue Ansicht zu bestimmen – folgt im Teil III
vordefinierte
Standardansicht ohne weitere Einstellungen im Prinzip
Paralleprojektion auf die xy-Ebene
1
0 1
OpenGL-Beispiel
# i n c l u d e " g l u t . h "
/* Z e i c h e n f u n k t i o n . H i e r s t e h e n d i e O p e n G L - B e f e h l e , d i e l e t z t e n d l i c h d i e D a r s t e l l u n g a u f d e m B i l d s c h i r m e r z e u g e n */
v o i d m y D i s p l a y( v o i d) {
g l C l e a r C o l o r( 0.0 , 0.0 , 1.0 , 0 . 0 ) ; // b l a u e r H i n t e r g r u n d
g l C l e a r( G L _ C O L O R _ B U F F E R _ B I T); // B i l d s c h i r m ( F e n s t e r i n h a l t ) l o e s c h e n
g l u t W i r e S p h e r e( 0.5 , 10 , 1 0 ) ; // K u g e l
g l u t S w a p B u f f e r s(); // " A n z e i g e " d e s B i l d e s ( D o u b l e B u f f e r i n g ) }
int m a i n( int argc, c h a r** a r g v) {
g l u t I n i t( &argc, a r g v); // I n i t i a l i s i e r u n g v o n G L U T
g l u t I n i t D i s p l a y M o d e( G L U T _ D O U B L E | G L U T _ R G B A); // E i n s t e l l e n d e s A n z e i g e m o d u s g l u t I n i t W i n d o w S i z e( 600 , 6 0 0 ) ; // E i n s t e l l e n d e r F e n s t e r g r o e s s e
g l u t C r e a t e W i n d o w( " O p e n G L " ); // F e n s t e r e r z e u g e n
g l u t D i s p l a y F u n c( m y D i s p l a y); // S e t z e n d e r D i s p l a y - F u n k t i o n
g l u t M a i n L o o p( ); // glut - H a u p t s c h l e i f e
e x i t( 0);
}
OpenGL-Beispiel
Erstes Beispiel Zweites Beispiel
