View
32
Download
2
Category
Tags:
Preview:
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 set of function with well defined interface. - PowerPoint PPT Presentation
Citation preview
Computer GraphicsComputer GraphicsCSC 830CSC 830
Computer GraphicsComputer GraphicsCSC 830CSC 830
Lecture notes 2Lecture notes 2OpenGLOpenGL
2
What is OpenGL?• It is NOT a language.• It is a Graphics Rendering API (Application Programmer’s
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. -> I will show examples with C language bindings.
A History of OpenGL• Was SGI’s Iris GL – basis for “Open”GL• “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
• Official Sitehttp://www.opengl.org
• Non official sites– http://nehe.gamedev.net/
• BOOKS – OpenGL : A Primer– OpenGL Red Book & – OpenGL Blue Book
Useful Websites and Books
5
Useful Links• Online Reference manual sites
• GL and GLUhttp://www.mevis.de/~uwe/opengl/opengl.html
• GLUThttp://pyopengl.sourceforge.net/documentation/manual/
reference-GLUT.html
6
Three View of OpenGL• Programmer’s 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 -> Transformer -> Clipper -> Projector -> Rasterizer ->
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
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
Libraries and HeadersLibrary Name
Library File Header File
Note
OpenGL opengl32.lib (PC)-lgl (UNIX)
gl.h “core” library
Auxiliary library
glu32.lib (PC)-lglu
glu.h handles a variety of accessory functions
Utility toolkits glut32.lib (PC)-lglut (UNIX)glaux.lib (PC)-lglaux (UNIX)
glut.hglaux.h
window managements
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/spec3/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
Include Header files
#include <GL/gl.h> // “core”, the only thing is required
#include <GL/glu.h> // handles accessory functions
#include <GL/glut.h> // handles window managements
void main( int argc, char **argv ){
…..}
Only the “core” library (opengl32.lib, gl.h) are required
Include the necessary header files in your code
Link Libraries
• 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)
Link the necessary Libraries to your code
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
GLshort A[10]; short A[10];
GLdouble B; double B;
Programming Convention : OpenGL
Data TypesOpenGL Data Type Representatio
nAs C Type
GLbyte 8-bit integer signed char
GLshort 16-bit integer short
GLint, GLsizei 32-bit integer long
GLfloat 32-bit float float
GLdouble 64-bit float double
GLubyte, GLboolean 8-bit unsigned integer
unsigned char
GLushort 16-bit unsigned short
unsigned short
GLunit, GLenum, GLbitfield
32-bit unsigned integer
unsigned long
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
<Library prefix><Root command><Argument count><Argument type>
Programming Convention : OpenGL
Function Naming
glColor3f(…) gl library Root command, # of arguments, type of arguments
gl means OpenGL
glu means GLU
glut means GLUT
f: the argument is float type
i: the argument is integer type
v: the argument requires a vector
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
1. Configure GL (and GLUT) - Open window, Display mode, ……
2. Initialize OpenGL state - background color, light, View positions, ……
3. Register callback functions - Render, Interaction (keyboard, mouse), ……
4. Event processing loop - glutMainLoop()
A Sample Programvoid 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
1: Initializing & Creating Window
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
……
}
Set up window/display you’re going to use
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 positionvoid 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);
2: Initializing OpenGL State
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_MODELVIEW);
}
Set up whatever state you’re going to use
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
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()
3: Register Callback Functions
void main (int argc, char **argv)
{
……
glutDisplayFunc ( display ); // display callback
glutReshapeFunc ( resize ); // window resize callback
glutKeyboardFunc ( key ); // keyboard callback
……
}
Set up any callback function you’re going to use
Rendering Callback
void display( void )
{
int k;
glClear(GL_COLOR_BUFFER_BIT);
for( k=0; k<5000; k++)
……
}
It’s here that does all of your OpenGL rendering
Window Resize Callback
void resize(int w, int h)
{
……
display();
}
It’s called when the window is resized or moved
Keyboard Input Callback
void key( char mkey, int x, int y ){ switch( mkey ) { case ‘q’ : exit( EXIT_SUCCESS ); break; …… }}
It’s called when a key is struck on the keyboard
4. Event Process Loop
void main (int argc, char **argv)
{
……
glutMainLoop();
}
This is where your application receives events, and schedules when callback functions are called
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_POINTS GL_LINES GL_LINE_STRIP
GL_LINE_LOOP
GL_POLYGON
GL_QUADS GL_TRIANGLES
GL_TRIANGLE_FAN
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_POINTS GL_LINES GL_LINE_STRIP
GL_LINE_LOOP
GL_POLYGON
GL_QUADS GL_TRIANGLES
GL_TRIANGLE_FAN
38
TypesGL_POINTSGL_LINES : each successive pair for a ling segmentGL_LINE_STRIP: vertices defining a sequence of line segmentsGL_LINE_LOOP: GL_LINE_STRIP + the last vertex connects to
the firstGL_POLYGON : sequence of vertices of polygon, filledGL_QUADS: each successive group of four vertices for a
quadrilateralsGL_TRIANGLES: each successive group of three vertices for a
triangleGL_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 : Linevoid 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 glRect{sifd} (TYPE x1, TYPE y1, TYPE x2, TYPE y2);
41
Examplevoid drawSquare (){ glClear(GL_COLOR_BUFFER_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
hcolor_dept2
42
82
242
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 ComponentAlpha 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
Examplevoid drawLine (GLfloat *color){ glColor3fv ( color ); glBegin(GL_LINE); glVertex2f ( 0.0, 0.0 ); glVertex2f ( 1.0, 0.0 ); glEnd();}
50
Examplevoid 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 InterpolationglShadeModel(GL_SMOOTH);
OrglShadeModel(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 FeaturesGL_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_array[4];
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 stacksvoid glPishAttrib(GLbitfield mask)void glPopAttrib()
59
Saving the StateglMatrix(GL_PROJECTION)
// set projection matrix
// draw scene
glPushMatrix();
// change the project matrix
//draw scene
glPopMatrix();
60
Callback : Reshapevoid 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 : Idlevoid glutIdleFunc(void (*)f (void))
– f will be executed whenever there are no other events to be handled.
– necessary for animation
62
Callback : IdleglutIdleFunc(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 InteractionglutKeyboardFunc(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(key==‘q’)
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 Interactionvoid 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 Interactionvoid glutMotionFunc(void (*f) (int x, int y));
-- mouse moved with button downvoid 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 AnalogyThe 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 <= M // set to matrix M
C <= CT // post-multiply by T
C <= CS // post-multiply by S
C <= 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 <= M; C <= CT; C <= CR; C <= 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 matrixglMatrixMode (mode)
Specified what transformation matrix is modified.
mode:
GL_MODELVIEW
GL_PROJECTION
82
Specifying Matrix(2)• Modify current matrix
glLoadMatrix{fd} ( 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
glMultMatrix{fd} ( 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
1000
100
010
001
z
y
x
d
d
d
,, zyx dddTTranslation:
1000
000
000
000
z
y
x
s
s
s
,, zyx sssSScale:
• Three elementary 3D transformations
87
Recall
1000
0cossin0
0sincos0
0001
)(Rx
)(Ry
1000
0cos0sin
0010
0sin0cos
1000
0100
00cossin
00sincos
)(
Rz
Rotation )(Rx
Rotation )(Ry
Rotation )(Rz
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 <= IC <= CT(4.0, 5.0, 6.0)C <= CR(45, 1.0, 2.0, 3.0)C < = CT(-4.0, -5.0, -6.0)
• FinallyC = T(4.0, 5.0, 6.0) CR(45, 1.0, 2.0, 3.0) CT(-4.0, -
5.0, -6.0)Write it
Read it
93
Matrix Multiplication is Not Commutative
First rotate, then translate =>
First translate, then rotate =>
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
• Translation• Rotation
x
y
z
x
y
z Camera
R, T
96
Where I am and Looking at
x
y
z
x
y
zEyepoint
(eyex, eyey, eyez)
Model
View-up vector
(upx, upy, upz)
Loot at
(atx, aty, atz)
97
Define Coordinate System
+X
+Z
+YIn 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
Top
Bottom
Popping
Pushing
• 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.
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-dependent.
• 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_PROJECTION_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.
PositiveX
YPositive
OpenGL Screen Mapping
(50, 50)
(0, 0)
PositiveX
Y Positive
Windows Screen Mapping
(50, 50)
(0, 0)
106
Perspective Projection Volume
Far-plane: zNearNear-plane: zNear
Viewing volume
hw
aspect ratio = w/hy
z
x
fovy
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_DOUBLE|GLUT_RBG|GLUT_DEPTH);
glClear(GL_DEPTH_BUFFER_BIT)
Clear z (depth) buffer
You can also clear the depth buffer (as we did for color buffer)
110
Viewing a 3D world
View right
View up
ViewUp
ViewRightAspect Ratio
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
A viewpoint is defined as the same size as the window
A viewpoint is defined as half the size of the window
h
w h
w
113
Aspect Ratio• The Aspect Ratio of a rectangle is the
ratio of the rectangle’s 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
Recommended