Computer Graphics CSC 830

1
Computer GraphicsCSC 830

• Lecture notes 2
• OpenGL

2
What is OpenGL?

• It is NOT a language.
• It is a Graphics Rendering API (Application
  Programmers Interface) that is a set of function
  with well defined interface.
• Whenever we say that a program is OpenGL-based or
  OpenGL applications, we mean that it is written
  in some programming language (such as C/C or
  Java) that makes calls to one or more of OpenGL
  libraries.
• OpenGL is Not Object-Oriented. OpenGL API does
  not make use of features such as overloading that
  are available in object-oriented languages. -gt I
  will show examples with C language bindings.

3
A History of OpenGL

• Was SGIs Iris GL basis for OpenGL
• Open standard allowing for wide range hardware
  platforms
• OpenGL v1.0 (1992)
• OpenGL v1.1 (1995)
• OpenGL v1.5 (latest)
• Governed by OpenGL Architecture Review Board
  (ARB) which has members from such as Silicon
  Graphics, IBM, and NVIDIA.
• Mesa an Open source (http//www.mesa3d.org)

4
Useful Websites and Books

• Official Site
• http//www.opengl.org
• Non official sites
• http//nehe.gamedev.net/
• BOOKS
• OpenGL A Primer
• OpenGL Red Book
• OpenGL Blue Book

5
Useful Links

• Online Reference manual sites
• GL and GLU
• http//www.mevis.de/uwe/opengl/opengl.html
• GLUT
• http//pyopengl.sourceforge.net/documentation/manu
  al/reference-GLUT.html

6
Three View of OpenGL

• Programmers view
• Specifying a set of objects to render
• Describing properties of these objects
• Defining how these objects should be viewed
• State machine
• Keeps states that affects appearances of input
  ie. States determines how the inputs are
  processed.
• Change state (such as color) by using state
  changing functions
• OpenGL uses Rendering Pipeline Model
• Models -gt Transformer -gt Clipper -gt Projector -gt
  Rasterizer -gt Image

7
OpenGL API Functions

• OpenGL contains over 200 functions
• Primitive functions define the elements (eg. A
  point, line, polygon, etc)
• Attribute functions control the appearance of
  primitives (eg. colors, line types, light source,
  textures.)
• Viewing functions determine the properties of
  camera. Transformation
• Windowing functions not part of core OpenGL
• Other functions

8
Window Management

• OpenGL is meant to be platform independent. i.e.
  OpenGL is window and operating system
  independent.
• OpenGL does not include any functions for window
  management, user interaction, and file I/O.
• Host environment is responsible for window
  management.

9
Window Management API

• We need additional libraries to handle window
  management
• GLX/AGL/WGL - glue between OpenGL and windowing
  systems
• GLUT - OpenGL Window Interface/Utility toolkit
• AUX - OpenGL Utility Toolkit

10
OpenGL API Hierarchy
11
OpenGL Division of Labor

• GL - core library of OpenGL that is platform
  independent
• GLU - an auxiliary library that handles a variety
  of graphics accessory functions
• GLUT/AUX - utility toolkits that handle window
  managements

12
Libraries and Headers
All are presented in the C language
13
Learning OpenGL with GLUT

• GLUT is a Window Manager (handles window
  creation, user interaction, callbacks, etc)
• http//www.opengl.org/resources/libraries/glut/spe
  c3/spec3.html
• Platform Independent
• Makes it easy to learn and write OpenGL programs
  without being distracted by your environment
• All of our discussions will be presented in C/C
  language

14
Include Header files
Include the necessary header files in your code

• include ltGL/gl.hgt // core,
  the only thing is required
• include ltGL/glu.hgt // handles
  accessory functions
• include ltGL/glut.hgt // handles
  window managements
• void main( int argc, char argv )
• ..

Only the core library (opengl32.lib, gl.h) are
required
15
Link Libraries
Link the necessary Libraries to your code

• Link GL library
• Link opengl32.lib (PC), or -lgl (UNIX)
• Link GLU library
• Link glu32.lib (PC), or -lglu (UNIX)
• Link GLUT library
• Link glut32.lib (PC), or -lglut (UNIX)

16
Programming Convention OpenGL Data Types
To make it easier to convert OpenGL code from one
platform to another, OpenGL defines its own data
types that map to normal C data types
17
Programming Convention OpenGL Data Types
18
Programming Convention OpenGL Function Naming
OpenGL functions all follow a naming convention
that tells you which library the function is
from, and how many and what type of arguments
that the function takes
ltLibrary prefixgtltRoot commandgtltArgument
countgtltArgument typegt
19
Programming Convention OpenGL Function Naming
f the argument is float type i the argument is
integer type v the argument requires a vector
gl means OpenGL glu means GLU glut means GLUT
20
Programming Convention OpenGL Function Naming

• Multiple forms of OpenGL functions to support the
  variety of data types
• glVertex3i(ix, iy, iz)
• glVertex3f(x, y, z)
• glVertex2i(ix, iy)
• glVertex2f(x, y)
• ..
• We shall use the notation glVertex() to refer to
  all the forms of the vertex function

21
Basic OpenGL Coding Framework

• Configure GL (and GLUT) - Open window, Display
  mode,
• Initialize OpenGL state - background color,
  light, View positions,
• Register callback functions - Render, Interaction
  (keyboard, mouse),
• Event processing loop - glutMainLoop()

22
A Sample Program
void main (int argc, char argv) glutInit
(argc, argv)
glutInitDisplayMode (GLUT_SINGLE
GLUT_RGB) glutInitWindowSize (500, 500)
glutCreateWindow (My First Program")
myinit ()
glutDisplayFunc (
display )
glutReshapeFunc ( resize )
glutKeyboardFunc ( key )
glutMainLoop ()
1
2
3
4
23
1 Initializing Creating Window
Set up window/display youre going to use
void main (int argc, char argv) glutInit
(argc, argv)
// GLUT initialization
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB)
// display model glutInitWindowSize (500,
500) // window size
glutCreateWindow (My First Program") //
create window
24
GLUT Initializing Functions

• Standard GLUT initialization
• void glutInit (int argc, char argv)
• Display model
• void glutInitDisplayMode (unsigned int mode)
• Define color model GLUT_RGB or GLUT_INDEX
• Define buffering GLUT_SINGLE GLUT_DOUBLE
• Window size and position
• void glutInitWindowSize (int width, int height)
• void glutInitWindowPosition(int x, int y)
• - top-left corner of the screen in pixel
• Create window
• int glutCreateWindow (char title)

25
2 Initializing OpenGL State
Set up whatever state youre going to use
void myinit(void) glClearColor(1.0,
1.0, 1.0, 1.0) // background
color glColor3f(1.0, 0.0, 0.0)
// line color
glMatrixMode(GL_PROJECTION) //
followings set up viewing
glLoadIdentity() gluOrtho2D(0.0,
500.0, 0.0, 500.0) glMatrixMode(GL_MODELVI
EW)
26
Event Loops and Callback Functions

• Interactive programs react to the events such as
  mouse or keyboard events and window events.
• Callback Function - Routine to call when
  something happens (eg. window resize, redraw,
  user input, etc)
• GLUT uses a callback mechanism to do its event
  processing

27
GLUT Callback Functions

• Contents of window need to be refreshed
• glutDisplayFunc()
• Window is resized or moved
• glutReshapeFunc()
• Key action
• glutKeyboardFunc()
• Mouse button action
• glutMouseFunc()
• Mouse moves while a button is pressed
• glutMotionFunc()
• Mouse moves regardless of mouse button state
• glutPassiveMouseFunc()
• Called when nothing else is going on
• glutIdleFunc()

28
3 Register Callback Functions
Set up any callback function youre going to use
void main (int argc, char argv)
glutDisplayFunc ( display )
// display callback
glutReshapeFunc ( resize )
// window resize callback
glutKeyboardFunc ( key )
// keyboard callback
29
Rendering Callback
Its here that does all of your OpenGL rendering
void display( void ) int k glClear(GL_COLOR_B
UFFER_BIT) for( k0 klt5000 k)

30
Window Resize Callback
Its called when the window is resized or moved
void resize(int w, int h)
display()
31
Keyboard Input Callback
Its called when a key is struck on the keyboard
void key( char mkey, int x, int y )
switch( mkey ) case q
exit( EXIT_SUCCESS )
break
32
4. Event Process Loop
This is where your application receives events,
and schedules when callback functions are called
void main (int argc, char argv)
glutMainLoop()
33
2D Geometric Primitives

• Primitives fundamental entities such as point
  and polygons
• Basic types of geometric primitives
• Points
• Line segments
• Polygons

34
2D Geometric Primitives
GL_QUADS
All geometric primitives are specified by vertices
35
Geometry Commands

• glBegin(GLenum type)
• marks the beginning of a vertex-data list that
  describes a geometric primitives

• glEnd (void)
• marks the end of a vertex-data list

• glVertex()
• specifies vertex for describing a geometric
  object

36
Specifying Geometric Primitives

• glBegin( type )
• glVertex()
• glVertex()
• glEnd()

type determines how vertices are combined
37
Types
GL_QUADS
38
Types

• GL_POINTS
• GL_LINES each successive pair for a ling
  segment
• GL_LINE_STRIP vertices defining a sequence of
  line segments
• GL_LINE_LOOP GL_LINE_STRIP the last vertex
  connects to the first
• GL_POLYGON sequence of vertices of polygon,
  filled
• GL_QUADS each successive group of four vertices
  for a quadrilaterals
• GL_TRIANGLES each successive group of three
  vertices for a triangle
• GL_TRIANGLE_FAN first three vertices for the
  first triangle and each subsequent vertex with
  the first vertex and the previous vertex for the
  next triangle

39
Attribute Line

• void glLineWidth(GLfloat width)
• Set the width in pixel. Default is 1.0
• void glLineStripple(GLint factor, GLushort
  pattern)

40
Rectangles

• glRect() defines 2D filled rectangle aligned
  with the axes.
• void glRectsifd (TYPE x1, TYPE y1, TYPE x2,
  TYPE y2)

41
Example
void drawSquare () glClear(GL_COLOR_BUFFE
R_BIT) glBegin(GL_POLYGON)
glVertex2f ( 0.0, 0.0 ) glVertex2f (
1.0, 0.0 ) glVertex2f ( 1.1, 1.1 )
glVertex2f ( 0.0, 1.0 )
glEnd() glFlush() // force the renderer
to output the results
42
OpenGL Color

• There are two color models in OpenGL
• RGB Color (True Color)
• Indexed Color (Color map)

43
RGB Color Model

• R, G, B components are stored for each pixel

44
RGB Color
Red
Green
Blue
45
How Many Colors?

• Color number

For example 4-bit color 16
colors 8-bit color 256 colors 24-bit
color 16.77 million colors
46
How Much Memory?

• Buffer size width height color depth

For example If width 640, height 480,
color depth 24 bits Buffer size (640
480 2) bytes If width 640, height 480,
color depth 32 bits Buffer size (640
480 4) bytes
47
Alpha Component

• Alpha value
• A value indicating the pixels opacity
• 0 usually represents totally transparent and
  the 1 represents completely opaque
• Alpha buffer
• Hold the alpha value for every pixel
• Alpha values are commonly represented in 8
  bits, in which case transparent to opaque ranges
  from 0 to 255

48
RGB Color Commands

• glColor()
• specifies vertex colors

• glClearColor(r, g, b, a)
• sets current color for cleaning color buffer

49
Example
void drawLine (GLfloat color)
glColor3fv ( color ) glBegin(GL_LINE)
glVertex2f ( 0.0, 0.0 )
glVertex2f ( 1.0, 0.0 ) glEnd()
50
Example
void drawLine (GLfloat color)
glBegin(GL_LINE) glColor3f(1.0,0.0,0.0 )
glVertex2f ( 0.0, 0.0 ) glColor3f(0.0,0.
0,1.0) glVertex2f ( 1.0, 0.0 )
glEnd()
51
Color Interpolation

• glShadeModel(GL_SMOOTH)
• Or
• glShadeModel(GL_FLAT) - the last vertex color
• Linear interpolation for a line
• Bilinear interpolation for a polygons

52
2D Viewing

• Where do we draw the 2D object?
• Assume that we draw objects on an infinite sheet
  of paper
• Then we need to specify clipping region and
  project these 2D objects to the screen
• void gluOrtho2D(GLdouble left, GLdouble right,
  GLdouble bottom, GLdouble top)

53
Coordinate Systems and Transformation

• Identify which matrix we wish to alter
• Set the matrix to an identity matrix
• Alter the matrix to form the desired matrix
• glMatrixMode(GL_PROJECTION)
• glLoadIdentity()
• gluOrtho2D(-1.0, 1.0, -1.0, 1.0)

54
Coordinate Systems and Transformation

• glMatrixMode(GLenum mode)
• Identify which matrix we wish to alter The mode
  is usually GL_MODELVIEW, GL_PROJECTION
• glLoadIdentity()
• Set the current matrix to an identity matrix

55
Enabling GL Features

• Features lighting, hidden-surface removal,
  texture mapping, etc
• Each feature will slow down the rendering
  process.
• We can enable/disable each feature individually
• void glEnable(GLenum feature)
• void glDisable(GLenum feature)
• Eg. glEnable(GL_LINE_STRIPPLE)

56
Enabling GL Features

• GL_ALPHA_TEST
• If enabled, do alpha testing.
• GL_AUTO_NORMAL
• If enabled, generate normal vectors when either
  GL_MAP2_VERTEX_3 or GL_MAP2_VERTEX_4 is used to
  generate vertices. See glMap2.
• GL_BLEND
• If enabled, blend the incoming RGBA color values
  with the values in the color buffers..
• GL_CLIP_PLANE i
• If enabled, clip geometry against user-defined
  clipping plane i..
• GL_COLOR_LOGIC_OP
• If enabled, apply the currently selected logical
  operation to the incoming RGBA color and color
  buffer values.
• GL_COLOR_MATERIAL
• If enabled, have one or more material parameters
  track the current color.
• GL_COLOR_TABLE
• If enabled, preform a color table lookup on the
  incoming RGBA color values.
• GL_CONVOLUTION_1D
• If enabled, perform a 1D convolution operation
  on incoming RGBA color values.
• GL_CONVOLUTION_2D
• If enabled, perform a 2D convolution operation
  on incoming RGBA color values.

57
Queries

• OpenGL state can be queried by
• void glGet(GLenum name, Type value)
• Eg.
• GLfloat color_array4
• glGetFloatv(GL_CURRENT_COLOR,color_array)
• Check if a feature has been enabled by
• GLboolean glIsEnabled(GLenum feature) - returns
  GL_TRUE or GL_FALSE

58
Saving the State

• State changing functions overwrites the state
  variables
• We can store previous state values for later use
• Matrix stacks
• void glPushMatrix()
• void glPopMatrix()
• Attribute stacks
• void glPishAttrib(GLbitfield mask)
• void glPopAttrib()

59
Saving the State

• glMatrix(GL_PROJECTION)
• // set projection matrix
• // draw scene
• glPushMatrix()
• // change the project matrix
• //draw scene
• glPopMatrix()

60
Callback Reshape

• void glutReshapeFunc(void (f) (int width, int
  height))
• invoked whenever the use changes the size of the
  window using the mouse. width and height is the
  new window size.
• Usually you want to take care of a new aspect
  ratio (width-to-height ratio).

61
Callback Idle

• void glutIdleFunc(void ()f (void))
• f will be executed whenever there are no other
  events to be handled.
• necessary for animation

62
Callback Idle

• glutIdleFunc(myidle)
• void myidle()
• glutPostRedisplay()
• Request the display callback to be executed
  after the current callback returns

63
Double Buffering

• Use two buffers front buffer and back buffer to
  guarantee to display a fully redrawn butter image
• glutSwapBuffers()
• Replace glFlush() by glutSwapBuffer() in the
  display callback

64
Keyboard Interaction

• glutKeyboardFunc(void f (unsigned char key, int
  x, int y))
• f is called when any key on the keyboard is
  pressed. (x, y) is the position of the mouse in
  the window given in pixel measured from the
  upper-left corner of the window.
• glutKeyboardFunc(mykey)
• void mykey(unsigned char key, int x, int y)
• if(keyq)
• exit(0)

65
Keyboard Interaction

• Special Keys (defined in glut.h)
• glutSpecialFunc(void f (int key, int x, int y))
• glutSpecialFunc(myskey)
• void mykey(unsigned char key, int x, int y)
• if(key GLIT_KEY_F1)
• ..
• if(key GLIT_KEY_UP)

66
Keyboard Interaction

• int glutGetModifiers() returns the logical AND
  of GLUT_ACTIVE_SHIFT, GLUT_ACTIVE_CTRL or
  GLUT_ACTIVE_ALT if that key is pressed at the
  time a mouse of keyboard event is generated.
• if(glutGetModifiers() GLUT_ACTIVE_CTRL) (key
  c)) exit(0)

