OpenGL

(1)

An Interactive Introduction to

OpenGL Programming

An Interactive Introduction to

OpenGL Programming

Dave Shreiner Ed Angel Vicki Shreiner

(2)

2

What You’ll See Today

•

_{General OpenGL Introduction}

•

_{Rendering Primitives}

•

_{Rendering Modes}

•

_Lighting

•

_{Texture Mapping}

•

_{Additional Rendering Attributes}

•

_Imaging

(3)

Goals for Today

•

_{Demonstrate enough OpenGL to write an}

interactive graphics program with

• _{custom modeled 3D objects or imagery} • _lighting

• _{texture mapping}

•

_{Introduce advanced topics for future}

(4)

OpenGL and GLUT Overview

(5)

OpenGL and GLUT Overview

•

_{What is OpenGL & what can it do for me?}

•

_{OpenGL in windowing systems}

•

_{Why GLUT}

(6)

6

What Is OpenGL?

•

_{Graphics rendering API}

• _{high-quality color images composed of geometric}

and image primitives

• _{window system independent} • _{operating system independent}

(7)

OpenGL Architecture

Display List Polynomial Evaluator Per Vertex Operations & Primitive Assembly

Rasterization Per Fragment_Operations Frame_Buffer

Texture Memory CPU

Pixel Operations

(8)

8

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}

(9)

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}

(10)

1

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

(11)

Preliminaries

•

_{Headers Files} • _{#include <GL/gl.h>} • #include <GL/glu.h> • _{#include <GL/glut.h>}

•

_Libraries

•

_{Enumerated Types}

• _{OpenGL defines numerous types for compatibility}

(12)

1

GLUT Basics

•

_{Application Structure}

• _{Configure and open window} • _{Initialize OpenGL state}

• _{Register input callback functions}

• render

• _resize

• _{input: keyboard, mouse, etc.}

(13)

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(); }

(14)

1

OpenGL Initialization

•

_{Set up whatever state you’re 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 ); }

(15)

GLUT Callback Functions

•

_{Routine to call when something happens}

• _{window resize or redraw} • _{user input}

• _animation

•

_{“Register” callbacks with GLUT}

glutDisplayFunc( display ); glutIdleFunc( idle );

(16)

1

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(); }

•

_{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(); }

(17)

Idle Callbacks

•

_{Use for animation and continuous update}

glutIdleFunc( idle );

void idle( void ) {

t += dt;

glutPostRedisplay(); }

(18)

1

User Input Callbacks

•

_{Process user input}

glutKeyboardFunc( keyboard );

void keyboard( char key, int x, int y ) { switch( key ) { case ‘q’ : case ‘Q’ : exit( EXIT_SUCCESS ); break; case ‘r’ : case ‘R’ : rotate = GL_TRUE; break; } }

•

_{Process user input}

glutKeyboardFunc( keyboard );

void keyboard( char key, int x, int y ) { switch( key ) { case ‘q’ : case ‘Q’ : exit( EXIT_SUCCESS ); break; case ‘r’ : case ‘R’ : rotate = GL_TRUE; break; } }

(19)

Elementary Rendering

(20)

2

Elementary Rendering

•

_{Geometric Primitives}

•

_{Managing OpenGL State}

•

_{OpenGL Buffers}

•

_{Geometric Primitives}

•

_{Managing OpenGL State}

•

_{OpenGL Buffers}

(21)

OpenGL Geometric Primitives

•

_{All geometric primitives are specified by}

vertices

•

_{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

(22)

2 2

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(); }

(23)

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 )

(24)

2

Specifying Geometric Primitives

•

_{Primitives are specified using}

glBegin( primType ); glEnd();

• _{primType determines how vertices are combined}

GLfloat red, greed, blue; Glfloat coords[3];

glBegin( primType );

for ( i = 0; i < nVerts; ++i ) { glColor3f( red, green, blue ); glVertex3fv( coords );

}

(25)

OpenGL Color

Models

OpenGL Color

Models

•

_{RGBA or Color Index}

•

