Geometrische Primitive in OpenGL

C A R L 

V O N 

O S S I E T Z K Y 

Geometrische Primitive und 

Hidden Surface Removal 

Johannes Diemke 

Übung im Modul OpenGL mit Java 

Wintersemester 2010/2011

Wiederholung 

Geometrische Primitive in OpenGL 

◮ Mit nur wenigen einfachen Bausteinen können hochkomplexe 

Strukturen erstellt werden 

Diese Bausteine werden in OpenGL Primitive genannt 

Es existieren genau 10 verschiedene Primitive 

gl.glColor3f(0.65f, 0.85f, 0.65f); 

gl.glBegin(GL.GL_TRIANGLES); 

gl.glVertex3f(-2.0f, -1.0f, 0.0f); 

gl.glVertex3f( 2.0f, -1.0f, 0.0f); 

gl.glVertex3f( 0.0f, 1.0f, 0.0f); 

gl.glEnd(); 

Johannes Diemke OpenGL mit Java WiSe 2010 / 2011 2/23

Geometrische Primitive 

Darstellung von Punkten 

◮ Der Parameter GL.GL_POINTS lässt OpenGL die Liste der Vertices als 

Punkte interpretieren 

Die Punktgröße kann mit der Methode glPointSize(float size) 

gesetzt werden 

Vorsicht! Nicht alle Punktgrößen werden unterstützt 

float range[] = new float[2]; 

gl.glGetFloatv(GL.GL_POINT_SIZE_RANGE, range, 0); 

float step[] = new float[1]; 

gl.glGetFloatv(GL.GL_POINT_SIZE_GRANULARITY, 

step, 0); 

gl.glPointSize(range[0]); 

gl.glBegin(GL.GL_POINTS); 



gl.glEnd(); 



Darstellung von Liniensegmenten 

◮ Der Parameter GL.GL_LINES lässt OpenGL jeweils zwei Vertices der 

Liste als Liniensegment interpretieren 

Die Linienbreite kann mit der Methode glLineWidth(float width) 

gesetzt werden 

Vorsicht! Nicht alle Linienbreiten werden unterstützt 

float range[] = new float[2]; 

gl.glGetFloatv(GL.GL_LINE_WIDTH_RANGE, range, 0); 

float step[] = new float[1]; 

gl.glGetFloatv(GL.GL_LINE_WIDTH_GRANULARITY, 

step, 0); 

gl.glLineWidth(range[1]); 

gl.glBegin(GL.GL_LINES); 



gl.glEnd(); 



Darstellung von Linienzügen 

◮ Der Parameter 

GL.GL_LINE_STRIP lässt OpenGL die Liste 

der Vertices als Linienzug interpretieren 

gl.glBegin(GL.GL_LINE_STRIP); 


gl.glVertex3f(50.0f, 50.0f, 0.0f); 


gl.glEnd(); 



Darstellung von geschlossenen Linienzügen 

◮ Der Parameter GL.GL_LINE_LOOP 

lässt OpenGL die Liste der Vertices 

als geschlossenen Linienzug interpretieren 

gl.glBegin(GL.GL_LINE_LOOP); 




gl.glEnd(); 



Darstellung von Dreiecken 

◮ Der Parameter GL.GL_TRIANGLES 

lässt OpenGL die Liste der 

Vertices als Dreiecke interpretieren 

gl.glBegin(GL.GL_TRIANGLES); 




gl.glVertex3f(-50.0f, 



gl.glEnd(); 

0.0f, 0.0f); 

50.0f, 0.0f); 

0.0f, 0.0f); 



Einschub: Polygon Winding 

◮ Die Kombination aus Ordnung und Richtung in der die Vertices 

angegeben werden wird als Winding bezeichnet 

◮ In der Standardeinstellung nimmt OpenGL Polygone mit einem 

CCW-Winding als front facing an 



Darstellung von Triangle Strips 

◮ Der Parameter GL.GL_TRIANGLE_STRIP lässt OpenGL die Liste der 

Vertices folgendermaßen als Gruppe verbundener Dreiecke 

interpretieren: 



Darstellung von Triangle Fans 

◮ Der Parameter GL.GL_TRIANGLE_FAN lässt OpenGL die Liste der Vertices 

folgendermaßen als Gruppe verbundener Dreiecke interpretieren: 



Color Shading Model 

◮ Farben werden pro Vertex festgelegt 

◮ Das Shading Model bestimmt, ob ein Polygon eine feste Farbe oder 

einen weichen Farbverlauf zwischen den für jeden Vertex 

festgelegten Farben besitzt 

◮ Es wird mit der Methode glShadeModel(int mode) gesetzt 