67
Mouse Interaction

• void glutMouseFunc(void (f) (int button, int
  state, int x, int y)
• register mouse callback function
• Button GLUT_LEFT_BUTTON, GLUT_RIGHT_BUTTON,
  GLUT_MIDDLE_BUTTON
• State GLUT_UP, GLUT_DOWN

68
Mouse Interaction

• void glutMotionFunc(void (f) (int x, int y)) --
  mouse moved with button down
• void glutPassiveMotionFunc(void (f) (int x, int
  y) -- mouse moved without button down
• (x,y) is the current position of the mouse
• void glutEntryFunc(void (f) (int state))
• specifies the mouse entry callback
• state GLUT_ENTERED, GLUT_LEFT

69
Null Callback

• When we no longer need a callback.
• glutIdleFunc(Null)

70
Camera Analogy

• The graphics transformation process is analogous
  to taking a photograph with a camera
• Place objects
• Position camera
• Adjust camera
• Produce photograph

71
Transformations and Camera Analogy

• Modeling transformation
• Positioning and moving the model.
• Viewing transformation
• Positioning and aiming camera in the world.
• Projection transformation
• Adjusting the lens of the camera.
• Viewport transformation
• Enlarging or reducing the physical photograph.

72
OpenGL Transformation Pipeline
73
Transformations in OpenGL

• Transformations are specified by matrix
  operations. Desired transformation can be
  obtained by a sequence of simple transformations
  that can be concatenated together.
• Transformation matrix is usually represented by
  4x4 matrix (homogeneous coordinates).
• Provides matrix stacks for each type of supported
  matrix to store matrices.

74
Programming Transformations

• In OpenGL, the transformation matrices are part
  of the state, they must be defined prior to any
  vertices to which they are to apply.
• In modeling, we often have objects specified in
  their own coordinate systems and must use
  transformations to bring the objects into the
  scene.
• OpenGL provides matrix stacks for each type of
  supported matrix (model-view, projection,
  texture) to store matrices.

75
Steps in Programming

• Define matrices
• Viewing/modeling, projection, viewport
• Composite transformations

76
Transformation Matrix Operation

• Current Transformation Matrix (CTM)
• The matrix that is applied to any vertex that is
  defined subsequent to its setting.
• If change the CTM, we change the state of the
  system.
• CTM is a 4 x 4 matrix that can be altered by a
  set of functions.

77
Current Transformation Matrix
The CTM can be set/reset/modify (by
post-multiplication) by a matrix Ex C lt M
// set to matrix M C lt CT
// post-multiply by T C lt CS
// post-multiply by S C lt CR
// post-multiply by R
78
Current Transformation Matrix

• Each transformation actually creates a new matrix
  that multiplies the CTM the result, which
  becomes the new CTM.
• CTM contains the cumulative product of
  multiplying transformation matrices.

Ex If C lt M C lt CT C lt CR C lt CS Then
C M T R S
79
Ways to Specify Transformations

• In OpenGL, we usually have two styles of
  specifying transformations
• Specify matrices ( glLoadMatrix, glMultMatrix )
• Specify operations ( glRotate, glTranslate )

80
Specifying Matrix

• Identify current matrix
• Modify current matrix
• Load current matrix
• Multiple current matrix

81
Specifying Matrix (1)

• Identify current matrix

glMatrixMode (mode) Specified what
transformation matrix is modified. mode
GL_MODELVIEW GL_PROJECTION
82
Specifying Matrix(2)

• Modify current matrix

glLoadMatrixfd ( Type m ) Set the 16 values
of current matrix to those specified by m.
Note m is the 1D array of 16 elements arranged
by the columns of the desired matrix
83
Specifying Matrix(3)

• Modify current matrix

glLoadIdentity ( void ) Set the currently
modifiable matrix to the 4x4 identity matrix.
84
Specifying Matrix(4)

• Modify current matrix

glMultMatrixfd ( Type m ) Multiple the matrix
specified by the 16 values pointed by m by the
current matrix, and stores the result as current
matrix.
Note m is the 1D array of 16 elements arranged
by the columns of the desired matrix
85
Specifying Operations

• Three OpenGL operation routines for modeling
  transformations
• Translation
• Scale
• Rotation

86
Recall

• Three elementary 3D transformations

Translation
Scale
87
Recall
88
Specifying Operations (1)

• Translation

glTranslate fd (TYPE x, TYPE y, TYPE z)
Multiplies the current matrix by a matrix that
translates an object by the given x, y, z.
89
Specifying Operations (2)

• Scale

glScale fd (TYPE x, TYPE y, TYPE z)
Multiplies the current matrix by a matrix that
scales an object by the given x, y, z.
90
Specifying Operations (3)

• Rotate

glRotate fd (TPE angle, TYPE x, TYPE y, TYPE
z) Multiplies the current matrix by a matrix
that rotates an object in a counterclockwise
direction about the ray from origin through the
point by the given x, y, z. The angle parameter
specifies the angle of rotation in degree.
91
Order of Transformations

• The transformation matrices appear in reverse
  order to that in which the transformations are
  applied.
• In OpenGL, the transformation specified most
  recently is the one applied first.

92
Order of Transformations

• In each step
• C lt I
• C lt CT(4.0, 5.0, 6.0)
• C lt CR(45, 1.0, 2.0, 3.0)
• C lt CT(-4.0, -5.0, -6.0)
• Finally
• C T(4.0, 5.0, 6.0) CR(45, 1.0, 2.0, 3.0)
  CT(-4.0, -5.0, -6.0)

93
Matrix Multiplication is Not Commutative
First rotate, then translate gt
First translate, then rotate gt
94
Viewing-Modeling Transformation

• If given an object, and I want to render it from
  a viewpoint, what information do I have to have?

• Viewing position
• Which way I am looking at
• Which way is up
• ..

95
Viewing Position
R, T

• Translation
• Rotation

96
Where I am and Looking at
y
y
Loot at (atx, aty, atz)
View-up vector (upx, upy, upz)
x
x
Model
z
z
Eyepoint (eyex, eyey, eyez)
97
Define Coordinate System
In the default position, the camera is at the
origin, looking down the negative z-axis
98
If we use OpenGL

• Look-At Function

gluLookAt (eyex, eyey, eyez, atx, aty, atz, upx,
upy, upz ) Define a viewing matrix and multiplies
it to the right of the current matrix.
99
Matrix Stacks

• OpenGL uses matrix stacks mechanism to manage
  transformation hierarchy.
• OpenGL provides matrix stacks for each type of
  supported matrix to store matrices.
• Model-view matrix stack
• Projection matrix stack
• Texture matrix stack

100
Matrix Stacks

• Current matrix is always the topmost matrix of
  the stack
• We manipulate the current matrix is that we
  actually manipulate the topmost matrix.
• We can control the current matrix by using push
  and pop operations.

Pushing
Popping
Top
Bottom
101
Manipulating Matrix Stacks (1)

• Remember where you are

glPushMatrix ( void ) Pushes all matrices in the
current stack down one level. The topmost matrix
is copied, so its contents are duplicated in both
the top and second-from-the top matrix.
Note current stack is determined by
glMatrixModel()
102
Manipulating Matrix Stacks (2)

• Go back to where you were

glPopMatrix ( void ) Pops the top matrix off the
stack, destroying the contents of the popped
matrix. What was the second-from-the top matrix
becomes the top matrix.
Note current stack is determined by
glMatrixModel()
103
Manipulating Matrix Stacks (3)

• The depth of matrix stacks are implementation-depe
  ndent.
• The Modelview matrix stack is guaranteed to be at
  least 32 matrices deep.
• The Projection matrix stack is guaranteed to be
  at least 2 matrices deep.

glGetIntegerv ( Glenum pname, Glint parms
) Pname GL_MAX_MODELVIEW_STACT_DEPTH GL_MAX_PROJE
CTION_STACT_DEPTH
104
Projection Transformation

• Projection Viewing Volume
• Projection Transformation
• Viewpoint Transformation

105
OpenGL and Windows Screen
Remember the Y coordinates of OpenGL screen is
the opposite of Windows screen. But same as in
the XWindows system.
106
Perspective Projection Volume
107
Perspective Projection Commands

• glFrustum( left, right, bottom, top, zNear, zFar
  )
• Creates a matrix for a perspective viewing
  frustum and multiplies the current matrix by it.

108
Perspective Projection Commands

• gluPerspective( fovy, aspect, zNear, zFar )
• Creates a matrix for an perspective viewing
  frustum and multiplies the current matrix by it.

Note fovy is the field of view (fov) between the
top and bottom planes of the clipping volume.
aspect is the aspect ratio
109
Remember to Initialize
glutInitDisplayMode(GLUT_DOUBLEGLUT_RBGGLUT_DEPT
H)
You can also clear the depth buffer (as we did
for color buffer)
glClear(GL_DEPTH_BUFFER_BIT) Clear z (depth)
buffer
110
Viewing a 3D world
View up
View right
111
Viewport

• Viewport
• The region within the window that will be used
  for drawing the clipping area
• By default, it is set to the entire rectangle of
  the window that is opened
• Measured in the window coordinates, which reflect
  the position of pixels on the screen related to
  the lower-left corner of the window

112
Viewport Transformation
113
Aspect Ratio

• The Aspect Ratio of a rectangle is the ratio of
  the rectangles width to its height
• e.g. Aspect Ratio width/height
• Viewport aspect ratio should be same as
  projection transformation, or resulting image may
  be distorted.

114
Viewport Commands

• glViewport( x, y, width, height )
• Defines a pixel rectangle in the window into
  which the final image is mapped
• (x, y) specifies the lower-left corner of the
  viewport
• (width, height) specifies the size of the
  viewport rectangle