The document provides an introduction to OpenGL programming. It discusses that OpenGL is a hardware-independent API for 3D graphics. It originated from SGI's GL library and was developed as the cross-platform OpenGL standard. The document outlines OpenGL's core functionality and architecture, as well as common libraries like GLUT and GLU. It provides examples of basic OpenGL programs and concepts like the rendering pipeline, coordinate systems, and event handling.

1. Introduction to
OpenGL Programming

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 Libraries
 OpenGL core library
 OpenGL32 on Windows
 GL on most unix/linux systems (libGL.a)
 OpenGL Utility Library (GLU)
 Provides functionality in OpenGL core but avoids
having to rewrite code
 Links with window system
 GLX for X window systems, WGL for Windows
 Cross-platform GUI libraries: GLUT, SDL, FLTK, QT,
…

7. Windowing with OpenGL
 OpenGL is independent of any specific
window system
 OpenGL can be used with different window
systems
 X windows (GLX)
 MFC
 …
 GLUTprovide a portable API for creating
window and interacting with I/O devices

8. GLUT
 OpenGL Utility Toolkit (GLUT)
 Provides functionality common to all window systems
 Open a window
 Get input from mouse and keyboard
 Menus
 Event-driven
 Code is portable but GLUT lacks the functionality of a
good toolkit for a specific platform
 No slide bars, buttons, …

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

10. OpenGL Architecture
Immediate Mode geometry
pipeline
Per Vertex
Polynomial Operations &
Evaluator Primitive
Assembly
Display Per Fragment Frame
CPU List
Rasterization
Operations Buffer
Texture
Memory
Pixel
Operations

11. OpenGL as a state machine
 GL State Variables- can be set and queried by OpenGL. Remains
unchanged until the next change.
 Projection and viewing matrix
 Color and material properties
 Lights and shading
 Line and polygon drawing modes
 …
 OpenGL functions are of two types
 Primitive generating
 Can cause output if primitive is visible
 How vertices are processed and appearance of primitive are controlled by the
state
 State changing
 Transformation functions
 Attribute functions

12. OpenGL Syntax
 Functions have prefix gl and initial capital letters for each word
 glClearColor(), glEnable(), glPushMatrix() …
 glu for GLU functions
 gluLookAt(), gluPerspective() …
 Constants begin with GL_, use all capital letters
 GL_COLOR_BUFFER_BIT, GL_PROJECTION, GL_MODELVIEW …
 Extra letters in some commands indicate the number and type of
variables
 glColor3f(), glVertex3f() …
 OpenGL data types
 GLfloat, GLdouble, GLint, GLenum, …
 Underlying storage mode is the same
 Easy to create overloaded functions in C++ but issue is efficiency

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

14. 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,….

15. GLUT
 Developed by Mark Kilgard
 Hides the complexities of differing window
system APIs
 Default user interface for class projects
 Glut routines have prefix glut
 glutCreateWindow() …
 Has very limited GUI interface
 Glui is the C++ extension of glut

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

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

18. A Simple Program
Generate a square on a solid background

19. simple.c
#include <GL/glut.h>
void mydisplay(){
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glVertex2f(-0.5, -0.5);
glVertex2f(-0.5, 0.5);
glVertex2f(0.5, 0.5);
glVertex2f(0.5, -0.5);
glEnd();
glFlush();
}
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();
}

20. Closer Look at the main()
#include <GL/glut.h> includes gl.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); define window properties
init(); display callback
set OpenGL state
glutMainLoop();
}
enter event loop

21. init.c
black clear color
void init() opaque window
{
glClearColor (0.0, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 1.0); fill/draw with white
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}
viewing volume

22. Event Handling
 Virtually all interactive graphics programs are even
driven
 GLUT uses callbacks to handle events
 Windows system invokes a particular procedure when an
event of particular type occurs.
 MOST IMPORTANT: display event
 Signaled when window first displays and whenever portions
of the window reveals from blocking window
 glutDisplayFunc(void (*func)(void)) registers
the display callback function
 Running the program: glutMainLoop()
 Main event loop. Never exit()

23. More Callbacks
 glutReshapeFunc(void (*func)(int w, int h)) indicates
what action should be taken when the window is resized.
 glutKeyboardFunc(void (*func)(unsigned char key, int
x, int y)) and glutMouseFunc(void (*func)(int button,
int state, int x, int y)) allow you to link a keyboard key or a
mouse button with a routine that's invoked when the key or mouse
button is pressed or released.
 glutMotionFunc(void (*func)(int x, int y)) registers a
routine to call back when the mouse is moved while a mouse button is
also pressed.
 glutIdleFunc(void (*func)(void)) registers a function that's to
