Girish Ghate, profile picture
Uploaded byGirish Ghate
PDF, PPTX7,997 views

OpenGL Introduction.

The document provides an introduction and overview of OpenGL graphics programming. It discusses that OpenGL is a 3D graphics rendering API that is hardware independent and portable. The document outlines the OpenGL rendering pipeline and libraries. It describes that OpenGL is not a language itself but makes calls to functions from libraries like GLUT, GLU, and OpenGL in a programming language like C/C++. The basic framework of an OpenGL program and functions for initializing OpenGL state, registering callbacks, and the event processing loop are also covered.

Embed presentation

Download as PDF, PPTX
1 / 156
2 / 156
Most read
3 / 156
4 / 156
5 / 156
6 / 156
7 / 156
8 / 156
9 / 156
10 / 156
11 / 156
12 / 156
13 / 156
14 / 156
15 / 156
16 / 156
17 / 156
18 / 156
19 / 156
20 / 156
21 / 156
Most read
22 / 156
23 / 156
24 / 156
Most read
25 / 156
26 / 156
27 / 156
28 / 156
29 / 156
30 / 156
31 / 156
32 / 156
33 / 156
34 / 156
35 / 156
36 / 156
37 / 156
38 / 156
39 / 156
40 / 156
41 / 156
42 / 156
43 / 156
44 / 156
45 / 156
46 / 156
47 / 156
48 / 156
49 / 156
50 / 156
51 / 156
52 / 156
53 / 156
54 / 156
55 / 156
56 / 156
57 / 156
58 / 156
59 / 156
60 / 156
61 / 156
62 / 156
63 / 156
64 / 156
65 / 156
66 / 156
67 / 156
68 / 156
69 / 156
70 / 156
71 / 156
72 / 156
73 / 156
74 / 156
75 / 156
76 / 156
77 / 156
78 / 156
79 / 156
80 / 156
81 / 156
82 / 156
83 / 156
84 / 156
85 / 156
86 / 156
87 / 156
88 / 156
89 / 156
90 / 156
91 / 156
92 / 156
93 / 156
94 / 156
95 / 156
96 / 156
97 / 156
98 / 156
99 / 156
100 / 156
101 / 156
102 / 156
103 / 156
104 / 156
105 / 156
106 / 156
107 / 156
108 / 156
109 / 156
110 / 156
111 / 156
112 / 156
113 / 156
114 / 156
115 / 156
116 / 156
117 / 156
118 / 156
119 / 156
120 / 156
121 / 156
122 / 156
123 / 156
124 / 156
125 / 156
126 / 156
127 / 156
128 / 156
129 / 156
130 / 156
131 / 156
132 / 156
133 / 156
134 / 156
135 / 156
136 / 156
137 / 156
138 / 156
139 / 156
140 / 156
141 / 156
142 / 156
143 / 156
144 / 156
145 / 156
146 / 156
147 / 156
148 / 156
149 / 156
150 / 156
151 / 156
152 / 156
153 / 156
154 / 156
155 / 156
156 / 156
Graphics Programming Introduction to OpenGL
Outline • What is OpenGL • OpenGL Rendering Pipeline • OpenGL Utility Toolkits • OpenGL Coding Framework • OpenGL API
Graphics System Function calls Output User User Graphics Graphics I/O I/O Program Program System System Device Device Data Input Graphics API
What is OpenGL OpenGL • A software interface to graphics hardware • A 3D graphics rendering API (>120 functions) • Hardware independent • Very fast (a standard to be accelerated) • Portable http://www.opengl.org
A History of OpenGL • Was SGI’s Iris GL – “Open”GL • “Open” standard allowing for wide range hardware platforms • OpenGL v1.0 (1992) • OpenGL v1.1 (1995) • OpenGL v1.4 (latest) • Governed by OpenGL Architecture Review Board (ARB) “Mesa” – an Open source (http://www.mesa3d.org)
Graphics Process Geometric Primitives Rendering Rendering Frame Buffer Image Primitives + =
OpenGL Architecture
OpenGL is Not a Language It is a Graphics Rendering API 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++) that makes calls to one or more of OpenGL libraries
Window Management • 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
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
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 Headers Library Name Library File Header File Note OpenGL opengl32.lib (PC) gl.h “core” library -lgl (UNIX) Auxiliary library glu32.lib (PC) glu.h handles a -lglu variety of accessory functions Utility toolkits glut32.lib (PC) glut.h window -lglut (UNIX) glaux.h managements glaux.lib (PC) -lglaux (UNIX) All are presented in the C language
Learning OpenGL with GLUT • GLUT is a Window Manager (handles window creation, user interaction, callbacks, etc) • Platform Independent • Makes it easy to learn and write OpenGL programs without being distracted by your environment • Not “final” code (Not meant for commercial products)
Environment Setup • All of our discussions will be presented in C/C++ language • Use GLUT library for window managements • Files needed gl.h, glu.h, glut.h opengl32.lib, glu32.lib, glut32.lib • Go to http://www.opengl.org download files • Follow the Setup instruction to configure proper path
Usage Include the necessary header files in your code #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
Usage 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)
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;
OpenGL Data Types OpenGL Data Type Representation As 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
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>
OpenGL Function Naming glColor3f(…) gl library Root command, # of arguments, type of arguments gl means OpenGL f: the argument is float type glu means GLU i: the argument is integer type glut means GLUT v: the argument requires a vector
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 Program void main (int argc, char **argv) { glutInit (&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (500, 500); 1 glutCreateWindow (“My First Program"); myinit (); 2 glutDisplayFunc ( display ); glutReshapeFunc ( resize ); 3 glutKeyboardFunc ( key ); glutMainLoop (); 4 }
1: Initializing & Creating Window Set up window/display you’re 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 …… }
GLUT Initializing Functions • Standard GLUT initialization glutInit (int argc, char ** argv) • Display model glutInitDisplayMode (unsigned int mode) • Window size and position glutInitWindowSize (int width, int height) glutInitWindowPosition(int x, int y) • Create window glutCreateWindow (char *name);
2: Initializing OpenGL State Set up whatever state you’re 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_MODELVIEW); }
Callback Functions • Callback Function Routine to call when something happens - 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 Set up any callback function you’re going to use void main (int argc, char **argv) { …… glutDisplayFunc ( display ); // display callback glutReshapeFunc ( resize ); // window resize callback glutKeyboardFunc ( key ); // keyboard callback …… }
Rendering Callback It’s here that does all of your OpenGL rendering void display( void ) { typedef GLfloat point2[2]; point2 vertices[3]={{0.0, 0.0}, {250.0, 500.0}, {500.0, 0.0}}; int i, j, k; int rand(); glClear(GL_COLOR_BUFFER_BIT); for( k=0; k<5000; k++) …… }
Window Resize Callback It’s called when the window is resized or moved void resize(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); …… display(); }
Keyboard Input Callback It’s 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; …… }
Event Process Loop This is where your application receives events, and schedules when callback functions are called void main (int argc, char **argv) { …… glutMainLoop(); }
Let’s go Inside • OpenGL API – Geometric Primitives – Color Mode – Managing OpenGL’s State – Transformations – Lighting and shading – Texture mapping
OpenGL API Functions • Primitives – A point, line, polygon, bitmap, or image • Transformation – Rotation, size, perspective in 3D coordinate space • Color mode – RGB, RGBA, Color index • Materials lighting and shading – Accurately compute the color of any point given the material properties • Buffering – Double buffering, Z-buffering, Accumulation buffer • Texture mapping ……
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
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
Specifying Geometric Primitives glBegin( type ); glVertex*(…); …… glVertex*(…); glEnd(); type determines how vertices are combined
Example void drawSquare (GLfloat *color) { glColor3fv ( color ); glBegin(GL_POLYGON); glVertex2f ( 0.0, 0.0 ); glVertex2f ( 1.0, 0.0 ); glVertex2f ( 1.1, 1.1 ); glVertex2f ( 0.0, 1.0 ); glEnd(); }
Primitives and Attributes • Draw what… – Geometric primitives • points, lines and polygons • How to draw… – Attributes • colors, lighting, shading, texturing, etc.
Attributes • An attribute is any property that determines how a geometric primitives is to be rendered • Each time, OpenGL processes a vertex, it uses data stored in its internal attribute tables to determine how the vertex should be transformed, rendered or any of OpenGL’s other modes
Example glPointSize(3.0); glShadeModel(GL_SMOOTH); glBegin(GL_LINE); glColor4f(1.0, 1.0, 1.0, 1.0); glVertex2f(5.0, 5.0); glColor3f(0.0, 1.0, 0.0); glVertex2f(25.0, 5.0); glEnd();
OpenGL Color • There are two color models in OpenGL – RGB Color (True Color) – Indexed Color (Color map) • The type of window color model is requested from the windowing system. OpenGL has no command to control
Color Cube Three color theory C = T1*R + T2*G + T3* B
RGB Color • R, G, B components are stored for each pixel • With RGB mode, each pixel’s color is independent of each other
RGB Color Red Green Blue
How Many Colors? color_depth Color number = 2 For example: 4-bit color 4 2 = 16 colors 8-bit color 8 2 = 256 colors 24-bit color 224 = 16.77 million colors
How Much Memory? Buffer size = width * height *color depth For example: If width = 640, height = 480, color depth = 24 bits Buffer size = 640 * 480 * 24 = 921,600 bytes If width = 640, height = 480, color depth = 32 bits Buffer size = 640 * 480 * 32 = 1,228,800 bytes
Alpha Component Alpha value A value indicating the pixels opacity Zero usually represents totally transparent and the maximum value 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
RGB Color Commands • glColor*(…) specifies vertex colors • glClearColor(r, g, b, a) sets current color for cleaning color buffer • glutInitDisplayMode(mode) specify either an RGBA window (GLUT_RGBA ), or a color indexed window (GLUT_INDEX )
Example glutInitDisplayMode (GLUT_RGBA); glClearColor(1.0, 1.0, 1.0, 1.0); void drawLine (GLfloat *color) { glColor3fv ( color ); glBegin(GL_LINE); glVertex2f ( 0.0, 0.0 ); glVertex2f ( 1.0, 0.0 ); glEnd(); }
Indexed Color • Historically, color-index mode was important because it required less memory • Use Color-map (lookup table) • With color-index mode, each pixel with same index stored in its bit-planes shares the same color-map location
Color Lookup Table Index Red Green Blue 0 0 0 0 1 120 123 187 … 253 … … … 254 255 8 bits 8 bits 8 bits
RGBA vs. Color Index Mode Color index model Index R G B 0 0 0 0 1 120 123 187 2 … … … … 254 255 RGBA model
Color Index Commands • glIndex*(…) specifies vertex colors • glClearIndex(Glfloat index) sets current color for cleaning color buffer. • glutSetColor(int color, GLfloat r, GLfloat g, GLfloat b ) sets the entries in a color table for window.
Shading Model Green Red Blue (0, 0, 0) (128, 128, 128) (255, 255, 255) Black Gray White
Shading Model Green Red Blue A triangle in RGB color space Smooth shading in OpenGL
Shading Model Commands • glShadeModel(mode) set the shading mode. The mode parameter can be GL_SMOOTH (the default) or GL_FLAT. Flat shading: the color of one particular vertex of an independent primitive is duplicated across all the primitive’s vertices to render that primitive. Smooth shading: the color at each vertex is treated individually. The colors of interior pixels are interpolated.
OpenGL’s State Machine In OpenGL, all rendering attributes are encapsulated in the OpenGL State – rendering styles – color – shading – lighting – texture mapping
OpenGL’s State Management • Setting Vertex Attributes – glPointSize(...) -- point size – glLineWidth(…) -- line width – glColor*(…) -- color Attributes – glNormal*(…) -- normal – glTexCoord*(…) -- texturing • Controlling State Functions – glEnable(…) – glDisable(…)
Controlling State Functions • OpenGL has many states and state variables can be changed to control rendering Ex. – GL_LIGHTING – GL_DEPTH_TEST – GL_SHADE_MODEL – GL_LINE_STIPPLE ……
Controlling State Functions • By default, most of the states are initially inactive. These states can be turn on/off by using: • glEnable (Glenum state) turn on a state • glDisable (Glenum state) turn off a state
Example glEnable(GL_LIGHTING); glShadeModel(GL_SMOOTH); glBegin(GL_LINE); glColor3f(1.0, 1.0, 1.0); glVertex2f(5.0, 5.0); glColor3f(0.0, 1.0, 0.0); glVertex2f(25.0, 5.0); glEnd(); glDisable(GL_LIGHTING);
OpenGL Transformations Model View direction View position (eyepoint)
Graphics Pipeline Object Transformation Object Coordinates Object -> World World Transformation World Coordinates World -> Viewport Viewport Clipping Viewport Coordinates Screen Coordinates Rasterization Scan Converting Triangles
Camera Analogy The graphics transformation process is analogous to taking a photograph with a camera - Position camera - Place objects - Adjust camera - Produce photograph
Transformations and Camera Analogy • Viewing transformation – Positioning and aiming camera in the world. • Modeling transformation – Positioning and moving the model. • Projection transformation – Adjusting the lens of the camera. • Viewport transformation – Enlarging or reducing the physical photograph.
OpenGL Transformation Pipeline
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.
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.
Steps in Programming • Define matrices: – Viewing/modeling, projection, viewport … • Manage the matrices – Including matrix stack • Composite transformations
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.
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
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=MTRS
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” …..
Viewing Position y R, T y x z x • Translation Camera • Rotation z
Where I am and Looking at y y Loot at View-up vector (atx, aty, atz) (upx, upy, upz) x x Model z z Eyepoint (eyex, eyey, eyez)
Define Coordinate System +Y In the default position, the camera is at the origin, looking down the +X negative z-axis +Z
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.
Ways to Specify Transformations • In OpenGL, we usually have two styles of specifying transformations: – Specify matrices ( glLoadMatrix, glMultMatrix ) – Specify operations ( glRotate, glTranslate )
Specifying Matrix • Specify current matrix mode • Modify current matrix • Load current matrix • Multiple current matrix
Specifying Matrix (1) • Specify current matrix mode glMatrixMode (mode) Specified what transformation matrix is modified. mode: GL_MODELVIEW GL_PROJECTION
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
Specifying Matrix (3) • Modify current matrix glLoadIdentity ( void ) Set the currently modifiable matrix to the 4x4 identity matrix.
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
Specifying Operations • Three OpenGL operation routines for modeling transformations: – Translation – Scale – Rotation
Recall • Three elementary 3D transformations ⎡1 0 0 d x⎤ ⎢ ⎥ Translation: T ( dx, dy , d z ) = ⎢0 ⎢0 1 0 0 1 d y⎥ d z⎥ ⎢ ⎥ ⎣0 0 0 1⎦ ⎡sx 0 0 0⎤ ⎢ ⎥ S (sx , s y , s z) ⎢ 0 sy 0 0⎥ Scale: =⎢ 0 0 sz 0⎥ ⎢ ⎥ ⎣0 0 0 1⎦
Recall ⎡1 0 0 0⎤ ⎢ ⎥ Rotation Rx (θ ) Rx (θ ) = ⎢0 cosθ − sin θ 0⎥ ⎢0 sin θ cosθ 0⎥ ⎢ ⎥ ⎣0 0 0 1⎦ ⎡ cosθ 0 sin θ 0⎤ ⎢ ⎥ Rotation Ry (θ ) Ry(θ ) = ⎢ 0 1 0 0⎥ ⎢− sin θ 0 cosθ 0⎥ ⎢ ⎥ ⎣ 0 0 0 1⎦ ⎡cosθ − sin θ 0 0⎤ ⎢ ⎥ Rotation Rz (θ ) sin θ cosθ 0 0⎥ Rz (θ ) = ⎢ ⎢ 0 0 1 0⎥ ⎢ ⎥ ⎣ 0 0 0 1⎦
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.
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.
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.
Example Let’s examine an example: – Rotation about an arbitrary point Question: Rotate a object for a 45.0-degree about the line through the origin and the point (1.0, 2.0, 3.0) with a fixed point of (4.0, 5.0, 6.0).
Rotation About an Arbitrary Point 1. Translate object through vector –V. T(-4.0, -5.0, -6.0) 2. Rotate about the origin through angle θ. R(45.0) 3. Translate back through vector V T(4.0, 5.0, 6.0) M = T(V ) R(θ ) T(-V )
OpenGL Implementation glMatrixMode (GL_MODEVIEW); glLoadIdentity (); glTranslatef (4.0, 5.0, 6.0); glRotatef (45.0, 1.0, 2.0, 3.0); glTranslatef (-40.0, -5.0, -6.0);
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.
Order of Transformations • In each step: C <= I C <= CT(4.0, 5.0, 6.0) C <= CR(45, 1.0, 2.0, 3.0) C < = 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) Write it Read it
Matrix Multiplication is Not Commutative First rotate, then translate => First translate, then rotate =>
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
Matrix Stacks • Current matrix is always the topmost matrix of the stack Pushing • We manipulate the Popping current matrix is that Top we actually manipulate the topmost matrix. • We can control the Bottom current matrix by using push and pop operations.
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()
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()
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
Projection Transformation • Projection & Viewing Volume • Projection Transformation • Viewpoint Transformation
OpenGL and Windows Screen Windows Screen Mapping OpenGL Screen Mapping X Y (0, 0) Positive Positive (50, 50) (50, 50) Positive (0, 0) X Y Positive Remember: the Y coordinates of OpenGL screen is the opposite of Windows screen. But same as in the XWindows system.
Orthographic Projection • Vertexes of an object are projected towards infinity • Points projected outside view volume are clipped out • Distance does not change the apparent size of an object Clipped out Image
Orthographic Viewing Volume Clipped out top left right Bottom Near-plane Far-plane Viewing rectangle Viewing volume
Orthographic Projection Commands • glOrtho( left, right, bottom, top, zNear, zFar ) Creates a matrix for an orthographic viewing volume and multiplies the current matrix by it • gluOrtho2D( left, right, bottom, top ) Creates a matrix for projecting 2D coordinates onto the screen and multiplies the current matrix by it
Orthographic Projection (Example) Define a 500x500 viewing rectangle with the lower-left corner of the rectangle at the origin of the 2D system glMatrixMode(GL_PROJECTION) glLoadIdentity(); gluOrtho2D(0.0, 500.0, 0.0, 500.0); glMatrixMode(GL_MODELVIEW);
Perspective Projection Volume y aspect ratio = w/h w h z fovy x Far-plane: zNear Near-plane: zNear Viewing volume
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.
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
Hidden-Surface Removal z-buffer algorithm - Image-space check - The worst-case complexity is proportional to the number of polygons z2 z1 - Requires a depth or z buffer to store the information as polygons are rasterized Viewpoint
Hidden-Surface Removal glEnable(GL_DEPTH_TEST) glDisable(GL_DEPTH_TEST) Enable/disable z (depth) buffer for hidden- surface removal
Remember to Initialize glutInitDisplayMode(GLUT_DOUBLE|GLUT_RBG|GLUT_DEPTH); You can also clear the depth buffer (as we did for color buffer) glClear(GL_DEPTH_BUFFER_BIT) Clear z (depth) buffer
Viewing a 3D world View up ViewRight Aspect Ratio = ViewUp View right
Viewpoint • Viewpoint – 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
Viewpoint Transformation h h w w A viewpoint is A viewpoint is defined as half the defined as the same size of the window size as the window
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.
Viewpoint 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
Lighting • Point light source - approximates the light source as a 3D point in space. Light rays emanate in all directions. • Distributed light source - approximates the light source as a 3D object. Light rays usually emanate in specific directions. • Spotlights - characterized by a narrow range of angles through which light is emitted. • Ambient light - provide uniform illumination throughout the environment. It represents the approximate contribution of the light to the general scene, regardless of location of light and object. (Background Light)
Light Model • Ambient The combination of light reflections from various surfaces to produce a uniform illumination. Background light. • Diffuse Uniform light scattering of light rays on a surface. Proportional to the “amount of light” that hits the surface. Depends on the surface normal and light vector. • Sepecular Light that gets reflected. Depends on the light ray, the viewing angle, and the surface normal.
Light Model • Light at a pixel from a light = Ambient + Diffuse + Specular Ilight = Iambient + Idiffuse + Ispecular lights−1 I light = k a La + ∑ f (dl ) [ k d Lld (L ⋅ N )+ k s Lls (R ⋅ V ) ] ns l =0
Shading • Flat Shading – Calculate one lighting calculation (pick a vertex) per triangle – Color the entire triangle the same color • Gouraud Shading – Calculate three lighting calculations (the vertices) per triangle – Linearly interpolate the colors as you scan convert • Phong Shading – While do scan convert, linearly interpolate the normals. – With the interpolated normal at each pixel, calculate the lighting at each pixel
Lighting in OpenGL • OpenGL supports the four types of light sources. • OpenGL allows at least eight light sources set in a program. • We must specify and enable individually (as exactly required by the Phong model)
Steps of Specifying Lighting • Define normal vectors for each vertex of every object. • Create, position, and enable one or more light sources. • Select a lighting model. • Define material properties for the objects in the scene. • Don’t forget to Enable/disable lighting.
Creating Light Sources • Define light properties – color, position, and direction glLight*(Glenum light, Glenum pname, TYPE param) Create the light specified by light, which can be GL_light0, GL_light1,…GL_light7. pname indicates the properties of light that will be specified with param.
Creating Light Sources • Color GLfloat light_ambient[] = {0.0, 0.0, 1.0, 1.0); GLfloat lght_diffuse[] = {1.0, 1.0, 1.0, 1.0); glLightfv (GL_LIGHT0, GL_AMBIENT, lgiht_ambient); glLightfv (GL_LIGHT1, GL_DIFFUSE, lgiht_diffuse); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1);
Creating Light Sources • Position GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0); glLightfv (GL_LIGHT0, GL_POSITION, lgiht_position); GLfloat spot_dir[] = {-1.0, -1.0, 0.0); glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, spot_dir); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1);
Creating Light Sources • Controlling a Light’s Position and Direction OpenGL treats the position and direction of a light source just as it treats the position of a geometric primitives. In other word, a light source is subject to the same matrix transformations as a primitives. – A light position that remains fixed – A light that moves around a stationary object – A light that moves along with the viewpoint
Selecting Lighting Model • OpenGL notion of a lighting model has three components: – The global ambient light intensity. – Whether the viewpoint position is local to the scene or whether it should be considered to be infinite distance away. – Whether lighting calculations should be performed differently for both the front and back faces of objects. glLightModel*(Glenum pname, TYPE param) Sets properties of the lighting model.
Selecting Lighting Model • Global ambient light GLfloat lmodel_ambient[] = {0.2, 0.3, 1.0, 1.0); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); • Local or Infinite Viewpoint glLightModelfi (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); • Two-sided Lighting glLightModelfi (GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
Defining Material Properties • OpenGL supports the setting of material properties of objects in the scene – Ambient – Diffuse – Specular – Shininess glMaterial*(Glenum face, Glenum pname, TYPE param) Specifies a current material property foe use in lighting calculations.
OpenGL Image Path
Texture Mapping in OpenGL • Steps in Texture Mapping – Create a texture object and specify a texture for that object. – Indicate how the texture is to be applied to each pixel. – Enable texture mapping. – Draw the scene, supplying both texture and geometric coordinates. • Keep in mind that texture mapping works only in RGBA mode. Texture mapping results in color- index mode are undefined.
Specifying the Texture GLubyte image[rows][cols] void glTexImage2D (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) Note: both width and height must have the form 2m+2b, where m is nonnegative integer, and b is the value of board.
Texture Object • Texture objects are an important new feature since OpenGL 1.1. A texture object stores data and makes it readily available. • To use texture objects for your texture data, take these steps: – Generate texture names. – Initially bind (create) texture objects to texture data, including the image arrays and texture properties. – Bind and rebind texture objects, making their data currently available for rendering texture models.
Naming a Texture Object • Any nonzero unsigned integer may be used as a texture name. To avoid accidentally resulting names, consistently use glGenTexture() to provide unused texture names. void glGenTextures (Glsizei n, GLuint *textureNames)
Creating and Using Texture Object • The same routine, glBindTexture(), both creates and uses texture objects. void glBindTexture (GLenum target, GLuint textureName) When using it first time, a new texture object is created. When binding to previously created texture object, that texture object becomes active. Ex: glBindTexture(GL_TEXTURE_2D, name);
Cleaning Up Texture Objects void glDeleteTexture (GLsizei n, const GLuint textureNames) Delete n texture object, named by elements in the array textureNames. The freed texture names may now be reused.
Set Texture Parameters void glTexParameter* (GLenum target, GLenum pname, TYPE param) Set various parameters that control how a texture is treated as it’s applied or stored in a texture object. How to control texture mapping and rendering?
Texture Mapping Process Object -> Texture Screen -> Object Transformation Transformation (s, t) (u, v) (x, y)
Rendering the Texture • Rendering texture is similar to shading: It proceeds across the surface pixel-by pixel. For each pixel, it must determine the corresponding texture coordinates (s, t), access the texture, and set the pixel to the proper texture color. (s, t) (u, v) (x, y)
Combining Lighting and Texturing • There is no lighting involved with texture mapping • They are independent operations, which may be combined • It all depends on how to “apply” the texture to the underlying triangle
Set Texturing Function void glTexEnv (GLenum target, GLenum pname, TYPE param) Set the current texturing function. We can use directly the texture colors to paint the object, or use the texture values to modulate or blend the color in the texture map with the original color of object. Ex: glTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)
Assigning Texture Coordinates void glTexCoord* (TYPE coords) Sets the current texture coordinates. Subsequent calls to glVertex*() result in those vertices being assigning the current texture coordinates. glBegin(GL_QUAN) { glTexCoord2f (0, 0); glVertex2f (0, 0, 5); glTexCoord2f (1, 0); glVertex2f (10, 0, 5); glTexCoord2f (1, 1); glVertex2f (10, 10, 5); glTexCoord2f (0, 1); glVertex2f (0, 10, 5); }
Remember to Enable Texture glEnable (GL_TEXTURE_2D) glDisable (GL_TEXTURE_2D) Enable/disable texture mapping
Automatic Texture-Coordinate Generation • OpenGL can automatically generate texture coordinate for you. void glTexGen* (GLenum coord, GLenum pname, TYPE param Specifies the function for automatically generating texture coordinates. coord: GL_S, GL_T, GL_R, GL_Q
Recall Aliasing • Aliasing manifests itself as “jaggies” in graphics. Thus we don’t have enough pixels to accurately represent the underlying function. • Three reasons – Pixel numbers are fixed in the frame buffer – Pixel locations are fixed on a uniform – Pixel size/shape are fixed • How do we fix it? – Increase resolution – Filtering
Increase Rendering Resolution • Render the image at a higher resolution and downsample (like you are letting your eye do some filtering).
Mip Mapping • MIP - multium in parvo - many in a small place. • Build a pyramid of images, each smaller and filtered from the original.
Mipmapping • Thus as we render, we choose the texture that best “fits” what you are drawing. • OpenGL supports mipmapping gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, image); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
Bump Mapping • We can also use textures for so much more than just images! • We can use the textures as a “road map” on how to perturb normals across a surface. • As we shade each pixel, perturb the normal by the partial derivatives of the corresponding s, t in the bump map.
Environmental Mapping • Highly reflective surface are characterized by specular reflections that mirror the environment. • We can extend our mapping techniques to obtain an image that approximates the desired reflection by extending texture maps to environmental (reflection) maps.
Environmental Mapping • Two-pass texture mapping (1) Map the texture to a 3D intermediate surface. (2) Map the intermediate surface to the surface being rendered. Object in environment Intermediate surface Projected object
Environmental Mapping • Then, we need to map the texture values on the intermediate surface to the desired surface. n n n
Now It’s Your Turn • Find a good reference/book • Play with an example • Make your own code Computer graphics is best learned by doing!