_{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 CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Raster Frag_Frag FB_FB Pixel

Pixel

Texture Texture

(26)

2

Shapes Tutorial

(27)

Controlling Rendering

Appearance

Controlling Rendering

Appearance

•

_{From Wireframe to Texture Mapped}

(28)

2

OpenGL’s State Machine

•

_{All rendering attributes are encapsulated}

in the OpenGL State

• _{rendering styles}

• _shading

• _lighting

• _{texture mapping}

•

_{All rendering attributes are encapsulated}

in the OpenGL State

• _{rendering styles} • _shading

• _lighting

(29)

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*()

•

_{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*()

(30)

3

Controlling current state

•

_{Setting State}

glPointSize( size );

glLineStipple( repeat, pattern ); glShadeModel( GL_SMOOTH );

•

_{Enabling Features} glEnable( GL_LIGHTING ); glDisable( GL_TEXTURE_2D );

•

_{Setting State} glPointSize( size );

glLineStipple( repeat, pattern ); glShadeModel( GL_SMOOTH );

•

_{Enabling Features}

glEnable( GL_LIGHTING );

(31)

Transformations

(32)

3

Transformations in OpenGL

•

_Modeling

•

_Viewing • _{orient camera} • _projection

•

_Animation

•

_{Map to screen}

(33)

Camera Analogy

•

_{3D is just like taking a photograph (lots of}

photographs!)

camera

tripod model

viewing volume

(34)

3

Camera Analogy and

Transformations

Camera Analogy and

Transformations

•

_{Projection transformations}

• _{adjust the lens of the camera}

•

_{Viewing transformations}

• _{tripod–define position and orientation of the viewing}

volume in the world

•

_{Modeling transformations}

• _{moving the model}

•

_{Viewport transformations}

(35)

Coordinate Systems and

Transformations

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}

(36)

3

Affine Transformations

•

_{Want transformations which preserve}

geometry

• _{lines, polygons, quadrics}

•

_{Affine = line preserving}

• _{Rotation, translation, scaling} • _Projection

(37)

3

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

(38)

3

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 Mv

             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

(39)

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

(40)

4

Programming Transformations

•

_{Prior to rendering, view, locate, and orient:}

• _{eye/camera position} • _{3D geometry}

•

_{Manage the matrices}

• _{including matrix stack}

(41)

v e r t e x Modelview Matrix Projection Matrix Perspective Division Viewport Transform Modelview Modelview Projection l l l object ey e clip normalized device window

• other calculations here

• material è color

• shade model (flat)

• polygon rendering mode

• polygon culling

• clipping

Transformation

Pipeline

Transformation

Pipeline

CPUCPU DLDL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(42)

4

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 )

•

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

(43)

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

•

_{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 )

(44)

4

Applying Projection

Transformations

Applying Projection

Transformations

•

_{Typical use (orthographic projection)}

glMatrixMode( GL_PROJECTION ); glLoadIdentity();

glOrtho( left, right, bottom, top, zNear, zFar );

•

_{Typical use (orthographic projection)}

glMatrixMode( GL_PROJECTION ); glLoadIdentity();

(45)

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}

(46)

4

Projection Tutorial

(47)

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 )

(48)

4

Transformation Tutorial

(49)

Connection: Viewing and

Modeling

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

(50)

5

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 _z+ y

z+

(51)

Common Transformation Usage

•

_{3 examples of}_resize()_routine

• _{restate projection & viewing transformations}

•

_{Usually called when window resized}

•

_{Registered as callback for}_{glutReshapeFunc}()

•

_{3 examples of}_resize()_routine

• _{restate projection & viewing transformations}

•

_{Usually called when window resized}

(52)

5

resize(): Perspective &

LookAt

resize(): Perspective &

LookAt

void resize( int w, int h ) {

glViewport( 0, 0, (GLsizei) w, (GLsizei) h ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluPerspective( 65.0, (GLfloat) 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 ); }

(53)

resize(): Perspective &

Translate

resize(): Perspective &

Translate

•

_{Same effect as previous LookAt}

glViewport( 0, 0, (GLsizei) w, (GLsizei) h ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluPerspective( 65.0, (GLfloat) w/h, 1.0, 100.0 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef( 0.0, 0.0, -5.0 ); }

•

_{Same effect as previous LookAt}

glViewport( 0, 0, (GLsizei) w, (GLsizei) h ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluPerspective( 65.0, (GLfloat) w/h, 1.0, 100.0 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef( 0.0, 0.0, -5.0 ); }

(54)

5

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 …

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();

(55)

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)

(56)

5

Compositing Modeling

Transformations

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}

(57)

Compositing Modeling

Transformations

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}

(58)

5

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     By Cz D Ax

(59)

Reversing Coordinate

Projection

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}

(60)

Animation and Depth Buffering

(61)

Animation and Depth Buffering

•

_{Discuss double buffering and animation}

•

_{Discuss hidden surface removal using the}

(62)

6

Double

Buffering

Double

Buffering

1 2 4 8 16 1 2 4 8 16 Front Buffer Back Buffer Display CPU CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(63)

Animation Using Double

Buffering

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

 Request a double buffered color buffer

GLUT_DOUBLE );

 Clear color buffer

glClear( GL_COLOR_BUFFER_BIT );

 Render scene

 Request swap of front and back buffers

glutSwapBuffers();

(64)

6

Depth Buffering and

Hidden Surface Removal

Depth Buffering and

Hidden Surface Removal

1 2 4 8 16 1 2 4 8 16 Color Buffer Depth Buffer Display