be executed if no other events are pending - for example, when the
event loop would otherwise be idle

24. Compilation on Windows
 See class web site on how to set up a project
with OpenGL
 Visual C++
 Get glut.h, glut32.lib and glut32.dll from web
 Create a console application
 Add opengl32.lib, glut32.lib, glut32.lib to project
settings (under link tab)

25. Simple Animation
 Animation
 Redraw + swap buffers
 What looks like if using single buffer
 Example program
 More on the glut documentation
 Chapter 2 of textbook
 OpenGL redbook
 Links in the class resources page

26. OpenGL Drawing
 We have learned how to create a window
 Steps in the display function
 Clear the window
 Set drawing attributes
 Send drawing commands
 Swap the buffers
 OpenGL coordinate system has different origin from
the window system
 Uses lower left corner instead of upper left corner as origin

27. Clear the Window
 glClear(GL_COLOR_BUFFER_BIT)
 clears the frame buffer by overwriting it with the
background color.
 Background color is a state set by
glClearColor(GLfloat r, GLfloat g,
GLfloat b, GLfloat a) in the init().

28. Drawing Attributes: Color
 glColor3f(GLfloat r, GLfloat g, GLfloat b) sets the
drawing color
 glColor3d(), glColor3ui() can also be used
 Remember OpenGL is a state machine
 Once set, the attribute applies to all subsequent defined
objects until it is set to some other value
 glColor3fv() takes a flat array as input
 There are more drawing attributes than color
 Point size: glPointSize()
 Line width: glLinewidth()
 Dash or dotted line: glLineStipple()
 Polygon pattern: glPolygonStipple()
 …

29. Drawing Commands
 Simple Objects glRectf()
 Complex Objects
 Use construct
glBegin(mode) and
glEnd() and a list of
vertices in between
 glBegin(mode)
glVertex(v0);
glVertex(v1);
...
glEnd();
 Some other commands can
also be used between
glBegin() and glEnd(), e.g.
glColor3f().
 Example

30. Projection and Viewport

31. Orthographic projection
 Orthographic View
 glOrtho(left,
right, bottom,
top, front, back)
 Specifies the
coordinates of 3D
region to be projected
z=0
into the image space.
 Any drawing outside the
region will be
automatically clipped
away.

32. Viewports
 Do not have use the entire window for the
image: glViewport(x,y,w,h)
 Values in pixels (screen coordinates)

33. Window to Viewport mapping
Aspect Ratio: Height/Width
If the aspect ratio of the window
Is different from that of the
viewport, the picture will be
distorted.

34. Sierpinski Gasket (2D)
 Start with a triangle
 Connect bisectors of sides and remove central
triangle
 Repeat

35. Example
 Five subdivisions

36. Gasket Program
#include <GL/glut.h>
/* initial triangle */
GLfloat v[3][2]={{-1.0, -0.58},
{1.0, -0.58}, {0.0, 1.15}};
int n; /* number of recursive steps */
void triangle( GLfloat *a, GLfloat *b, GLfloat *c)
/* display one triangle */
{
glVertex2fv(a);
glVertex2fv(b);
glVertex2fv(c);
}

37. Triangle Subdivision
void divide_triangle(GLfloat *a, GLfloat *b, GLfloat *c, int
m)
{
/* triangle subdivision using vertex numbers */
point2 v0, v1, v2;
int j;
if(m>0)
{
for(j=0; j<2; j++) v0[j]=(a[j]+b[j])/2;
for(j=0; j<2; j++) v1[j]=(a[j]+c[j])/2;
for(j=0; j<2; j++) v2[j]=(b[j]+c[j])/2;
divide_triangle(a, v0, v1, m-1);
divide_triangle(c, v1, v2, m-1);
divide_triangle(b, v2, v0, m-1);
}
else(triangle(a,b,c));
/* draw triangle at end of recursion */
}

38. Gasket Display Functions
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
divide_triangle(v[0], v[1], v[2], n);
glEnd();
glFlush();
}
• By having the glBegin and glEnd in the display callback rather
than in the function triangle and using GL_TRIANGLES rather
than GL_POLYGON in glBegin, we call glBegin and glEnd
only once for the entire gasket rather than once for each triangle

39. Example: 3D Gasket
after 5 iterations

40. Tetrahedron Code
void tetrahedron( int m)
{
glColor3f(1.0,0.0,0.0);
divide_triangle(v[0], v[1], v[2], m);
glColor3f(0.0,1.0,0.0);
divide_triangle(v[3], v[2], v[1], m);
glColor3f(0.0,0.0,1.0);
divide_triangle(v[0], v[3], v[1], m);
glColor3f(0.0,0.0,0.0);
divide_triangle(v[0], v[2], v[3], m);
}