More Related Content

PPTX
What is OpenGL ?
byMohammad Hosein Nemati
 
PPT
Open gl
bych samaram
 
PPT
Seed filling algorithm
byMani Kanth
 
PPT
lecture2 computer graphics graphics hardware(Computer graphics tutorials)
byDaroko blog(www.professionalbloggertricks.com)
 
PDF
Unit-1 basics of computer graphics
byAmol Gaikwad
 
PPTX
3D Graphics : Computer Graphics Fundamentals
byMuhammed Afsal Villan
 
PDF
18csl67 vtu lab manual
byNatsuDragoneel5
 
PPT
Polygon filling
byAnkit Garg
 
What is OpenGL ?
byMohammad Hosein Nemati
 
Open gl
bych samaram
 
Seed filling algorithm
byMani Kanth
 
lecture2 computer graphics graphics hardware(Computer graphics tutorials)
byDaroko blog(www.professionalbloggertricks.com)
 
Unit-1 basics of computer graphics
byAmol Gaikwad
 
3D Graphics : Computer Graphics Fundamentals
byMuhammed Afsal Villan
 
18csl67 vtu lab manual
byNatsuDragoneel5
 
Polygon filling
byAnkit Garg
 

What's hot

PPT
Programming with OpenGL
bySyed Zaid Irshad
 
