Computer Graphics CSC 830 - PowerPoint PPT Presentation

1 / 114
About This Presentation
Title:

Computer Graphics CSC 830

Description:

Computer Graphics CSC 830 Lecture notes 2 OpenGL What is OpenGL? It is NOT a language. It is a Graphics Rendering API (Application Programmer s Interface) that is a ... – PowerPoint PPT presentation

Number of Views:50
Avg rating:3.0/5.0
Slides: 115
Provided by: tlalocSf
Category:

less

Transcript and Presenter's Notes

Title: 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
Write a Comment
User Comments (0)
About PowerShow.com