An Interactive Introduction to

OpenGL Programming
2
OpenGL and GLUT Overview
What is OpenGL & what can it do for me?
OpenGL in windowing systems
Why GLUT
A GLUT program template
3
What Is OpenGL?
Graphics rendering API
high-quality color images composed of geometric
and image primitives
window system independent
operating system independent
4
OpenGL Architecture
Display
List
Polynomial
Evaluator
Per Vertex
Operations &
Primitive
Assembly
Rasterization
Per Fragment
Operations
Frame
Buffer
Texture
Memory
CPU
Pixel
Operations
5
OpenGL as a Renderer
Geometric primitives
points, lines and polygons
Image Primitives
images and bitmaps
separate pipeline for images and geometry
linked through texture mapping
Rendering depends on state
colors, materials, light sources, etc.
6
Related APIs
AGL, GLX, WGL
glue between OpenGL and windowing systems
GLU (OpenGL Utility Library)
part of OpenGL
NURBS, tessellators, quadric shapes, etc.
GLUT (OpenGL Utility Toolkit)
portable windowing API
not officially part of OpenGL
7
OpenGL and Related APIs
GLUT
GLU
GL
GLX, AGL
or WGL
X, Win32, Mac O/S
software and/or hardware
application program
OpenGL Motif
widget or similar
8
Preliminaries
Headers Files
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
Libraries
Enumerated Types
OpenGL defines numerous types for compatibility
GLfloat, GLint, GLenum, etc.

9
GLUT Basics
Application Structure
Configure and open window
Initialize OpenGL state
Register input callback functions
render
resize
input: keyboard, mouse, etc.
Enter event processing loop
10
Sample Program
void main( int argc, char** argv )
{
int mode = GLUT_RGB|GLUT_DOUBLE;
glutInitDisplayMode( mode );
glutCreateWindow( argv[0] );
init();
glutDisplayFunc( display );
glutReshapeFunc( resize );
glutKeyboardFunc( key );
glutIdleFunc( idle );
glutMainLoop();
}
11
OpenGL Initialization
Set up whatever state youre going to use
void init( void )
{
glClearColor( 0.0, 0.0, 0.0, 1.0 );
glClearDepth( 1.0 );

glEnable( GL_LIGHT0 );
glEnable( GL_LIGHTING );
glEnable( GL_DEPTH_TEST );
}
12
GLUT Callback Functions
Routine to call when something happens
window resize or redraw
user input
animation
Register callbacks with GLUT
glutDisplayFunc( display );
glutIdleFunc( idle );
glutKeyboardFunc( keyboard );
13
Rendering Callback
Do all of your drawing here
glutDisplayFunc( display );
void display( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_TRIANGLE_STRIP );
glVertex3fv( v[0] );
glVertex3fv( v[1] );
glVertex3fv( v[2] );
glVertex3fv( v[3] );
glEnd();
glutSwapBuffers();
}
14
Idle Callbacks
Use for animation and continuous update
glutIdleFunc( idle );
void idle( void )
{
t += dt;
glutPostRedisplay();
}

15
User Input Callbacks
Process user input
glutKeyboardFunc( keyboard );
void keyboard( unsigned char key, int x, int y )
{
switch( key ) {
case q : case Q :
exit( EXIT_SUCCESS );
break;
case r : case R :
rotate = GL_TRUE;
glutPostRedisplay();
break;
}
}

16
Elementary Rendering
Geometric Primitives
Managing OpenGL State
OpenGL Buffers
17
OpenGL Geometric Primitives
All geometric primitives are specified by
vertices
GL_QUAD_STRIP
GL_POLYGON
GL_TRIANGLE_STRIP
GL_TRIANGLE_FAN
GL_POINTS
GL_LINES
GL_LINE_LOOP GL_LINE_STRIP
GL_TRIANGLES
GL_QUADS
18
Simple Example
void drawRhombus( GLfloat color[] )
{
glBegin( GL_QUADS );
glColor3fv( color );
glVertex2f( 0.0, 0.0 );
glVertex2f( 1.0, 0.0 );
glVertex2f( 1.5, 1.118 );
glVertex2f( 0.5, 1.118 );
glEnd();
}
19
OpenGL Command Formats
glVertex3fv( v )
Number of
components
2 - (x,y)
3 - (x,y,z)
4 - (x,y,z,w)
Data Type
b - byte
ub - unsigned byte
s - short
us - unsigned short
i - int
ui - unsigned int
f - float
d - double
Vector
omit v for
scalar form