PPT
OpenGL Basics
bySandip Jadhav
 
PDF
Opengl basics
bypushpa latha
 
PPTX
Model Based Software Architectures
byMunazza-Mah-Jabeen
 
PPTX
OpenGL Introduction
byJayant Mukherjee
 
PDF
Computer graphics curves and surfaces (1)
byRohitK71
 
PPTX
Anti- aliasing computer graphics
bySafayet Hossain
 
PPTX
Polygon filling algorithm
byAparna Joshi
 
PPT
Shading
byAmit Kapoor
 
PPTX
Opengl presentation
byelnaqah
 
PDF
Principles of programming languages. Detail notes
byVIKAS SINGH BHADOURIA
 
PPTX
Computer animation Computer Graphics
byUniversity of Potsdam
 
PDF
Computer graphics notes
bysmruti sarangi
 
PPT
Line drawing algo.
byMohd Arif
 
PPTX
Computer graphics basic transformation
bySelvakumar Gna
 
PPTX
Depth Buffer Method
byUmmiya Mohammedi
 
PPTX
Artifacts
byMayuresh Wadekar
 
PPTX
Windows to viewport transformation
byPrashant Singh
 
PPTX
Introduction and Application of Computer Graphics.
byBhautik Jethva
 
PPT
GRPHICS06 - Shading
byMichael Heron
 
