1. SUJAN CHOWDHURY Lecturer, CSE, CUET
OpenGL Basics
SUJAN CHOWDHURY
Lecturer, CSE, CUET

2. What is OpenGL OpenGL is a software API to graphics hardware.
designed as a streamlined, hardware-independent interface to be implemented on many different hardware platforms
Intuitive, procedural interface with c binding
No windowing commands !
No high-level commands for describing models of three-dimensional objects
The OpenGL Utility Library (GLU) provides many of the modeling features, such as quadric surfaces and NURBS curves and surfaces

3. SGI and GL
Silicon Graphics (SGI) revolutionized the graphics workstation by implementing the pipeline in hardware (1982)
To access the system, application programmers used a library called GL
With GL, it was relatively simple to program three dimensional interactive applications

4. OpenGL
The success of GL lead to OpenGL (1992), a platform-independent API that was
Easy to use
Close enough to the hardware to get excellent performance
Focus on rendering
Omitted windowing and input to avoid window system dependencies

5. OpenGL Evolution Controlled by an Architectural Review Board (ARB)
Members include SGI, Microsoft, Nvidia, HP, 3DLabs, IBM,…….
Relatively stable (present version 2.0)
Evolution reflects new hardware capabilities
3D texture mapping and texture objects
Vertex and fragment programs
Allows for platform specific features through extensions

6. 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 (Silicon Graphics Inc.)
2D/3D graphics, lower-level primitives (polygons)
does not include low-level I/O management
basis for higher-level libraries/toolkits

7. 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

8. Software Organization
application program
OpenGL Motif
widget or similar
GLUT
GLX, AGL or WGL
GLU
OpenGL
X, Win32, Mac O/S
software and/or hardware

9. OpenGL #defines
Most constants are defined in the include files gl.h, glu.h and glut.h
Note #include <GL/glut.h> should automatically include the others
Examples
glBegin(GL_POLYGON)
glClear(GL_COLOR_BUFFER_BIT)
include files also define OpenGL data types: GLfloat, GLdouble,….

10. 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.

11. OpenGL function format
function name
dimensions
glVertex3f(x,y,z)
x,y,z are floats
belongs to GL library
glVertex3fv(p)
p is a pointer to an array

12. Parameter Types b 8-bit integer GLbyte s 16-bit integer GLshort
i 32-bit integer GLint
f 32-bit float GLfloat
d 64-bit float GLdouble
ub 8-bit unsigned int GLubyte
us 16-bit unsigned int GLushort
ui 32-bit unsigned int GLuint

13. 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

14. Primitives Primitives: Points, Lines & Polygons
Each object is specified by a set Vertices
Grouped together by glBegin & glEnd
glBegin(type)
glVertex*( ) …
glEnd( );
type can have 10
possible values

15. Glut Routines
Initialization: glutInit() processes (and removes) command­line arguments that may be of interest to glut and the window system and does general initialization of Glut and OpenGL
Must be called before any other glut routines
Display Mode: The next procedure, glutInitDisplayMode(), performs initializations informing OpenGL how to set up the frame buffer.
Display Mode Meaning
GLUT_RGB Use RGB colors
GLUT_RGBA Use RGB plus alpha (for transparency)
GLUT_INDEX Use indexed colors (not recommended)
GLUT_DOUBLE Use double buffering (recommended)
GLUT_SINGLE Use single buffering (not recommended)
GLUT_DEPTH Use depth­buffer (for hidden surface removal.)

16. Glut Routines Window Setup glutInitWindowSize(int width, int height)
glutInitWindowPosition(int x, int y)
glutCreateWindow(char* title)

17. Primitive Types Polygon must be: Simple No-holes inside Convex
GL_LINE V0 V1 V2 V3 V5 V4
GL_LINE_STRIP V0 V1 V2 V3 V5 V4
GL_LINE_LOOP V0 V1 V2 V3 V5 V4
Polygon must be:
Simple
No-holes inside
Convex
Non-convex
Complex P1 P2
GL_POINTS V0 V1 V2 V3 V5 V4
GL_POLYGON V0 V1 V2 V3 V4

18. Primitive Types Order of Vertex rendering 012, 213, 234, 435
GL_TRIANGLE V0 V1 V2 V3 V4 V5 V6 V7 V8
GL_TRIANGLE_STRIP V0 V1 V2 V3 V4 V5
Order of Vertex rendering
012, 213, 234, 435
GL_TRIANGLE_FAN V0 V1 V2 V3 V4 V5
012, 023 , 034, 045
GL_QUAD V0 V1 V2 V3 V4 V5 V6 V7
GL_QUAD_STRIP V0 V1 V2 V3 V4 V5 V6 V7
0132, 2354, 4576

19. An Example void drawParallelogram( GLfloat color[] ) {
glBegin( GL_QUADS );
glColor3fv( color );
glVertex2f( 0.0, 0.0 );
glVertex2f( 1.0, 0.0 );
glVertex2f( 1.5, );
glVertex2f( 0.5, );
glEnd(); }

20. Vertices and Primitives
Points, GL_POINTS
Individual points
Point size can be altered
glPointSize (float size)
glBegin(GL_POINTS);
glColor3fv( color );
glVertex2f( P0.x, P0.y );
glVertex2f( P1.x, P1.y );
glVertex2f( P2.x, P2.y );
glVertex2f( P3.x, P3.y );
glVertex2f( P4.x, P4.y );
glVertex2f( P5.x, P5.y );
glVertex2f( P6.x, P6.y );
glVertex2f( P7.x, P7.y );
glEnd();