// enable flat shading 

gl.glShadeModel(GL.GL_FLAT); 

... 

// enable smooth shading 

gl.glShadeModel(GL.GL_SMOOTH); 



Depth Buffer 

◮ In der Standardeinstellung von OpenGL erscheint das zuletzt 

gezeichnete Objekt über einem zuvor gezeichneten Objekt 

◮ Dies gilt selbst, wenn das zuletzt gezeichnete Objekt räumlich hinter 

anderen liegt 

◮ Dies kann mit dem Depth Testing korrigiert werden → Depth Buffer 

// enable depth testing 

gl.glEnable(GL.GL_DEPTH_TEST); 

... 

// disable depth testing 

gl.glDisable(GL.GL_DEPTH_TEST); 



Depth Buffer (Forts.) 







◮ Der Depth Buffer muss vor jedem Rendern der Szene geleert werden 

public void display(GLAutoDrawable drawable) { 

GL2 gl = drawable.getGL().getGL2(); 

} 

// clear the color and depth buffer 

gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); 

gl.glLoadIdentity(); 

gl.glTranslatef(0.0f, 0.0f, -5.0f); 

... 


Hidden Surface Determination 

Back-Face Culling 

◮ Das Back-face Culling vermeidet das Zeichnen der Rückseiten von 

Polygonen 

◮ Das ist sinnvoll bei geschlossenen Körpern, die nur von außen 

betrachtet werden können 

◮ Ein Spezialfall tritt bei transparenten Objekten ein → blending 

// enable back-face culling 

gl.glEnable(GL.GL_CULL_FACE); 

... 

// disable back-face culling 

gl.glDisable(GL.GL_CULL_FACE); 


Hidden Surface Determination 

Back-Face Culling (Forts.) 

◮ Zum Bestimmen der Vorder- und Rückseite eines Polygons wird 

dessen Winding betrachtet 

Daher ist es wichtig das Polygon-Winding konsistent zu halten 

if(bCull) { 

// enable back-face culling 

gl.glEnable(GL.GL_CULL_FACE); 

} else { 

// disable back-face culling 

gl.glDisable(GL.GL_CULL_FACE); 

} 

◮ Die Festlegung der Vorder- und Rückseiten geschieht mit der 

Methode glFrontFace(int mode) 

// clockwise-wound polygons are front facing 

gl.glFrontFace(GL.GL_CW); 



Polygon Modes 

◮ Polygone müssen nicht grundsätzlich mit einer Farbe gefüllt sein 

◮ Mit der Methode glPolygonMode(int face, int mode) lässt sich festlegen, 

wie Polygone dargestellt werden sollen: 

GL.GL_POINT 

GL.GL_LINE 

GL.GL_FILL 

if(bOutline) { 

// draw polygons as outlines 

gl.glPolygonMode(GL.GL_BACK, GL_LINE) 

} else { 

// draw polygons solid 

gl.glPolygonMode(GL.GL_BACK, GL_FILL) 

} 



Konstruktionsregeln für Polygone 

◮ Alle Polygone müssen planar sein 

Die Vertices eines Polygons müssen immer in genau einer Ebene liegen 

Bei Dreiecken ist das überhaupt kein Problem 



Konstruktionsregeln für Polygone (Forts.) 

◮ Es darf keine Schnittpunkte zwischen den Kanten eines Polygons 

geben 

◮ Polygone müssen konvex sein: 

Jede Strecke zweier Punkte des Polygons liegt vollständig in ihm 


Grafikprogrammierung 

Ein etwas anderes Beispiel ... 


Literatur und Links 

 

 

 

 

Mason Woo, Jackie Neider, Tom Davis und Dave Shreiner 

OpenGL Programming Guide 

http://www.opengl.org/documentation/red book/ 

Randi J. Rost 

OpenGL Shading Language 

http://www.3dshaders.com/ 

Richard S. Wright und Michael Sweet 

OpenGL SuperBibel 

http://www.starstonesoftware.com/OpenGL/ 

Tomas Möller und Eric Haines 

Real-Time Rendering 

http://www.realtimerendering.com/ 


Literatur und Links 

 

 

 

 

Fletcher Dunn und Ian Parberry 

3D Math Primer For Graphics and Game Development 

http://www.gamemath.com/ 

Khronos Group 

OpenGL Homepage 

http://www.opengl.org/ 

Game Technology Group at Sun Microsystems 

JOGL API Project 

https://jogl.dev.java.net/ 

Fairlight und The Black Lotus 

Only one wish 

http://capped.tv/playeralt.php?vid=1215051083-1-0

Geometrische Primitive in OpenGL

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?