Programming with OpenGL
bySyed Zaid Irshad
 
OpenGL Basics
bySandip Jadhav
 
Opengl basics
bypushpa latha
 
Model Based Software Architectures
byMunazza-Mah-Jabeen
 
OpenGL Introduction
byJayant Mukherjee
 
Computer graphics curves and surfaces (1)
byRohitK71
 
Anti- aliasing computer graphics
bySafayet Hossain
 
Polygon filling algorithm
byAparna Joshi
 
Shading
byAmit Kapoor
 
Opengl presentation
byelnaqah
 
Principles of programming languages. Detail notes
byVIKAS SINGH BHADOURIA
 
Computer animation Computer Graphics
byUniversity of Potsdam
 
Computer graphics notes
bysmruti sarangi
 
Line drawing algo.
byMohd Arif
 
Computer graphics basic transformation
bySelvakumar Gna
 
Depth Buffer Method
byUmmiya Mohammedi
 
Artifacts
byMayuresh Wadekar
 
Windows to viewport transformation
byPrashant Singh
 
Introduction and Application of Computer Graphics.
byBhautik Jethva
 
GRPHICS06 - Shading
byMichael Heron
 

Viewers also liked

PPTX
Lecture 6 introduction to open gl and glut
bysimpleok
 
PDF
Introduction of openGL
byGary Yeh
 
PDF
OpenGL Introduction
byYi-Lung Tsai
 
PDF
OpenGL L01-Primitives
byMohammad Shaker
 
ODP
Opengl Lighting Basic
byMohammad Zunayed Hassan
 
PPTX
3 d graphics with opengl part 2
bySardar Alam
 
PPTX
Opengl lec 3
byelnaqah
 
PPT
Order Independent Transparency
byacbess
 
PPT
Shadow Mapping with Today's OpenGL Hardware
byMark Kilgard
 
PPT
Week 2 understand lighting (semester 1)
byUniversiti Teknologi MARA
 
PPT
OpenGL for 2015
byMark Kilgard
 
PDF
CG OpenGL polar curves & input display color-course 4
byfungfung Chen
 
PDF
OpenGL Interaction
bySandip Jadhav
 
PPT
SIGGRAPH 2012: NVIDIA OpenGL for 2012
byMark Kilgard
 
PDF
OpenGL Transformation
bySandip Jadhav
 
PDF
OpenGL Starter L01
byMohammad Shaker
 
PPTX
Chapter02 graphics-programming
byMohammed Romi
 
PPTX
Cgp lecture1 introduction
byJavkhlan Rentsendorj
 
KEY
jQTouch at jQuery Conference 2010
byDavid Kaneda
 
PDF
OpenGL Starter L02
byMohammad Shaker
 
Lecture 6 introduction to open gl and glut
bysimpleok
 
Introduction of openGL
byGary Yeh
 
OpenGL Introduction
byYi-Lung Tsai
 
OpenGL L01-Primitives
byMohammad Shaker
 
Opengl Lighting Basic
byMohammad Zunayed Hassan
 
