opengl basics. opengl – open graphics library what it is a s/w interface to graphics h/w ...
Post on 19-Dec-2015
248 Views
Preview:
TRANSCRIPT
OpenGL Basics
OpenGL – Open Graphics Library
What it is a s/w interface to graphics h/w mid-level, device-independent, portable graphics
subroutine package developed primarily by SGI 2D/3D graphics, lower-level primitives (polygons) does not include low-level I/O management basis for higher-level libraries/toolkits
The camera analogy
OpenGL libraries
GL – gl.h – Opengl32.lib Provides basic commands for graphics drawing
GLU (OpenGL Utility Library) – glu.h – glu32.lib Uses GL commands for performing compound graphics like
viewing orientation and projection specification polygon tessellations, surface rendering etc.
GLUT (OpenGL Utility Toolkit) – glut.h – glut.lib is a window system-independent toolkit for user interaction built on top
of OpenGL and WGL (Windows) or GLX (Linux).
System-specific OpenGl extensions GLX : for X window system (Linux/Unix) WGL: for Windows 95/98/2000/NT AGL : Apple Macintosh system
OpenGL conventions
Functions in OpenGL start with gl Most functions use just gl (e.g., glColor())
Functions starting with glu are utility functions (e.g., gluLookAt()) Note that GLU functions can always be composed
entirely from core GL functions Functions starting with glut are from the
GLUT library.
OpenGL conventions
Function names indicate argument type and number Functions ending with f take floats Functions ending with i take ints Functions ending with b take bytes Functions ending with ub take unsigned bytes Functions that end with v take an array.
Examples glColor3f() takes 3 floats glColor4fv() takes an array of 4 floats
Graphics Pipeline
Step 1: Modeling Transform
Vertices of an object are define in it’s own co-ordinate system (Object Space)
A scene is composed of different objects and some times multiple copy of the same object
Modeling transforms places all the objects in a world co-ordinate system (World Space)
Model Transforms must be specified before specifying the vertices of an object
glRotatef(30, 1, 0, 0); glVertex3d(20, 30, 10);
Basic Modeling Transforms are: Translate : glTranslate{f|d}(x,y,z) Rotate : glRotate{f|d}(,x,y,z) Scale : glScale{f|d}(x,y,z) Object
Space World Space
Instantiate &ModelingTransform
Step 2: Viewing Transform
A model can be viewed from different angles. Viewing Transform specify following information about the
viewer: eye position head up Look at direction
Eye Space
Step 2: Viewing Transform
void gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz);
Step 3: Normalize & Clip
Normalize View volume within an unit cube. Remove Primitives that are not in Normalized view volume
Eye Space Clipping Space
• After clipping lighting effects and textures are applied to the primitives
Step 4: Projection
Maps 3D-coordinates to 2D-image coordinates
Par
alle
l P
roje
ctio
n
Per
spec
tive
Pro
ject
ionTypes
Clipping Space
Image Space
Step 4: Projection
Perspective Projection
Step 4: Projection
Perspective Projection
Step 4: Projection
Parallel Projection
Step 5: Rasterization
Projected image (vertices) in image space has fractional x and y co-ordinates values
But raster scan device can only display pixels at integer co-ordinates
Image Space
Screen SpaceRasterization• Some Algorithms:
– DDA (Digital Differential Analyzer
– Brasenham’s Algorithm
– Midpoint Algorithm
Step 6: Viewport Transformation
Maps rasterized 2D images onto graphical device
Screen Space Device Space
Step 6: Viewport Transformation
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
gluPerspective(fovy, 1.0, near, far); glViewport(0, 0, 400, 400);
gluPerspective(fovy, 1.0, near, far); glViewport(0, 0, 400, 200);
Graphics Pipeline
GraphicsPrimitives
ObjectSpace
transformmatrix
Modeling Transform
WorldSpace
Eye, lookat,headup
Viewing Transform
EyeSpace
Parallel orPerspectivevolume
Normalize& Clip
ClippingSpace
material,
lights, color
Shading &Texture
viewport
location
Image on Screen
ViewportTransform
DeviceSpace
ImageSpace
Projection
projection
matrix
Image in Internal Buffer
Rasteri-zation
ScreenSpace
Scan
conversion
Primitives
Primitives: Points, Lines & Polygons Each object is specified by a set Vertices
• Grouped together by glBegin & glEnd
glBegin(type)
glVertex*( )
glVertex*( )
…
glEnd( );
• type can have 10
possible values
Primitive Types
GL_POINTS
V0
V1V2
V3
V5
V4
GL_LINE_LOOP
V0
V1 V2
V3
V5
V4
GL_LINE
V0
V1V2
V3
V5
V4
GL_LINE_STRIP
V0
V1V2
V3
V5
V4
GL_POLYGON
V0
V1
V2
V3
V4
Polygon must be:•Simple•No-holes inside•Convex Simple
Non-convex
ComplexConvex
P1
P2
Primitive Types
GL_TRIANGLE
V0
V1
V2
V3
V4
V5
V6
V7V8
GL_QUAD
V0
V1
V2
V3
V4
V5
V6
V7
GL_TRIANGLE_STRIP
V0
V1
V2
V3
V4
V5
Order of Vertex rendering
GL_TRIANGLE_STRIP012, 213, 234, 435
GL_QUAD_STRIP
V0
V1
V2
V3
V4
V5
V6
V7
GL_QUAD_STRIP0132, 2354, 4576
GL_TRIANGLE_FAN
V0
V1
V2
V3
V4
V5
GL_TRIANGLE_FAN012, 023 , 034, 045
Configuring OpenGL in Visual C++
Files Required for GLUT: glut32.dll glut.h glut32.lib
Sample Program
Specify Canvas Color
Must always remember to clear canvas before drawing
glClearColor( r , g , b , α ) specify the color to clear the canvas to should generally set α to be 0 (i. e., fully transparent) this is a state variable, and can be done only once
glClear( GL_ COLOR_ BUFFER_ BIT) actually clears the screen glClear clears such as the depth buffer GL_ DEPTH_ BUFFER_ BIT but we’re not using it right now
Redrawing Window void glFlush(void);
Forces previously issued OpenGL commands to begin execution It returns before the execution ends. glutSwapBuffers() automatically calls glFlush() For single buffer display function should end with this command
void glFinish(void); Forces previously issued OpenGL commands to complete This command doesn’t return until all effects from previous commands
are fully realized.
void glutPostRedisplay(void); Causes the currently registered display function to be called at the
next available opportunity.
Initializing GLUT
Void glutInit( int argc, char **argv) initialize glut, process command line arguments such as
-geometry, -display etc.
void glutInitDisplayMode(unsigned int mode) Mode for later glutCreateWindow() call mode is a bit-wised Ored combination of
Either GLUT_RGBA or GLUT_INDEX Either GLUT_SINGLE or GLUT_DOUBLE One or more GLUT_DEPTH, GLUT_STENCIL, GLUT_ACCUM
buffers default:RGBA & SINGLE
Initializing GLUT
void glutInitWindowPosition(int x, int y) Initial location of window
void glutInitWindowSize(int width, int height) Initial size of window
int glutCreateWindow(char *name) Called after Init, Displaymode, Position and Size calls Window will not appear until glutMainLoop is called Return value is a unique identifier for the window
Event driven approach void glutMainLoop(void);
enters the GLUT event processing loop.
should be called at most once in a GLUT program.
Once called, this routine will never return.
It will call as necessary any callbacks that have been registered.
While (TRUE) {e=getNextEvent();
switch (e) { case (MOUSE_EVENT): call registered MouseFunc break; case (RESIZE_EVENT): call registered ReshapeFunc break; … }
EventQueue
Keyboard Callback
Mouse Callback
Display Callback
Keyboard
Mouse
Display
OS MainLoop
Each application has itsOwn event queue
Callback Functions
void glutDisplayFunc(void (*func) (void)) Specifies the function that’s called whenever
the window is initially opened The content of the window is needed to be redrawn glutPostRedisplay() is explicitly called.
void glutReshapeFunc(void (*func)(int width, int height));
Specifies the function that’s called whenever The window is resized or moved
The function should perform following tasks Call glViewPort(0,0,width, height); // default behavior Redefine projection matrix to match aspect ratio of
image & view port
Callback Functions
void glutKeyboardFunc(
void (* func)(unsigned int key, int x, int y) ); Specifies the function that’s called whenever
a key that generates an ASCII character is pressed. The key callback parameter is the generated ASCII
value. The x and y callback parameters indicate the location
of the mouse when the key was pressed.
Callback Functions void glutMouseFunc(
void (* func)(int button, int state, int x, int y)); Specifies the function that’s called whenever a mouse
button is pressed or released. button callback parameter is one of
GLUT_LEFT_BUTTON GLUT_MIDDLE_BUTTON GLUT_RIGHT_BUTTON
state callback parameter is either GLUT_UP GLUT_DOWN
The x and y callback parameters indicate the location of the mouse when the event occurred.
Animation( Motion = Redraw+Swap )
Animation( Motion = Redraw+Swap )
Animation( Motion = Redraw+Swap )
Transformation in OpenGL
OpenGL uses 3 stacks to maintain transformation matrices:
Model & View transformation matrix stack Projection matrix stack Texture matrix stack
You can load, push and pop the stack The top most matrix from each stack is applied to
all graphics primitive until it is changed
M N
Model-ViewMatrix Stack
ProjectionMatrix Stack
GraphicsPrimitives
(P)
OutputN•M•P
Translation – 2D
(4,5) (7,5)
Y
XBefore Translation
1
*
100
10
01
1
y
x
d
d
y
x
TPPd
dT
y
xP
y
xP
y
x
y
x
Form sHomogeniou
x’ = x + dx y’ = y + dy
(7,1) (10,1)
X
Y
Translation by (3,-4)
Transformations and OpenGL®
Each time an OpenGL transformation M is called the current MODELVIEW matrix C is altered:
Cvv CMvv
glTranslatef(1.5, 0.0, 0.0);glRotatef(45.0, 0.0, 0.0, 1.0);
CTRvv
Note: v is any vertex placed in rendering pipeline v’ is the transformed vertex from v.
Matrix Operation
Thinking About Transformations
As a Global System Objects moves but
coordinates stay the same
Think of transformation in reverse order as they appear in code
As a Local System Objects moves and
coordinates move with it
Think of transformation in same order as they appear in code
There is a World Coordinate System where: All objects are defined Transformations are in World Coordinate space
Two Different Views
Local View Translate Object Then Rotate
Order of Transformation T•R
glLoadIdentity();glMultiMatrixf( T);
glMultiMatrixf( R);
draw_ the_ object( v);v’ = ITRv
Global View Rotate Object
Then Translate
Effect is same, but perception is different
Order of Transformation R•T
glLoadIdentity();glMultiMatrixf( R);
glMultiMatrixf( T);
draw_ the_ object( v);v’ = ITRv
Local View Rotate Object Then Translate
Global View Translate Object
Then Rotate
Effect is same, but perception is different
Thank You
top related