(65)

Depth Buffering Using OpenGL



Request a depth buffer

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



Request a depth buffer

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

(66)

6 6

An Updated Program Template

glutInit( &argc, argv );

glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); glutCreateWindow( “Tetrahedron” ); init(); glutIdleFunc( idle ); glutDisplayFunc( display ); glutMainLoop(); }

glutInit( &argc, argv );

glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); glutCreateWindow( “Tetrahedron” ); init(); glutIdleFunc( idle ); glutDisplayFunc( display ); glutMainLoop(); }

(67)

An Updated Program Template

(cont.)

An Updated Program Template

(cont.)

void init( void ) {

glClearColor( 0.0, 0.0, 1.0, 1.0 ); }

(68)

6 8

An Updated Program Template

(cont.)

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(); }

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(); }

(69)

Lighting

(70)

7

Lighting Principles

•

_{Lighting simulates how objects reflect}

light

• _{material composition of object} • _{light’s color and position}

• _{global lighting parameters}

• _{ambient light}

• two sided lighting

• _{available in both color index}

(71)

How OpenGL Simulates Lights

•

_{Phong lighting model}

• _{Computed at vertices}

•

_{Lighting contributors}

• _{Surface material properties} • _{Light properties}

(72)

7

Surface

Normals

Surface

Normals

•

_{Normals define how a surface reflects light}

glNormal3f( x, y, z )

• _{Current normal is used to compute vertex’s color} • _{Use unit normals for proper lighting}

• _{scaling affects a normal’s length}

glEnable( GL_NORMALIZE ) or glEnable( GL_RESCALE_NORMAL ) CPU CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(73)

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

(74)

7

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

(75)

Light Sources (cont.)

•

_{Light color properties}

• _{GL_AMBIENT} • _{GL_DIFFUSE} • _{GL_SPECULAR}

•

_{Light color properties}

• _{GL_AMBIENT}

• _{GL_DIFFUSE}

(76)

7

Types of Lights

•

_{OpenGL supports two types of Lights}

• _{Local (Point) light sources}

• _{Infinite (Directional) light sources}

•

_{Type of light controlled by w coordinate}







xw yw zw



w z y x w at positioned Light Local along directed Light Infinite 0 0  

(77)

Turning on the Lights

•

_{Flip each light’s switch}

glEnable( GL_LIGHTn );

•

_{Turn on the power}

(78)

7

Light Material Tutorial

(79)

Controlling a Light’s Position

•

_{Modelview matrix affects a light’s position}

• _{Different effects based on when position is specified}

• _{eye coordinates} • _{world coordinates} • model coordinates

• _{Push and pop matrices to uniquely control a light’s}

(80)

8

Light Position Tutorial

(81)

Advanced Lighting Features

•

_Spotlights

• _{localize lighting affects}

• _{GL_SPOT_DIRECTION} • _{GL_SPOT_CUTOFF}

(82)

8

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   

(83)

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}

(84)

8

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

(85)

Imaging and Raster Primitives

(86)

8

Imaging and Raster Primitives

•

_{Describe OpenGL’s raster primitives:}

bitmaps and image rectangles

•

_{Demonstrate how to get OpenGL to read}

(87)

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 doesn’t understand image}

(88)

Frame Buffer Rasterization (including Pixel Zoom) Per Fragment Operations Texture Memory 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 CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(89)

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

(90)

9

Rendering Bitmaps

glBitmap( width, height, xorig, yorig, xmove,

ymove, bitmap )

• _{render bitmap in current color}

at

• _{advance raster position by}

after rendering    



x  xorig y  yorig



 xmove ymove width he ig h t xorig yorig xmove

(91)

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()}

(92)

9

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}

(93)

Reading Pixels

glReadPixels( x, y, width, height, format,

type, pixels )

• _{read pixels form specified (x,y) position in}

framebuffer

• _{pixels automatically converted from framebuffer}

format into requested format and type

•

_{Framebuffer pixel copy}

(94)

9 Raster Position glPixelZoom(1.0, -1.0);

Pixel Zoom

glPixelZoom( x, y )

• _{expand, shrink or reflect pixels}

around current raster position

• _{fractional zoom supported}

glPixelZoom( x, y ) • _{expand, shrink or reflect pixels}

around current raster position

(95)

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}

(96)

Texture Mapping

(97)

•

_{Apply a 1D, 2D, or 3D image to geometric}

primitives

•

_{Uses of Texturing}

• _{simulating materials}

• _{reducing geometric complexity}

• _{image warping}

• _reflections

•

_{Apply a 1D, 2D, or 3D image to geometric}

primitives

•

_{Uses of Texturing}

• _{simulating materials}

• _{reducing geometric complexity} • _{image warping}

• _reflections

Texture