3 d graphics with opengl part 2
bySardar Alam
 
Opengl lec 3
byelnaqah
 
Order Independent Transparency
byacbess
 
Shadow Mapping with Today's OpenGL Hardware
byMark Kilgard
 
Week 2 understand lighting (semester 1)
byUniversiti Teknologi MARA
 
OpenGL for 2015
byMark Kilgard
 
CG OpenGL polar curves & input display color-course 4
byfungfung Chen
 
OpenGL Interaction
bySandip Jadhav
 
SIGGRAPH 2012: NVIDIA OpenGL for 2012
byMark Kilgard
 
OpenGL Transformation
bySandip Jadhav
 
OpenGL Starter L01
byMohammad Shaker
 
Chapter02 graphics-programming
byMohammed Romi
 
Cgp lecture1 introduction
byJavkhlan Rentsendorj
 
jQTouch at jQuery Conference 2010
byDavid Kaneda
 
OpenGL Starter L02
byMohammad Shaker
 

Similar to OpenGL Introduction.

PPT
Opengl (1)
bych samaram
 
PPT
01.Opengl_intro-2.ppt
byEngrZamaan
 
PPT
Hill ch2ed3
byKunal Verma
 
PPTX
Computer Graphics with OpenGL presentation Slides.pptx
byAnandM62785
 
PPT
opengl.ppt
bySubiksha57
 
PPT
Intro to Computer Graphics.ppt
byadil104135
 
PPT
3.Computer graphics _ Opengl _ intro.ppt
bydinasaif3
 
PPT
Open Graphics Library
byAzmeen Gadit
 
PPTX
UNIT 1 OPENGL_UPDATED .pptx
bymiteshchaudhari4466
 
PPT
openGL basics for sample program (1).ppt
byHIMANKMISHRA2
 
PPT
openGL basics for sample program.ppt
byHIMANKMISHRA2
 
DOCX
Computer graphics workbook
byMuhammadalizardari
 
PDF
Airplane game management system project report .pdf
byKamal Acharya
 
PDF
AN INTERNSHIP REPORT ON AIRPLANE GAME MANAGEMENT SYSTEM PROJECT REPORT.
byKamal Acharya
 
PPTX
Computer Graphics Project on Sinking Ship using OpenGL
bySharath Raj
 
PPTX
OpenGL_summer2012.ccccccccccccccccccpptx
byarcse1
 
DOCX
Lab Practices and Works Documentation / Report on Computer Graphics
byRup Chowdhury
 
PDF
OpenGL_Programming_Guide.pdf
byRavinderKSingla
 
PPTX
Baiscs of OpenGL
byMrinmoy Dalal
 
PDF
201801 SER332 Lecture 03
byJavier Gonzalez-Sanchez
 
Opengl (1)
bych samaram
 
01.Opengl_intro-2.ppt
byEngrZamaan
 
Hill ch2ed3
byKunal Verma
 
Computer Graphics with OpenGL presentation Slides.pptx
byAnandM62785
 
opengl.ppt
bySubiksha57
 
Intro to Computer Graphics.ppt
byadil104135
 
3.Computer graphics _ Opengl _ intro.ppt
bydinasaif3
 
Open Graphics Library
byAzmeen Gadit
 
UNIT 1 OPENGL_UPDATED .pptx
bymiteshchaudhari4466
 
openGL basics for sample program (1).ppt
byHIMANKMISHRA2
 
openGL basics for sample program.ppt
byHIMANKMISHRA2
 
Computer graphics workbook
byMuhammadalizardari
 
Airplane game management system project report .pdf
byKamal Acharya
 
AN INTERNSHIP REPORT ON AIRPLANE GAME MANAGEMENT SYSTEM PROJECT REPORT.
byKamal Acharya
 
Computer Graphics Project on Sinking Ship using OpenGL
bySharath Raj
 
OpenGL_summer2012.ccccccccccccccccccpptx
byarcse1
 
Lab Practices and Works Documentation / Report on Computer Graphics
byRup Chowdhury
 
OpenGL_Programming_Guide.pdf
byRavinderKSingla
 
Baiscs of OpenGL
byMrinmoy Dalal
 
201801 SER332 Lecture 03
byJavier Gonzalez-Sanchez
 
In this document
Powered by AI
See More

Introduction to Graphics Programming using OpenGL and its rendering pipeline, including utility toolkits and the API.

Explains the graphics process, the role of a graphics API, and the architecture of OpenGL separating core library and utility libraries.

Detailing OpenGL libraries, headers, and the usage of the GLUT toolkit for window management within OpenGL.

Introduction to OpenGL-specific data types for C language compatibility and function naming conventions.

The basic framework for writing OpenGL applications, including window setup, initialization, and event handling.

Detailed discussion on rendering, including callbacks for display, window resizing, and the graphics pipeline.

Explains transformation matrices and their role in moving and manipulating objects in OpenGL.

Introduction to lighting models, ways to create light sources, and definitions of material properties in OpenGL.

Overview of texture mapping processes, including specifying textures and parameters for rendering texturing.

Discusses advanced techniques in OpenGL, including mipmapping, bump mapping, and environmental mapping.

Encouraging practical engagement with OpenGL through experimentation and coding.