glVertex2f( x, y )
20
Specifying Geometric Primitives
Primitives are specified using
glBegin( primType );
glEnd();
primType determines how vertices are combined
GLfloat red, green, blue;
Glfloat coords[3];
glBegin( primType );
for ( i = 0; i < nVerts; ++i ) {
glColor3f( red, green, blue );
glVertex3fv( coords );
}
glEnd();
21
OpenGL Color
Models
RGBA or Color Index
color index mode
Display 1
2
4
8
16
www
www
Red Green Blue
0
1
2
3
24
25
26
123 219 74
ww
ww
RGBA mode
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
22
Shapes Tutorial
23
Controlling Rendering
Appearance
From
Wireframe
to Texture
Mapped
24
OpenGLs State Machine
All rendering attributes are encapsulated in
the OpenGL State
rendering styles
shading
lighting
texture mapping
25
Manipulating OpenGL State
Appearance is controlled by current state
for each ( primitive to render ) {
update OpenGL state
render primitive
}
Manipulating vertex attributes is most
common way to manipulate state
glColor*() / glIndex*()
glNormal*()
glTexCoord*()
26
Controlling current state
Setting State
glPointSize( size );
glLineStipple( repeat, pattern );
glShadeModel( GL_SMOOTH );
Enabling Features
glEnable( GL_LIGHTING );
glDisable( GL_TEXTURE_2D );
27
Transformations in OpenGL
Modeling
Viewing
orient camera
projection
Animation
Map to screen
28
Camera Analogy
3D is just like taking a photograph (lots of
photographs!)
camera
tripod
model
viewing
volume
29
Camera Analogy and
Transformations
Projection transformations
adjust the lens of the camera
Viewing transformations
tripoddefine position and orientation of the viewing volume
in the world
Modeling transformations
moving the model
Viewport transformations
enlarge or reduce the physical photograph
30
Coordinate Systems and
Transformations
Steps in Forming an Image
specify geometry (world coordinates)
specify camera (camera coordinates)
project (window coordinates)
map to viewport (screen coordinates)
Each step uses transformations
Every transformation is equivalent to a change in
coordinate systems (frames)
31
Affine Transformations
Want transformations which preserve
geometry
lines, polygons, quadrics
Affine = line preserving
Rotation, translation, scaling
Projection
Concatenation (composition)
32
Homogeneous Coordinates
each vertex is a column vector





w is usually 1.0
all operations are matrix multiplications
directions (directed line segments) can be represented with w =
0.0