Mapping

Texture

Mapping

Pixel

(98)

9

Texture Mapping

s t x y z image geometry screen

(99)

Texture Mapping and the

OpenGL Pipeline

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}

(100)

1 0

Texture Example

•

_{The texture (below) is a}

256 x 256 image that has been mapped to a rectangular

polygon which is viewed in perspective

(101)

1

Applying Textures I

•

_{Three steps}

 specify texture

• _{read or generate image} • _{assign to texture}

 assign texture coordinates to vertices  specify texture parameters

(102)

1 0

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 • _{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}

(103)

1

Texture Objects

•

Like display lists for texture images

• one image per texture object

• _{may be shared by several graphics contexts}

•

_{Generate texture names}

(104)

1 0

Texture Objects (cont.)

•

Create texture objects with texture data and state

glBindTexture( target, id );

•

Bind textures before using

(105)

1

•

_{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

Specify Texture

Image

CPUCPU DLDL

Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(106)

1 0

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

(107)

1

Specifying a Texture:

Other Methods

Specifying a Texture:

Other Methods

•

Use frame buffer as source of texture image • uses current buffer as source image

glCopyTexImage2D(...) glCopyTexImage1D(...)

•

_{Modify part of a defined texture}

glTexSubImage2D(...) glTexSubImage1D(...)

(108)

1 0

•

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

Mapping a

Texture

Pixel

(109)

1

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     By Cz D Ax

(110)

1 1

Tutorial: Texture

(111)

1

•

_{Filter Modes}

• _{minification or magnification}

• _{special mipmap minification filters}

•

_{Wrap Modes}

• _{clamping or repeating}

•

_{Texture Functions}

• _{how to mix primitive’s color with texture’s color}

• blend, modulate or replace texels

Texture Application Methods

(112)

1 1

Filter Modes

Texture Polygon Magnification Minification Polygon Texture Example:

(113)

1

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( … )

(114)

1 1

Wrapping Mode

• Example: glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ) glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ) texture GL_REPEAT wrapping GL_CLAMP wrapping s t

(115)

1

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}

(116)

1 1

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}

(117)

1

Is There Room for a Texture?

•

_{Query largest dimension of texture image}

• _{typically largest square texture}

• _{doesn’t consider internal format size}

glGetIntegerv( GL_MAX_TEXTURE_SIZE, &size )

•

_{Texture proxy}

• _{will memory accommodate requested texture size?} • _{no image specified; placeholder}

• if texture won’t fit, texture state variables set to 0

• doesn’t know about other textures

(118)

1 1

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

(119)

Advanced OpenGL Topics

(120)

1 2

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}

(121)

1

Immediate Mode versus Display

Listed Rendering

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

(122)

1 2

Immediate Mode versus

Display Lists

Immediate Mode versus

Display Lists

Immediate Mode Display Listed Display List Polynomial Evaluator Per Vertex Operations & Primitive Assembly

Rasterization Per Fragment_Operations

Texture Memory CPU Pixel Operations Frame Buffer

(123)

1 2 3

Display Lists

•

_{Creating a display list}

GLuint id;

id = glGenLists( 1 );

glNewList( id, GL_COMPILE ); /* other OpenGL routines */ glEndList();

}

•

_{Call a created list}

void display( void ) { glCallList( id ); CPU CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(124)

1 2

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

(125)

1

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();

(126)

1 2

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)}

•

_{Vertex Arrays}

•

_{Bernstein Polynomial Evaluators}

• _{basis for GLU NURBS}

• _{NURBS (Non-Uniform Rational B-Splines)}

•

_{GLU Quadric Objects}

• _sphere

• _{cylinder (or cone)} • _{disk (circle)}

(127)

1

Vertex

Arrays

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}

•

_{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 CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(128)

1 2

Why use Display Lists or Vertex

Arrays?

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}

(129)

1

Alpha: the 4

th

Color Component

Alpha: the 4

th

Color Component

•

_{Measure of Opacity}

• _{simulate translucent objects}

• _{glass, water, etc.}

• _{composite images} • _antialiasing

• _{ignored if blending is not enabled}

(130)

1 3

Blending

•

_{Combine pixels with what’s in already}

in the framebuffer glBlendFunc( src, dst ) Framebuffer Pixel (dst) Blending Equation Blending Equation Fragment (src) Blended Pixel p f r

src

C

dst

C











CPU CPU DL_DL Poly. Poly. Per Vertex Per Vertex Raster

Pixel

(131)

1

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

(132)

1 3

Antialiasing

•

_{Removing the Jaggies}

glEnable( mode )

• _{GL_POINT_SMOOTH} • _{GL_LINE_SMOOTH}

• _{GL_POLYGON_SMOOTH}

• _{alpha value computed by computing}

sub-pixel coverage