OpenGL Introduction.

  • 1.
    Graphics Programming Introduction to OpenGL
  • 2.
    Outline • What is OpenGL • OpenGL Rendering Pipeline • OpenGL Utility Toolkits • OpenGL Coding Framework • OpenGL API
  • 3.
    Graphics System Function calls Output User User Graphics Graphics I/O I/O Program Program System System Device Device Data Input Graphics API
  • 4.
    What is OpenGL OpenGL • A software interface to graphics hardware • A 3D graphics rendering API (>120 functions) • Hardware independent • Very fast (a standard to be accelerated) • Portable http://www.opengl.org
  • 5.
    A History ofOpenGL • Was SGI’s Iris GL – “Open”GL • “Open” standard allowing for wide range hardware platforms • OpenGL v1.0 (1992) • OpenGL v1.1 (1995) • OpenGL v1.4 (latest) • Governed by OpenGL Architecture Review Board (ARB) “Mesa” – an Open source (http://www.mesa3d.org)
  • 6.
    Graphics Process Geometric Primitives Rendering Rendering Frame Buffer Image Primitives + =
  • 7.
  • 8.
    OpenGL is Nota Language It is a Graphics Rendering API 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++) that makes calls to one or more of OpenGL libraries
  • 9.
    Window Management • OpenGLis 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
  • 10.
    Window Management API Weneed 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
  • 11.
  • 12.
    OpenGL Division ofLabor • 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
  • 13.
    Libraries and Headers Library Name Library File Header File Note OpenGL opengl32.lib (PC) gl.h “core” library -lgl (UNIX) Auxiliary library glu32.lib (PC) glu.h handles a -lglu variety of accessory functions Utility toolkits glut32.lib (PC) glut.h window -lglut (UNIX) glaux.h managements glaux.lib (PC) -lglaux (UNIX) All are presented in the C language
  • 14.
    Learning OpenGL withGLUT • GLUT is a Window Manager (handles window creation, user interaction, callbacks, etc) • Platform Independent • Makes it easy to learn and write OpenGL programs without being distracted by your environment • Not “final” code (Not meant for commercial products)
  • 15.
    Environment Setup • Allof our discussions will be presented in C/C++ language • Use GLUT library for window managements • Files needed gl.h, glu.h, glut.h opengl32.lib, glu32.lib, glut32.lib • Go to http://www.opengl.org download files • Follow the Setup instruction to configure proper path
  • 16.
    Usage Include the necessaryheader files in your code #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
  • 17.
    Usage Link the necessaryLibraries 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)
  • 18.
    OpenGL Data Types Tomake 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;
  • 19.
    OpenGL Data Types OpenGL Data Type Representation As 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
  • 20.
    OpenGL Function Naming OpenGLfunctions 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>
  • 21.
    OpenGL Function Naming glColor3f(…) gl library Root command, # of arguments, type of arguments gl means OpenGL f: the argument is float type glu means GLU i: the argument is integer type glut means GLUT v: the argument requires a vector
  • 22.
    Basic OpenGL CodingFramework 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()
  • 23.
    A Sample Program voidmain (int argc, char **argv) { glutInit (&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (500, 500); 1 glutCreateWindow (“My First Program"); myinit (); 2 glutDisplayFunc ( display ); glutReshapeFunc ( resize ); 3 glutKeyboardFunc ( key ); glutMainLoop (); 4 }
  • 24.
    1: Initializing &Creating Window Set up window/display you’re 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 …… }
  • 25.
    GLUT Initializing Functions •Standard GLUT initialization glutInit (int argc, char ** argv) • Display model glutInitDisplayMode (unsigned int mode) • Window size and position glutInitWindowSize (int width, int height) glutInitWindowPosition(int x, int y) • Create window glutCreateWindow (char *name);
  • 26.
    2: Initializing OpenGLState Set up whatever state you’re 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_MODELVIEW); }
  • 27.
    Callback Functions • CallbackFunction Routine to call when something happens - window resize, redraw, user input, etc • GLUT uses a callback mechanism to do its event processing
  • 28.
    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()
  • 29.
    3: Register CallbackFunctions Set up any callback function you’re going to use void main (int argc, char **argv) { …… glutDisplayFunc ( display ); // display callback glutReshapeFunc ( resize ); // window resize callback glutKeyboardFunc ( key ); // keyboard callback …… }
  • 30.
    Rendering Callback It’s herethat does all of your OpenGL rendering void display( void ) { typedef GLfloat point2[2]; point2 vertices[3]={{0.0, 0.0}, {250.0, 500.0}, {500.0, 0.0}}; int i, j, k; int rand(); glClear(GL_COLOR_BUFFER_BIT); for( k=0; k<5000; k++) …… }
  • 31.
    Window Resize Callback It’scalled when the window is resized or moved void resize(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); …… display(); }
  • 32.
    Keyboard Input Callback It’scalled when a key is struck on the keyboard void key( char mkey, int x, int y ) { switch( mkey ) { case ‘q’ : exit( EXIT_SUCCESS ); break; …… }
  • 33.
    Event Process Loop Thisis where your application receives events, and schedules when callback functions are called void main (int argc, char **argv) { …… glutMainLoop(); }
  • 34.
    Let’s go Inside •OpenGL API – Geometric Primitives – Color Mode – Managing OpenGL’s State – Transformations – Lighting and shading – Texture mapping
  • 35.
    OpenGL API Functions •Primitives – A point, line, polygon, bitmap, or image • Transformation – Rotation, size, perspective in 3D coordinate space • Color mode – RGB, RGBA, Color index • Materials lighting and shading – Accurately compute the color of any point given the material properties • Buffering – Double buffering, Z-buffering, Accumulation buffer • Texture mapping ……
  • 36.
    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
  • 37.
    Geometry Commands • glBegin(GLenumtype) 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
  • 38.
    Specifying Geometric Primitives glBegin( type ); glVertex*(…); …… glVertex*(…); glEnd(); type determines how vertices are combined
  • 39.
    Example void drawSquare (GLfloat*color) { glColor3fv ( color ); glBegin(GL_POLYGON); glVertex2f ( 0.0, 0.0 ); glVertex2f ( 1.0, 0.0 ); glVertex2f ( 1.1, 1.1 ); glVertex2f ( 0.0, 1.0 ); glEnd(); }
  • 40.
    Primitives and Attributes •Draw what… – Geometric primitives • points, lines and polygons • How to draw… – Attributes • colors, lighting, shading, texturing, etc.
  • 41.
    Attributes • An attributeis any property that determines how a geometric primitives is to be rendered • Each time, OpenGL processes a vertex, it uses data stored in its internal attribute tables to determine how the vertex should be transformed, rendered or any of OpenGL’s other modes
  • 42.
    Example glPointSize(3.0); glShadeModel(GL_SMOOTH); glBegin(GL_LINE); glColor4f(1.0, 1.0, 1.0, 1.0); glVertex2f(5.0, 5.0); glColor3f(0.0, 1.0, 0.0); glVertex2f(25.0, 5.0); glEnd();
  • 43.
    OpenGL Color • Thereare two color models in OpenGL – RGB Color (True Color) – Indexed Color (Color map) • The type of window color model is requested from the windowing system. OpenGL has no command to control
  • 44.
    Color Cube Three colortheory C = T1*R + T2*G + T3* B
  • 45.
    RGB Color • R,G, B components are stored for each pixel • With RGB mode, each pixel’s color is independent of each other
  • 46.
  • 47.
    How Many Colors? color_depth Color number = 2 For example: 4-bit color 4 2 = 16 colors 8-bit color 8 2 = 256 colors 24-bit color 224 = 16.77 million colors
  • 48.
    How Much Memory? Buffersize = width * height *color depth For example: If width = 640, height = 480, color depth = 24 bits Buffer size = 640 * 480 * 24 = 921,600 bytes If width = 640, height = 480, color depth = 32 bits Buffer size = 640 * 480 * 32 = 1,228,800 bytes
  • 49.
    Alpha Component Alpha value A value indicating the pixels opacity Zero usually represents totally transparent and the maximum value 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
  • 50.
    RGB Color Commands •glColor*(…) specifies vertex colors • glClearColor(r, g, b, a) sets current color for cleaning color buffer • glutInitDisplayMode(mode) specify either an RGBA window (GLUT_RGBA ), or a color indexed window (GLUT_INDEX )
  • 51.
    Example glutInitDisplayMode (GLUT_RGBA); glClearColor(1.0, 1.0,1.0, 1.0); void drawLine (GLfloat *color) { glColor3fv ( color ); glBegin(GL_LINE); glVertex2f ( 0.0, 0.0 ); glVertex2f ( 1.0, 0.0 ); glEnd(); }
  • 52.
    Indexed Color • Historically,color-index mode was important because it required less memory • Use Color-map (lookup table) • With color-index mode, each pixel with same index stored in its bit-planes shares the same color-map location
  • 53.
    Color Lookup Table Index Red Green Blue 0 0 0 0 1 120 123 187 … 253 … … … 254 255 8 bits 8 bits 8 bits
  • 54.
    RGBA vs. ColorIndex Mode Color index model Index R G B 0 0 0 0 1 120 123 187 2 … … … … 254 255 RGBA model
  • 55.
    Color Index Commands •glIndex*(…) specifies vertex colors • glClearIndex(Glfloat index) sets current color for cleaning color buffer. • glutSetColor(int color, GLfloat r, GLfloat g, GLfloat b ) sets the entries in a color table for window.
  • 56.
    Shading Model Green Red Blue (0, 0, 0) (128, 128, 128) (255, 255, 255) Black Gray White
  • 57.
    Shading Model Green Red Blue A triangle in RGB color space Smooth shading in OpenGL
  • 58.
    Shading Model Commands •glShadeModel(mode) set the shading mode. The mode parameter can be GL_SMOOTH (the default) or GL_FLAT. Flat shading: the color of one particular vertex of an independent primitive is duplicated across all the primitive’s vertices to render that primitive. Smooth shading: the color at each vertex is treated individually. The colors of interior pixels are interpolated.
  • 59.
    OpenGL’s State Machine InOpenGL, all rendering attributes are encapsulated in the OpenGL State – rendering styles – color – shading – lighting – texture mapping
  • 60.
    OpenGL’s State Management •Setting Vertex Attributes – glPointSize(...) -- point size – glLineWidth(…) -- line width – glColor*(…) -- color Attributes – glNormal*(…) -- normal – glTexCoord*(…) -- texturing • Controlling State Functions – glEnable(…) – glDisable(…)
  • 61.
    Controlling State Functions •OpenGL has many states and state variables can be changed to control rendering Ex. – GL_LIGHTING – GL_DEPTH_TEST – GL_SHADE_MODEL – GL_LINE_STIPPLE ……
  • 62.
    Controlling State Functions •By default, most of the states are initially inactive. These states can be turn on/off by using: • glEnable (Glenum state) turn on a state • glDisable (Glenum state) turn off a state
  • 63.
    Example glEnable(GL_LIGHTING); glShadeModel(GL_SMOOTH); glBegin(GL_LINE); glColor3f(1.0, 1.0, 1.0); glVertex2f(5.0, 5.0); glColor3f(0.0, 1.0, 0.0); glVertex2f(25.0, 5.0); glEnd(); glDisable(GL_LIGHTING);
  • 64.
    OpenGL Transformations Model View direction View position (eyepoint)
  • 65.
    Graphics Pipeline Object Transformation Object Coordinates Object -> World World Transformation World Coordinates World -> Viewport Viewport Clipping Viewport Coordinates Screen Coordinates Rasterization Scan Converting Triangles
  • 66.
    Camera Analogy The graphicstransformation process is analogous to taking a photograph with a camera - Position camera - Place objects - Adjust camera - Produce photograph
  • 67.
    Transformations and CameraAnalogy • Viewing transformation – Positioning and aiming camera in the world. • Modeling transformation – Positioning and moving the model. • Projection transformation – Adjusting the lens of the camera. • Viewport transformation – Enlarging or reducing the physical photograph.
  • 68.
  • 69.
    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.
  • 70.
    Programming Transformations • InOpenGL, 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.
  • 71.
    Steps in Programming •Define matrices: – Viewing/modeling, projection, viewport … • Manage the matrices – Including matrix stack • Composite transformations
  • 72.
    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.
  • 73.
    Current Transformation Matrix TheCTM 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
  • 74.
    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=MTRS
  • 75.
    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” …..
  • 76.
    Viewing Position y R, T y x z x • Translation Camera • Rotation z
  • 77.
    Where I amand Looking at y y Loot at View-up vector (atx, aty, atz) (upx, upy, upz) x x Model z z Eyepoint (eyex, eyey, eyez)
  • 78.
    Define Coordinate System +Y In the default position, the camera is at the origin, looking down the +X negative z-axis +Z
  • 79.
    If we useOpenGL • 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.
  • 80.
    Ways to SpecifyTransformations • In OpenGL, we usually have two styles of specifying transformations: – Specify matrices ( glLoadMatrix, glMultMatrix ) – Specify operations ( glRotate, glTranslate )
  • 81.
    Specifying Matrix • Specify current matrix mode • Modify current matrix • Load current matrix • Multiple current matrix
  • 82.
    Specifying Matrix (1) •Specify current matrix mode glMatrixMode (mode) Specified what transformation matrix is modified. mode: GL_MODELVIEW GL_PROJECTION
  • 83.
    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
  • 84.
    Specifying Matrix (3) •Modify current matrix glLoadIdentity ( void ) Set the currently modifiable matrix to the 4x4 identity matrix.
  • 85.
    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
  • 86.
    Specifying Operations • ThreeOpenGL operation routines for modeling transformations: – Translation – Scale – Rotation
  • 87.
    Recall • Three elementary3D transformations ⎡1 0 0 d x⎤ ⎢ ⎥ Translation: T ( dx, dy , d z ) = ⎢0 ⎢0 1 0 0 1 d y⎥ d z⎥ ⎢ ⎥ ⎣0 0 0 1⎦ ⎡sx 0 0 0⎤ ⎢ ⎥ S (sx , s y , s z) ⎢ 0 sy 0 0⎥ Scale: =⎢ 0 0 sz 0⎥ ⎢ ⎥ ⎣0 0 0 1⎦
  • 88.
    Recall ⎡1 0 0 0⎤ ⎢ ⎥ Rotation Rx (θ ) Rx (θ ) = ⎢0 cosθ − sin θ 0⎥ ⎢0 sin θ cosθ 0⎥ ⎢ ⎥ ⎣0 0 0 1⎦ ⎡ cosθ 0 sin θ 0⎤ ⎢ ⎥ Rotation Ry (θ ) Ry(θ ) = ⎢ 0 1 0 0⎥ ⎢− sin θ 0 cosθ 0⎥ ⎢ ⎥ ⎣ 0 0 0 1⎦ ⎡cosθ − sin θ 0 0⎤ ⎢ ⎥ Rotation Rz (θ ) sin θ cosθ 0 0⎥ Rz (θ ) = ⎢ ⎢ 0 0 1 0⎥ ⎢ ⎥ ⎣ 0 0 0 1⎦
  • 89.
    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.
  • 90.
    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.
  • 91.
    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.
  • 92.
    Example Let’s examine anexample: – Rotation about an arbitrary point Question: Rotate a object for a 45.0-degree about the line through the origin and the point (1.0, 2.0, 3.0) with a fixed point of (4.0, 5.0, 6.0).
  • 93.
    Rotation About anArbitrary Point 1. Translate object through vector –V. T(-4.0, -5.0, -6.0) 2. Rotate about the origin through angle θ. R(45.0) 3. Translate back through vector V T(4.0, 5.0, 6.0) M = T(V ) R(θ ) T(-V )
  • 94.
    OpenGL Implementation glMatrixMode (GL_MODEVIEW); glLoadIdentity(); glTranslatef (4.0, 5.0, 6.0); glRotatef (45.0, 1.0, 2.0, 3.0); glTranslatef (-40.0, -5.0, -6.0);
  • 95.
    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.
  • 96.
    Order of Transformations •In each step: C <= I C <= CT(4.0, 5.0, 6.0) C <= CR(45, 1.0, 2.0, 3.0) C < = 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) Write it Read it
  • 97.
    Matrix Multiplication isNot Commutative First rotate, then translate => First translate, then rotate =>
  • 98.
    Matrix Stacks • OpenGLuses 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
  • 99.
    Matrix Stacks • Current matrix is always the topmost matrix of the stack Pushing • We manipulate the Popping current matrix is that Top we actually manipulate the topmost matrix. • We can control the Bottom current matrix by using push and pop operations.
  • 100.
    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()
  • 101.
    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()
  • 102.
    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
  • 103.
    Projection Transformation • Projection& Viewing Volume • Projection Transformation • Viewpoint Transformation
  • 104.
    OpenGL and WindowsScreen Windows Screen Mapping OpenGL Screen Mapping X Y (0, 0) Positive Positive (50, 50) (50, 50) Positive (0, 0) X Y Positive Remember: the Y coordinates of OpenGL screen is the opposite of Windows screen. But same as in the XWindows system.
  • 105.
    Orthographic Projection • Vertexesof an object are projected towards infinity • Points projected outside view volume are clipped out • Distance does not change the apparent size of an object Clipped out Image
  • 106.
    Orthographic Viewing Volume Clipped out top left right Bottom Near-plane Far-plane Viewing rectangle Viewing volume
  • 107.
    Orthographic Projection Commands •glOrtho( left, right, bottom, top, zNear, zFar ) Creates a matrix for an orthographic viewing volume and multiplies the current matrix by it • gluOrtho2D( left, right, bottom, top ) Creates a matrix for projecting 2D coordinates onto the screen and multiplies the current matrix by it
  • 108.
    Orthographic Projection (Example) Define a 500x500 viewing rectangle with the lower-left corner of the rectangle at the origin of the 2D system glMatrixMode(GL_PROJECTION) glLoadIdentity(); gluOrtho2D(0.0, 500.0, 0.0, 500.0); glMatrixMode(GL_MODELVIEW);
  • 109.
    Perspective Projection Volume y aspect ratio = w/h w h z fovy x Far-plane: zNear Near-plane: zNear Viewing volume
  • 110.
    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.
  • 111.
    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
  • 112.
    Hidden-Surface Removal z-buffer algorithm -Image-space check - The worst-case complexity is proportional to the number of polygons z2 z1 - Requires a depth or z buffer to store the information as polygons are rasterized Viewpoint
  • 113.
    Hidden-Surface Removal glEnable(GL_DEPTH_TEST) glDisable(GL_DEPTH_TEST) Enable/disable z (depth) buffer for hidden- surface removal
  • 114.
    Remember to Initialize glutInitDisplayMode(GLUT_DOUBLE|GLUT_RBG|GLUT_DEPTH); You can also clear the depth buffer (as we did for color buffer) glClear(GL_DEPTH_BUFFER_BIT) Clear z (depth) buffer
  • 115.
    Viewing a 3Dworld View up ViewRight Aspect Ratio = ViewUp View right
  • 116.
    Viewpoint • Viewpoint – 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
  • 117.
    Viewpoint Transformation h h w w A viewpoint is A viewpoint is defined as half the defined as the same size of the window size as the window
  • 118.
    Aspect Ratio • TheAspect 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.
  • 119.
    Viewpoint 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
  • 120.
    Lighting • Point lightsource - approximates the light source as a 3D point in space. Light rays emanate in all directions. • Distributed light source - approximates the light source as a 3D object. Light rays usually emanate in specific directions. • Spotlights - characterized by a narrow range of angles through which light is emitted. • Ambient light - provide uniform illumination throughout the environment. It represents the approximate contribution of the light to the general scene, regardless of location of light and object. (Background Light)
  • 121.
    Light Model • Ambient The combination of light reflections from various surfaces to produce a uniform illumination. Background light. • Diffuse Uniform light scattering of light rays on a surface. Proportional to the “amount of light” that hits the surface. Depends on the surface normal and light vector. • Sepecular Light that gets reflected. Depends on the light ray, the viewing angle, and the surface normal.
  • 122.
    Light Model • Lightat a pixel from a light = Ambient + Diffuse + Specular Ilight = Iambient + Idiffuse + Ispecular lights−1 I light = k a La + ∑ f (dl ) [ k d Lld (L ⋅ N )+ k s Lls (R ⋅ V ) ] ns l =0
  • 123.
    Shading • Flat Shading – Calculate one lighting calculation (pick a vertex) per triangle – Color the entire triangle the same color • Gouraud Shading – Calculate three lighting calculations (the vertices) per triangle – Linearly interpolate the colors as you scan convert • Phong Shading – While do scan convert, linearly interpolate the normals. – With the interpolated normal at each pixel, calculate the lighting at each pixel
  • 124.
    Lighting in OpenGL •OpenGL supports the four types of light sources. • OpenGL allows at least eight light sources set in a program. • We must specify and enable individually (as exactly required by the Phong model)
  • 125.
    Steps of SpecifyingLighting • Define normal vectors for each vertex of every object. • Create, position, and enable one or more light sources. • Select a lighting model. • Define material properties for the objects in the scene. • Don’t forget to Enable/disable lighting.
  • 126.
    Creating Light Sources •Define light properties – color, position, and direction glLight*(Glenum light, Glenum pname, TYPE param) Create the light specified by light, which can be GL_light0, GL_light1,…GL_light7. pname indicates the properties of light that will be specified with param.
  • 127.
    Creating Light Sources •Color GLfloat light_ambient[] = {0.0, 0.0, 1.0, 1.0); GLfloat lght_diffuse[] = {1.0, 1.0, 1.0, 1.0); glLightfv (GL_LIGHT0, GL_AMBIENT, lgiht_ambient); glLightfv (GL_LIGHT1, GL_DIFFUSE, lgiht_diffuse); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1);
  • 128.
    Creating Light Sources •Position GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0); glLightfv (GL_LIGHT0, GL_POSITION, lgiht_position); GLfloat spot_dir[] = {-1.0, -1.0, 0.0); glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, spot_dir); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1);
  • 129.
    Creating Light Sources •Controlling a Light’s Position and Direction OpenGL treats the position and direction of a light source just as it treats the position of a geometric primitives. In other word, a light source is subject to the same matrix transformations as a primitives. – A light position that remains fixed – A light that moves around a stationary object – A light that moves along with the viewpoint
  • 130.
    Selecting Lighting Model •OpenGL notion of a lighting model has three components: – The global ambient light intensity. – Whether the viewpoint position is local to the scene or whether it should be considered to be infinite distance away. – Whether lighting calculations should be performed differently for both the front and back faces of objects. glLightModel*(Glenum pname, TYPE param) Sets properties of the lighting model.
  • 131.
    Selecting Lighting Model •Global ambient light GLfloat lmodel_ambient[] = {0.2, 0.3, 1.0, 1.0); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); • Local or Infinite Viewpoint glLightModelfi (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); • Two-sided Lighting glLightModelfi (GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
  • 132.
    Defining Material Properties •OpenGL supports the setting of material properties of objects in the scene – Ambient – Diffuse – Specular – Shininess glMaterial*(Glenum face, Glenum pname, TYPE param) Specifies a current material property foe use in lighting calculations.
  • 133.
  • 134.
    Texture Mapping inOpenGL • Steps in Texture Mapping – Create a texture object and specify a texture for that object. – Indicate how the texture is to be applied to each pixel. – Enable texture mapping. – Draw the scene, supplying both texture and geometric coordinates. • Keep in mind that texture mapping works only in RGBA mode. Texture mapping results in color- index mode are undefined.
  • 135.
    Specifying the Texture GLubyteimage[rows][cols] void glTexImage2D (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) Note: both width and height must have the form 2m+2b, where m is nonnegative integer, and b is the value of board.
  • 136.
    Texture Object • Textureobjects are an important new feature since OpenGL 1.1. A texture object stores data and makes it readily available. • To use texture objects for your texture data, take these steps: – Generate texture names. – Initially bind (create) texture objects to texture data, including the image arrays and texture properties. – Bind and rebind texture objects, making their data currently available for rendering texture models.
  • 137.
    Naming a TextureObject • Any nonzero unsigned integer may be used as a texture name. To avoid accidentally resulting names, consistently use glGenTexture() to provide unused texture names. void glGenTextures (Glsizei n, GLuint *textureNames)
  • 138.
    Creating and UsingTexture Object • The same routine, glBindTexture(), both creates and uses texture objects. void glBindTexture (GLenum target, GLuint textureName) When using it first time, a new texture object is created. When binding to previously created texture object, that texture object becomes active. Ex: glBindTexture(GL_TEXTURE_2D, name);
  • 139.
    Cleaning Up TextureObjects void glDeleteTexture (GLsizei n, const GLuint textureNames) Delete n texture object, named by elements in the array textureNames. The freed texture names may now be reused.
  • 140.
    Set Texture Parameters voidglTexParameter* (GLenum target, GLenum pname, TYPE param) Set various parameters that control how a texture is treated as it’s applied or stored in a texture object. How to control texture mapping and rendering?
  • 141.
    Texture Mapping Process Object -> Texture Screen -> Object Transformation Transformation (s, t) (u, v) (x, y)
  • 142.
    Rendering the Texture •Rendering texture is similar to shading: It proceeds across the surface pixel-by pixel. For each pixel, it must determine the corresponding texture coordinates (s, t), access the texture, and set the pixel to the proper texture color. (s, t) (u, v) (x, y)
  • 143.
    Combining Lighting andTexturing • There is no lighting involved with texture mapping • They are independent operations, which may be combined • It all depends on how to “apply” the texture to the underlying triangle
  • 144.
    Set Texturing Function voidglTexEnv (GLenum target, GLenum pname, TYPE param) Set the current texturing function. We can use directly the texture colors to paint the object, or use the texture values to modulate or blend the color in the texture map with the original color of object. Ex: glTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)
  • 145.
    Assigning Texture Coordinates voidglTexCoord* (TYPE coords) Sets the current texture coordinates. Subsequent calls to glVertex*() result in those vertices being assigning the current texture coordinates. glBegin(GL_QUAN) { glTexCoord2f (0, 0); glVertex2f (0, 0, 5); glTexCoord2f (1, 0); glVertex2f (10, 0, 5); glTexCoord2f (1, 1); glVertex2f (10, 10, 5); glTexCoord2f (0, 1); glVertex2f (0, 10, 5); }
  • 146.
    Remember to EnableTexture glEnable (GL_TEXTURE_2D) glDisable (GL_TEXTURE_2D) Enable/disable texture mapping
  • 147.
    Automatic Texture-Coordinate Generation • OpenGL can automatically generate texture coordinate for you. void glTexGen* (GLenum coord, GLenum pname, TYPE param Specifies the function for automatically generating texture coordinates. coord: GL_S, GL_T, GL_R, GL_Q
  • 148.
    Recall Aliasing • Aliasingmanifests itself as “jaggies” in graphics. Thus we don’t have enough pixels to accurately represent the underlying function. • Three reasons – Pixel numbers are fixed in the frame buffer – Pixel locations are fixed on a uniform – Pixel size/shape are fixed • How do we fix it? – Increase resolution – Filtering
  • 149.
    Increase Rendering Resolution •Render the image at a higher resolution and downsample (like you are letting your eye do some filtering).
  • 150.
    Mip Mapping • MIP- multium in parvo - many in a small place. • Build a pyramid of images, each smaller and filtered from the original.
  • 151.
    Mipmapping • Thus aswe render, we choose the texture that best “fits” what you are drawing. • OpenGL supports mipmapping gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, image); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  • 152.
    Bump Mapping • Wecan also use textures for so much more than just images! • We can use the textures as a “road map” on how to perturb normals across a surface. • As we shade each pixel, perturb the normal by the partial derivatives of the corresponding s, t in the bump map.
  • 153.
    Environmental Mapping • Highlyreflective surface are characterized by specular reflections that mirror the environment. • We can extend our mapping techniques to obtain an image that approximates the desired reflection by extending texture maps to environmental (reflection) maps.
  • 154.
    Environmental Mapping • Two-passtexture mapping (1) Map the texture to a 3D intermediate surface. (2) Map the intermediate surface to the surface being rendered. Object in environment Intermediate surface Projected object
  • 155.
    Environmental Mapping • Then,we need to map the texture values on the intermediate surface to the desired surface. n n n
  • 156.
    Now It’s YourTurn • Find a good reference/book • Play with an example • Make your own code Computer graphics is best learned by doing!