21. Vertices and Primitives
Lines, GL_LINES
Pairs of vertices interpreted as individual line segments
Can specify line width using:
glLineWidth (float width)
glBegin(GL_LINES);
glColor3fv( color );
glVertex2f( P0.x, P0.y );
glVertex2f( P1.x, P1.y );
glVertex2f( P2.x, P2.y );
glVertex2f( P3.x, P3.y );
glVertex2f( P4.x, P4.y );
glVertex2f( P5.x, P5.y );
glVertex2f( P6.x, P6.y );
glVertex2f( P7.x, P7.y );
glEnd();

22. Vertices and Primitives
Line Strip, GL_LINE_STRIP
series of connected line segments

23. Vertices and Primitives
Line Loop, GL_LINE_LOOP
Line strip with a segment added between last and first vertices

24. Vertices and Primitives
Polygon , GL_POLYGON
boundary of a simple, convex polygon

25. Vertices and Primitives
Triangles , GL_TRIANGLES
triples of vertices interpreted as triangles

26. Vertices and Primitives
Triangle Strip , GL_TRIANGLE_STRIP
linked strip of triangles v1 v0 v3 v2 v4 v5 v7 v6

27. Vertices and Primitives
Triangle Fan , GL_TRIANGLE_FAN
linked fan of triangles v2 v1 v3 v4 v0 v5

28. Vertices and Primitives
Quads , GL_QUADS
quadruples of vertices interpreted as four-sided polygons

29. Files Required for GLUT:
Configuring OpenGL in Visual C++
Files Required for GLUT:
glut32.dll
glut.h
glut32.lib

30. Sample Program

31. Closer Look at the main()
includes gl.h
#include <GL/glut.h>
int main(int argc, char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("simple");
glutDisplayFunc(mydisplay);
init();
glutMainLoop(); }
define window properties
display callback
set OpenGL state
enter event loop

32. init.c black clear color opaque window fill/draw with white
void init() {
glClearColor (0.0, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); }
black clear color
opaque window
fill/draw with white
viewing volume
Set up whatever state you’re going to use
Don’t need this much detail unless working in 3D

33. GLUT Callback Functions
Callback function : Routine to call when an event happens
Window resize or redraw
User input (mouse, keyboard)
Animation (render many frames)
“Register” callbacks with GLUT
glutDisplayFunc( my_display_func );
glutIdleFunc( my_idle_func );
glutKeyboardFunc( my_key_events_func );
glutMouseFunc ( my_mouse_events_func );

34. Rendering Callback Callback function where all our drawing is done
Every GLUT program must have a display callback
glutDisplayFunc( my_display_func ); /* this part is in main.c */
void my_display_func (void ) {
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_TRIANGLE );
glVertex3fv( v[0] );
glVertex3fv( v[1] );
glVertex3fv( v[2] );
glEnd();
glFlush(); }

35. Events in OpenGL Event Example OpenGL Callback Function Keypress
KeyDown
KeyUp
glutKeyboardFunc
Mouse
leftButtonDown
leftButtonUp
glutMouseFunc
Motion
With mouse press
Without
glutMotionFunc
glutPassiveMotionFunc
Window
Moving
Resizing
glutReshapeFunc
System
Idle
Timer
glutIdleFunc
glutTimerFunc
Software
What to draw
glutDisplayFunc

36. 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

37. Redrawing Window void glFlush(void); void glFinish(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.

38. 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

39. 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

40. The command glOrtho() creates an orthographic parallel viewing volume
The command glOrtho() creates an orthographic parallel viewing volume. You specify the corners of the near clipping plane and the distance to the far clipping plane.
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom,
GLdouble top, GLdouble near, GLdouble far);

41. Each application has its
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 … }
Event
Queue
Keyboard
Callback
Mouse
Display OS
MainLoop
Each application has its
Own event queue

42. 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));
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

43. 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.

44. 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.

45. Animation( Motion = Redraw+Swap )

46. Animation( Motion = Redraw+Swap )

47. Animation( Motion = Redraw+Swap )

48. 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
Graphics
Primitives
(P)
Output
N•M•P
Model-View
Matrix Stack
Projection
Matrix Stack

50. Translation – 2D
x’ = x + dx
y’ = y + dy

51. Transformations and OpenGL®
Each time an OpenGL transformation M is called the current MODELVIEW matrix C is altered:
glTranslatef(1.5, 0.0, 0.0);
glRotatef(45.0, 0.0, 0.0, 1.0);
Note: v is any vertex placed in rendering pipeline v’ is the transformed
vertex from v.

52. Matrix Operation

53. Thinking About Transformations
There is a World Coordinate System where:
All objects are defined
Transformations are in World Coordinate space
Two Different Views
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

54. Order of Transformation T•R
glLoadIdentity();
glMultiMatrixf( T);
glMultiMatrixf( R);
draw_ the_ object( v);
v’ = ITRv
Global View
Rotate Object
Then Translate
Local View
Translate Object
Then Rotate
Effect is same, but perception is different

55. Order of Transformation R•T
glLoadIdentity();
glMultiMatrixf( R);
glMultiMatrixf( T);
draw_ the_ object( v);
v’ = ITRv
Global View
Translate Object
Then Rotate
Local View
Rotate Object
Then Translate
Effect is same, but perception is different

56. OpenGL Programming Guide (3rd Edition)
M. Woo, J. Neider, T. Davis, D. Shreiner
Addison-Wesley, 2000

57. Thank You