(
(
(
(

=
w
z
y
x
v

33
(
(
(
(

=
15 11 7 3
14 10 6 2
13 9 5 1
12 8 4 0
m m m m
m m m m
m m m m
m m m m
M
3D Transformations
A vertex is transformed by 4 x 4 matrices
all affine operations are matrix multiplications
all matrices are stored column-major in OpenGL
matrices are always post-multiplied
product of matrix and vector is
v

M
34
Specifying Transformations
Programmer has two styles of specifying
transformations
specify matrices (glLoadMatrix, glMultMatrix)
specify operation (glRotate, glOrtho)
Programmer does not have to remember the
exact matrices
check appendix of Red Book (Programming Guide)
35
Programming Transformations
Prior to rendering, view, locate, and orient:
eye/camera position
3D geometry
Manage the matrices
including matrix stack
Combine (composite) transformations
36
v
e
r
t
e
x
Modelview
Matrix
Projection
Matrix
Perspective
Division
Viewport
Transform
Modelview
Modelview
Projection
l
l
l
object
eye
clip
normalized
device
window
other calculations here
material color
shade model (flat)
polygon rendering mode
polygon culling
clipping
Transformation
Pipeline
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
37
Matrix Operations
Specify Current Matrix Stack
glMatrixMode( GL_MODELVIEW or GL_PROJECTION )
Other Matrix or Stack Operations
glLoadIdentity() glPushMatrix()
glPopMatrix()
Viewport
usually same as window size
viewport aspect ratio should be same as projection transformation
or resulting image may be distorted
glViewport( x, y, width, height )
38
Projection Transformation
Shape of viewing frustum
Perspective projection
gluPerspective( fovy, aspect, zNear, zFar )
glFrustum( left, right, bottom, top, zNear, zFar )
Orthographic parallel projection
glOrtho( left, right, bottom, top, zNear, zFar )
gluOrtho2D( left, right, bottom, top )
calls glOrtho with z values near zero
39
Applying Projection
Transformations
Typical use (orthographic projection)
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( left, right, bottom, top, zNear, zFar );
40
Viewing Transformations
Position the camera/eye in the scene
place the tripod down; aim camera
To fly through a scene
change viewing transformation and
redraw scene
gluLookAt( eye
x
, eye
y
, eye
z
,
aim
x
, aim
y
, aim
z
,
up
x
, up
y
, up
z
)
up vector determines unique orientation
careful of degenerate positions
tripod
41
Projection Tutorial
42
Modeling Transformations
Move object
glTranslate{fd}( x, y, z )
Rotate object around arbitrary axis
glRotate{fd}( angle, x, y, z )
angle is in degrees
Dilate (stretch or shrink) or mirror object
glScale{fd}( x, y, z )
( ) z y x
43
Transformation Tutorial
44
Connection: Viewing and
Modeling
Moving camera is equivalent to moving every
object in the world towards a stationary
camera
Viewing transformations are equivalent to
several modeling transformations
gluLookAt() has its own command
can make your own polar view or pilot view
45
Projection is left handed
Projection transformations (gluPerspective,
glOrtho) are left handed
think of zNear and zFar as distance from view
point
Everything else is right handed, including the
vertexes to be rendered
x
x
y
y
z+
z+
left handed right handed
46
Common Transformation Usage
3 examples of resize() routine
restate projection & viewing transformations
Usually called when window resized
Registered as callback for glutReshapeFunc()
47
resize(): Perspective &
LookAt
void resize( int w, int h )
{
glViewport( 0, 0, (GLsizei) w, (GLsizei) h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 65.0, (GLdouble) w / h,
1.0, 100.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( 0.0, 0.0, 5.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0 );
}
48
resize(): Perspective &
Translate
Same effect as previous LookAt
void resize( int w, int h )
{
glViewport( 0, 0, (GLsizei) w, (GLsizei) h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 65.0, (GLdouble) w/h,
1.0, 100.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0.0, 0.0, -5.0 );
}
49
resize(): Ortho (part 1)
void resize( int width, int height )
{
GLdouble aspect = (GLdouble) width / height;
GLdouble left = -2.5, right = 2.5;
GLdouble bottom = -2.5, top = 2.5;
glViewport( 0, 0, (GLsizei) w, (GLsizei) h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
continued
50
if ( aspect < 1.0 ) {
left /= aspect;
right /= aspect;
} else {
bottom *= aspect;
top *= aspect;
}
glOrtho( left, right, bottom, top, near, far );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
}
resize(): Ortho (part 2)
51
Compositing Modeling
Transformations
Problem 1: hierarchical objects
one position depends upon a previous position
robot arm or hand; sub-assemblies
Solution 1: moving local coordinate system
modeling transformations move coordinate system
post-multiply column-major matrices
OpenGL post-multiplies matrices
52
Compositing Modeling
Transformations
Problem 2: objects move relative to absolute world
origin
my object rotates around the wrong origin
make it spin around its center or something else
Solution 2: fixed coordinate system
modeling transformations move objects around fixed
coordinate system
pre-multiply column-major matrices
OpenGL post-multiplies matrices
must reverse order of operations to achieve desired effect
53
Additional Clipping Planes
At least 6 more clipping planes available
Good for cross-sections
Modelview matrix moves clipping plane
clipped
glEnable( GL_CLIP_PLANEi )
glClipPlane( GL_CLIP_PLANEi, GLdouble* coeff )
0 < + + + D Cz By Ax
54
Reversing Coordinate Projection
Screen space back to world space
glGetIntegerv( GL_VIEWPORT, GLint viewport[4] )
glGetDoublev( GL_MODELVIEW_MATRIX, GLdouble mvmatrix[16] )
glGetDoublev( GL_PROJECTION_MATRIX,
GLdouble projmatrix[16] )
gluUnProject( GLdouble winx, winy, winz,
mvmatrix[16], projmatrix[16],
GLint viewport[4],
GLdouble *objx, *objy, *objz )
gluProject goes from world to screen
space
55
Animation and Depth Buffering
Discuss double buffering and animation
Discuss hidden surface removal using the
depth buffer
56
Double
Buffering
1
2
4
8
16
1
2
4
8
16
Front
Buffer
Back
Buffer
Display
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
57
Animation Using Double
Buffering
Request a double buffered color buffer
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );
Clear color buffer
glClear( GL_COLOR_BUFFER_BIT );
Render scene
Request swap of front and back buffers
glutSwapBuffers();
Repeat steps 2 - 4 for animation
58
Depth Buffering and
Hidden Surface Removal
1
2
4
8
16
1
2
4
8
16
Color
Buffer
Depth
Buffer
Display
59
Depth Buffering Using OpenGL
Request a depth buffer
glutInitDisplayMode( GLUT_RGB |
GLUT_DOUBLE | GLUT_DEPTH );
Enable depth buffering
glEnable( GL_DEPTH_TEST );
Clear color and depth buffers
glClear( GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT );
Render scene
Swap color buffers
60
An Updated Program Template
void main( int argc, char** argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB |
GLUT_DOUBLE | GLUT_DEPTH );
glutCreateWindow( Tetrahedron );
init();
glutIdleFunc( idle );
glutDisplayFunc( display );
glutMainLoop();
}
61
An Updated Program Template
(cont.)

void init( void )
{
glClearColor( 0.0, 0.0, 1.0, 1.0 );
}


void idle( void )
{
glutPostRedisplay();
}
62
An Updated Program Template
(cont.)
void drawScene( void )
{
GLfloat vertices[] = { };
GLfloat colors[] = { };
glClear( GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT );
glBegin( GL_TRIANGLE_STRIP );
/* calls to glColor*() and glVertex*() */
glEnd();
glutSwapBuffers();
}
63
Lighting Principles
Lighting simulates how objects reflect light
material composition of object
lights color and position
global lighting parameters
ambient light
two sided lighting
available in both color index
and RGBA mode
64
How OpenGL Simulates Lights
Phong lighting model
Computed at vertices
Lighting contributors
Surface material properties
Light properties
Lighting model properties
65
Surface
Normals
Normals define how a surface reflects light
glNormal3f( x, y, z )
Current normal is used to compute vertexs color
Use unit normals for proper lighting
scaling affects a normals length
glEnable( GL_NORMALIZE )
or
glEnable( GL_RESCALE_NORMAL )
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
66
Material Properties
Define the surface properties of a primitive
glMaterialfv( face, property, value );





separate materials for front and back
GL_DIFFUSE Base color
GL_SPECULAR Highlight Color
GL_AMBIENT Low-light Color
GL_EMISSION Glow Color
GL_SHININESS Surface Smoothness
67
Light Properties
glLightfv( light, property, value );
light specifies which light
multiple lights, starting with GL_LIGHT0
glGetIntegerv( GL_MAX_LIGHTS, &n );
properties
colors
position and type
attenuation
68
Light Sources (cont.)
Light color properties
GL_AMBIENT
GL_DIFFUSE
GL_SPECULAR
69
Types of Lights
OpenGL supports two types of Lights
Local (Point) light sources
Infinite (Directional) light sources
Type of light controlled by w coordinate

( )
( )
w
z
w
y
w
x
w
z y x w
at positioned Light Local
along directed Light Infinite
0
0
=
=
70
Turning on the Lights
Flip each lights switch
glEnable( GL_LIGHTn );
Turn on the power
glEnable( GL_LIGHTING );
71
Light Material Tutorial
72
Controlling a Lights Position
Modelview matrix affects a lights position
Different effects based on when position is
specified
eye coordinates
world coordinates
model coordinates
Push and pop matrices to uniquely control a lights
position
73
Light Position Tutorial
74
Advanced Lighting Features
Spotlights
localize lighting affects
GL_SPOT_DIRECTION
GL_SPOT_CUTOFF
GL_SPOT_EXPONENT


75
Advanced Lighting Features
Light attenuation
decrease light intensity with distance
GL_CONSTANT_ATTENUATION
GL_LINEAR_ATTENUATION
GL_QUADRATIC_ATTENUATION

2
1
d k d k k
f
q l c
i
+ +
=
76
Light Model Properties
glLightModelfv( property, value );
Enabling two sided lighting
GL_LIGHT_MODEL_TWO_SIDE
Global ambient color
GL_LIGHT_MODEL_AMBIENT
Local viewer mode
GL_LIGHT_MODEL_LOCAL_VIEWER
Separate specular color
GL_LIGHT_MODEL_COLOR_CONTROL
77
Tips for Better Lighting
Recall lighting computed only at vertices
model tessellation heavily affects lighting results
better results but more geometry to process
Use a single infinite light for fastest lighting
minimal computation per vertex
78
Imaging and Raster Primitives
Describe OpenGLs raster primitives:
bitmaps and image rectangles
Demonstrate how to get OpenGL to read and
render pixel rectangles
79
Pixel-based primitives
Bitmaps
2D array of bit masks for pixels
update pixel color based on current color
Images
2D array of pixel color information
complete color information for each pixel
OpenGL doesnt understand image formats
Frame
Buffer
Rasterization
(including
Pixel Zoom)
Per Fragment
Operations
TextureM
emory
Pixel-Transfer
Operations
(and Pixel Map)
CPU
Pixel
Storage
Modes
glReadPixels(), glCopyPixels()
glBitmap(), glDrawPixels()
glCopyTex*Image();
Pixel Pipeline
Programmable pixel storage
and transfer operations
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
81
Positioning Image Primitives
glRasterPos3f( x, y, z )
raster position transformed like geometry
discarded if raster position
is outside of viewport
may need to fine tune
viewport for desired
results
Raster Position
82
Rendering Bitmaps
glBitmap( width, height, xorig, yorig, xmove,
ymove, bitmap )
render bitmap in current color
at
advance raster position by
after
rendering


( ) yorig y xorig x
( ) ymove xmove
width
xorig
yorig
xmove
83
Rendering Fonts using Bitmaps
OpenGL uses bitmaps for font rendering
each character is stored in a display list containing
a bitmap
window system specific routines to access system
fonts
glXUseXFont()
wglUseFontBitmaps()

84
Rendering Images
glDrawPixels( width, height, format, type,
pixels )
render pixels with lower left of
image at current raster position
numerous formats and data types
for specifying storage in memory
best performance by using format and type that
matches hardware

85
Reading Pixels
glReadPixels( x, y, width, height, format,
type, pixels )
read pixels from specified (x,y) position in
framebuffer
pixels automatically converted from framebuffer
format into requested format and type
Framebuffer pixel copy
glCopyPixels( x, y, width, height, type )
86
Raster
Position
glPixelZoom(1.0, -1.0);
Pixel Zoom
glPixelZoom( x, y )
expand, shrink or reflect pixels
around current raster position
fractional zoom supported

87
Storage and Transfer Modes
Storage modes control accessing memory
byte alignment in host memory
extracting a subimage
Transfer modes allow modify pixel values
scale and bias pixel component values
replace colors using pixel maps
88
Apply a 1D, 2D, or 3D image to geometric
primitives
Uses of Texturing
simulating materials
reducing geometric complexity
image warping
reflections
Texture
Mapping
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
89
Texture Mapping
s
t
x
y
z
image
geometry
screen
90
Texture Mapping and the
OpenGL Pipeline
geometry pipeline vertices
pixel pipeline
image
rasterizer
Images and geometry flow through separate
pipelines that join at the rasterizer
complex textures do not affect geometric
complexity
91
Texture Example
The texture (below) is a
256 x 256 image that has been
mapped to a rectangular
polygon which is viewed in
perspective

92
Applying Textures I
Three steps
specify texture
read or generate image
assign to texture
enable texturing
assign texture coordinates to vertices
specify texture parameters
wrapping, filtering
93
Applying Textures II
specify textures in texture objects
set texture filter
set texture function
set texture wrap mode
set optional perspective correction hint
bind texture object
enable texturing
supply texture coordinates for vertex
coordinates can also be generated
94
Texture Objects
Like display lists for texture images
one image per texture object
may be shared by several graphics contexts
Generate texture names
glGenTextures( n, *texIds );
95
Texture Objects (cont.)
Create texture objects with texture data and
state
glBindTexture( target, id );
Bind textures before using
glBindTexture( target, id );

96
Define a texture image from an array of
texels in CPU memory
glTexImage2D( target, level, components,
w, h, border, format, type, *texels );
dimensions of image must be powers of 2
Texel colors are processed by pixel
pipeline
pixel scales, biases and lookups can be
done
Specify Texture
Image
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
97
Converting A Texture Image
If dimensions of image are not power of 2
gluScaleImage( format, w_in, h_in,
type_in, *data_in, w_out, h_out,
type_out, *data_out );
*_in is for source image
*_out is for destination image
Image interpolated and filtered during scaling
98
Specifying a Texture:
Other Methods
Use frame buffer as source of texture image
uses current buffer as source image
glCopyTexImage1D(...)
glCopyTexImage2D(...)
Modify part of a defined texture
glTexSubImage1D(...)
glTexSubImage2D(...)
glTexSubImage3D(...)
Do both with glCopyTexSubImage2D(...), etc.
99
Based on parametric texture coordinates
glTexCoord*() specified at each vertex

s
t
1, 1
0, 1
0, 0 1, 0
(s, t) = (0.2, 0.8)
(0.4, 0.2)
(0.8, 0.4)
A
B C
a
b
c
Texture Space Object Space
Mapping a
Texture
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
100
Generating Texture Coordinates
Automatically generate texture coords
glTexGen{ifd}[v]()
specify a plane
generate texture coordinates based upon distance from
plane
generation modes
GL_OBJECT_LINEAR
GL_EYE_LINEAR
GL_SPHERE_MAP
0 = + + + D Cz By Ax
101
Tutorial: Texture
102
Filter Modes
minification or magnification
special mipmap minification filters
Wrap Modes
clamping or repeating
Texture Functions
how to mix primitives color with textures color
blend, modulate or replace texels

Texture Application Methods
103
Filter Modes
Texture Polygon
Magnification Minification
Polygon Texture
Example:
glTexParameteri( target, type, mode );

104
Mipmapped Textures
Mipmap allows for prefiltered texture maps of decreasing
resolutions
Lessens interpolation errors for smaller textured objects
Declare mipmap level during texture definition
glTexImage*D( GL_TEXTURE_*D, level, )
GLU mipmap builder routines
gluBuild*DMipmaps( )
OpenGL 1.2 introduces advanced LOD controls
105
Wrapping Mode
Example:
glTexParameteri( GL_TEXTURE_2D,
GL_TEXTURE_WRAP_S, GL_CLAMP )
glTexParameteri( GL_TEXTURE_2D,
GL_TEXTURE_WRAP_T, GL_REPEAT )
texture
s
t
GL_CLAMP
wrapping
GL_REPEAT
wrapping
106
Texture Functions
Controls how texture is applied
glTexEnv{fi}[v]( GL_TEXTURE_ENV, prop, param )
GL_TEXTURE_ENV_MODE modes
GL_MODULATE
GL_BLEND
GL_REPLACE
Set blend color with GL_TEXTURE_ENV_COLOR
107
Perspective Correction Hint
Texture coordinate and color interpolation
either linearly in screen space
or using depth/perspective values (slower)
Noticeable for polygons on edge
glHint( GL_PERSPECTIVE_CORRECTION_HINT, hint )
where hint is one of
GL_DONT_CARE
GL_NICEST
GL_FASTEST
108
Is There Room for a Texture?
Query largest dimension of texture image
typically largest square texture
doesnt consider internal format size
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &size )
Texture proxy
will memory accommodate requested texture size?
no image specified; placeholder
if texture wont fit, texture state variables set to 0
doesnt know about other textures
only considers whether this one texture will fit all of memory
109
Texture Residency
Working set of textures
high-performance, usually hardware accelerated
textures must be in texture objects
a texture in the working set is resident
for residency of current texture, check GL_TEXTURE_RESIDENT
state
If too many textures, not all are resident
can set priority to have some kicked out first
establish 0.0 to 1.0 priorities for texture objects
110
Advanced OpenGL Topics
Display Lists and Vertex Arrays
Alpha Blending and Antialiasing
Using the Accumulation Buffer
Fog
Feedback & Selection
Fragment Tests and Operations
Using the Stencil Buffer
111
Immediate Mode versus Display
Listed Rendering
Immediate Mode Graphics
Primitives are sent to pipeline and display right away
No memory of graphical entities
Display Listed Graphics
Primitives placed in display lists
Display lists kept on graphics server
Can be redisplayed with different state
Can be shared among OpenGL graphics contexts
112
Immediate Mode versus
Display Lists
Immediate Mode
Display Listed
Display
List
Polynomial
Evaluator
Per Vertex
Operations &
Primitive
Assembly
Rasterization
Per Fragment
Operations
Texture
Memor
y
CPU
Pixel
Operations
Frame
Buffer
113
Display Lists
Creating a display list
GLuint id;
void init( void )
{
id = glGenLists( 1 );
glNewList( id, GL_COMPILE );
/* other OpenGL routines */
glEndList();
}
Call a created list
void display( void )
{
glCallList( id );
}
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
114
Display Lists
Not all OpenGL routines can be stored in display
lists
State changes persist, even after a display list is
finished
Display lists can call other display lists
Display lists are not editable, but you can fake it
make a list (A) which calls other lists (B, C, and D)
delete and replace B, C, and D, as needed
115
Display Lists and Hierarchy
Consider model of a car
Create display list for chassis
Create display list for wheel
glNewList( CAR, GL_COMPILE );
glCallList( CHASSIS );
glTranslatef( );
glCallList( WHEEL );
glTranslatef( );
glCallList( WHEEL );

glEndList();
116
Advanced Primitives
Vertex Arrays
Bernstein Polynomial Evaluators
basis for GLU NURBS
NURBS (Non-Uniform Rational B-Splines)
GLU Quadric Objects
sphere
cylinder (or cone)
disk (circle)
117
Vertex
Arrays
Pass arrays of vertices, colors, etc. to
OpenGL in a large chunk
glVertexPointer( 3, GL_FLOAT, 0, coords )
glColorPointer( 4, GL_FLOAT, 0, colors )
glEnableClientState( GL_VERTEX_ARRAY )
glEnableClientState( GL_COLOR_ARRAY )
glDrawArrays( GL_TRIANGLE_STRIP, 0, numVerts );
All active arrays are used in rendering
Color
data
Vertex
data
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
118
Why use Display Lists or Vertex
Arrays?
May provide better performance than
immediate mode rendering
Display lists can be shared between multiple
OpenGL context
reduce memory usage for multi-context
applications
Vertex arrays may format data for better
memory access
119
Alpha: the 4
th
Color Component
Measure of Opacity
simulate translucent objects
glass, water, etc.
composite images
antialiasing
ignored if blending is not enabled
glEnable( GL_BLEND )
120
Blending
Combine pixels with whats in already
in the framebuffer
glBlendFunc( src, dst )
Framebuffer
Pixel
(dst)
Blending
Equation
Fragment
(src)
Blended
Pixel
p f r
C dst C src C

+ =
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
121
Multi-pass Rendering
Blending allows results from multiple
drawing passes to be combined together
enables more complex rendering algorithms
Example of bump-mapping
done with a multi-pass
OpenGL algorithm
122
Antialiasing
Removing the Jaggies
glEnable( mode )
GL_POINT_SMOOTH
GL_LINE_SMOOTH
GL_POLYGON_SMOOTH
alpha value computed by computing
sub-pixel coverage
available in both RGBA and colormap modes
123
Accumulation Buffer
Problems of compositing into color buffers
limited color resolution
clamping
loss of accuracy
Accumulation buffer acts as a floating point
color buffer
accumulate into accumulation buffer
transfer results to frame buffer
124
Accessing Accumulation Buffer
glAccum( op, value )
operations
within the accumulation buffer: GL_ADD, GL_MULT
from read buffer: GL_ACCUM, GL_LOAD
transfer back to write buffer: GL_RETURN
glAccum(GL_ACCUM, 0.5) multiplies each value
in write buffer by 0.5 and adds to accumulation
buffer
125
Accumulation Buffer
Applications
Compositing
Full Scene Antialiasing
Depth of Field
Filtering
Motion Blur
126
Full Scene Antialiasing :
Jittering the view
Each time we move the viewer, the image
shifts
Different aliasing artifacts in each image
Averaging images using accumulation
buffer averages out
these artifacts
127
Depth of Focus : Keeping a
Plane in Focus
Jitter the viewer to keep one plane
unchanged
Front Plane
Back Plane
Focal Plane
eye pos
1
eye pos
2

128
Fog
glFog{if}( property, value )
Depth Cueing
Specify a range for a linear fog ramp
GL_FOG_LINEAR
Environmental effects
Simulate more realistic fog
GL_FOG_EXP
GL_FOG_EXP2
129
Fog Tutorial
130
Feedback Mode
Transformed vertex data is returned to the
application, not rendered
useful to determine which primitives will make it
to the screen
Need to specify a feedback buffer
glFeedbackBuffer( size, type, buffer )
Select feedback mode for rendering
glRenderMode( GL_FEEDBACK )
131
Selection Mode
Method to determine which primitives are
inside the viewing volume
Need to set up a buffer to have results
returned to you
glSelectBuffer( size, buffer )
Select selection mode for rendering
glRenderMode( GL_SELECT )
132
Selection Mode (cont.)
To identify a primitive, give it a name
names are just integer values, not strings
Names are stack based
allows for hierarchies of primitives
Selection Name Routines
glLoadName( name ) glPushName( name )
glInitNames()
133
Picking
Picking is a special case of selection
Programming steps
restrict drawing to small region near pointer
use gluPickMatrix() on projection matrix
enter selection mode; re-render scene
primitives drawn near cursor cause hits
exit selection; analyze hit records
134
Picking Template
glutMouseFunc( pickMe );

void pickMe( int button, int state, int x, int y )
{
GLuint nameBuffer[256];
GLint hits;
GLint myViewport[4];
if (button != GLUT_LEFT_BUTTON ||
state != GLUT_DOWN) return;
glGetIntegerv( GL_VIEWPORT, myViewport );
glSelectBuffer( 256, nameBuffer );
(void) glRenderMode( GL_SELECT );
glInitNames();
135
Picking Template (cont.)
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
gluPickMatrix( (GLdouble) x, (GLdouble)
(myViewport[3]-y), 5.0, 5.0, myViewport );
/* gluPerspective or glOrtho or other projection */
glPushName( 1 );
/* draw something */
glLoadName( 2 );
/* draw something else continue */
136
Picking Template (cont.)
glMatrixMode( GL_PROJECTION );
glPopMatrix();
hits = glRenderMode( GL_RENDER );
/* process nameBuffer */
}
137
Picking Ideas
For OpenGL Picking Mechanism
only render what is pickable (e.g., dont clear screen!)
use an invisible filled rectangle, instead of text
if several primitives drawn in picking region, hard to use z
values to distinguish which primitive is on top
Alternatives to Standard Mechanism
color or stencil tricks (for example, use glReadPixels() to
obtain pixel value from back buffer)
138
Getting to the Framebuffer
Blending
Depth
Test
Dithering
Logical
Operations
Scissor
Test
Stencil
Test
Alpha
Test
F
r
a
g
m
e
n
t

F
r
a
m
e
b
u
f
f
e
r

139
Scissor Box
Additional Clipping Test
glScissor( x, y, w, h )
any fragments outside of box are clipped
useful for updating a small section of a viewport
affects glClear() operations
140
Alpha Test
Reject pixels based on their alpha value
glAlphaFunc( func, value )
glEnable( GL_ALPHA_TEST )
use alpha as a mask in textures
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
141
Stencil Buffer
Used to control drawing based on values in
the stencil buffer
Fragments that fail the stencil test are not drawn
Example: create a mask in stencil buffer and draw
only objects not in mask area
CPU DL
Poly.
Per
Vertex
Raster Frag FB
Pixel
Texture
142
Controlling Stencil Buffer
glStencilFunc( func, ref, mask )
compare value in buffer with ref using func
only applied for bits in mask which are 1
func is one of standard comparison functions
glStencilOp( fail, zfail, zpass )
Allows changes in stencil buffer based on passing
or failing stencil and depth tests: GL_KEEP,
GL_INCR
143
Creating a Mask
glInitDisplayMode( |GLUT_STENCIL| );
glEnable( GL_STENCIL_TEST );
glClearStencil( 0x0 );

glStencilFunc( GL_ALWAYS, 0x1, 0x1 );
glStencilOp( GL_REPLACE, GL_REPLACE,
GL_REPLACE );
draw mask
144
Using Stencil Mask
Draw objects where stencil = 1
glStencilFunc( GL_EQUAL, 0x1, 0x1 )
Draw objects where stencil != 1
glStencilFunc( GL_NOTEQUAL, 0x1, 0x1 );
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );

145
Dithering
glEnable( GL_DITHER )
Dither colors for better looking results
Used to simulate more available colors
146
Logical Operations on Pixels
Combine pixels using bitwise logical
operations
glLogicOp( mode )
Common modes
GL_XOR
GL_AND
147
Advanced Imaging
Imaging Subset
Only available if GL_ARB_imaging defined
Color matrix
Convolutions
Color tables
Histogram
MinMax
Advanced Blending
148
On-Line Resources
http://www.opengl.org
start here; up to date specification and lots of sample code
news:comp.graphics.api.opengl
http://www.sgi.com/software/opengl
http://www.mesa3d.org/
Brian Pauls Mesa 3D
http://www.cs.utah.edu/~narobins/opengl.html
very special thanks to Nate Robins for the OpenGL Tutors
source code for tutors available here!
149
Books
OpenGL Programming Guide, 3
rd
Edition
OpenGL Reference Manual, 3
rd
Edition
OpenGL Programming for the X Window
System
includes many GLUT examples
Interactive Computer Graphics: A top-down
approach with OpenGL, 2
nd
Edition