CS 381 Fall 2012
Lecture Notes for Tuesday, September 4, 2012

Introduction to OpenGL

What is OpenGL?

Professional-quality 2-D/3-D graphics API. Note: API = Application Programming Interface. (Can be implemented, but is not an implementation itself.)

• Work begun by SGI in 1992. Initially managed by consortium: Architecture Review Board (ARB). Now managed by Khronos Group.
• System-independent.
• An open standard.
• Available in a number of languages (we use C-language API; there is no C++ API).

OpenGL does:

• 2-D/3-D graphics with freeform surfaces made of polygons.
• Basic lighting, hidden-surface removal, clipping, anti-aliasing.
• Simple algorithms & tools that can be used to create fancier effects: texturing, blending, culling, fragment tests, reading the framebuffer.

OpenGL is not aimed primarily at:

• Text (although it can make text).
• GUI elements: window frames, buttons, etc.
• Page description.
• High-precision specification of images.

OpenGL does not:

• Manage windows or GUI controls.
• Have a user interface.
• Handle printers.
• Make sound.

The job of OpenGL is to create an image in a framebuffer.

Parts of OpenGL

Core OpenGL

• The interface with the graphics hardware.
• Designed for efficient implementation in hardware. (Particular OpenGL implementations may be any combination of hardware & software.)
• C header: <GL/gl.h>.

The OpenGL Utilities (GLU)

• Additional functions & types for convenience.
• Designed to be implemented in software. Calls core OpenGL.
• C header: <GL/glu.h>.

OpenGL Extensions

• Functionality added to base OpenGL.
• OpenGL specifies rules that extensions are to follow.
• We will use shading-language extensions (GLSL).
• Helpful: the OpenGL Extensions Wrangler (GLEW).

The Design of OpenGL

We deal with OpenGL via function calls, which implement OpenGL commands.

• We never see OpenGL’s internal data.
• Most OpenGL calls have few parameters.
• But we make lots of function calls.
• No complex data types.
• OpenGL is function-call intensive. Note: This has been mitigated somewhat by later additions to the API; we will discuss some of these next time.

OpenGL functions as a state machine. There are three kinds of functions:

• Those that set state.
• Those that return state.
• Those that draw.

Drawing is done via primitives. A state might be used to set an attribute of a vertex in a geometry primitive (e.g., its color) or a uniform property of a primitive as a whole (e.g., the width of a line).

Thus, you can think of OpenGL in an object-oriented sense. Commands are like member functions. States are like data members. The first 2 kinds of functions above are like setters and getters. The thing that corresponds with the object itself is an OpenGL rendering context. Typically, there is one context for each window.

Naming conventions for core OpenGL.

• Functions
  • Begin with “gl”. Words capitalized & run together.
  • Example: “glClearColor”.
  • May include type information. For example, in “glVertex2d”, the “2d” indicates 2 parameters of type GLdouble.
• Constants
  • Begin with “GL”. All upper-case, “_” between words.
  • Example: “GL_TRIANGLE_STRIP”.
• Types
  • Begin with “GL”. Next word not capitalized; others capitalized and run together.
  • Example: “GLdouble”.

GLU uses similar conventions, with “glu” instead of “gl”.

• Function: gluScaleImage.
• Constant: GLU_TESS_ERROR.
• Type: GLUtesselatorObj.

OpenGL defines its own types, which have at least a specified minimum precision on all systems. Some of these:

• GLint. Signed integer, 32 bits.
• GLubyte. Unsigned integer, 8 bits.
• GLfloat. Floating-point, 32 bits.
• GLdouble. Floating-point, 64 bits.
• GLenum. The type of OpenGL-defined constants like GL_TRIANGLE_STRIP.

So, for example, GLdouble is probably the same as double, but might not be. Be careful when dealing with pointers & arrays.

The C language cannot overload functions the way C++ can. Thus, some OpenGL commands have several forms allowing for different parameter types.

• The glVertex* command can take 2, 3, or 4 values of various types.
  • Function glVertex2d takes 2 parameters of type GLdouble.
  • Function glVertex3f takes 3 parameters of type GLfloat.
  • Function glVertex3dv (“v” for “vector”) takes a single parameter of type (GLdouble *), which should be a pointer to an array of 3 GLdouble values.
• The glTranslate* command always takes 3 parameters.
  • Function glTranslatef takes 3 parameters of type GLfloat.
  • Function glTranslated takes 3 parameters of type GLdouble.

GLUT Programs

What is GLUT?

GLUT = The OpenGL Utility Toolkit.

• A utility library written by Mark Kilgard in the 1990s.
• Provides a system-independent event-driven interface to I/O including OpenGL initialization, windows, the mouse, the keyboard, and pop-up menus.
• I do not consider GLUT to be appropriate for professional-quality work. We use it here, because it does what we need in a system-independent way, and it is easy to learn.

Some Details

The GLUT header is <GL/glut.h>. This includes the OpenGL and GLU headers for you.

Including the GLUT header in a system-indpendent way is a bit tricky. First, Apple puts it in a nonstandard place. Second, some implementations have a problem involving the exit system call, and so <cstdlib> should be included before the GLUT header. Putting it all together, the following seems to work everywhere.

#include <cstdlib>       // Do this before GL/GLUT includes
using std::exit;
#ifndef __APPLE__
# include <GL/glut.h>    // GLUT stuff, includes OpenGL headers as well
#else
# include <GLUT/glut.h>  // Apple puts glut.h in a different place
#endif

GLUT naming conventions are like those for GL, using “glut” instead of “gl”.

• Function: glutInitDisplayMode.
• Constant: GLUT_MIDDLE_BUTTON.
• GLUT defines no types.

Program Structure

We looked at sample1.cpp here.

The structure of our programs is dictated by GLUT.

• GLUT handles overall flow of control.
• You write functions to:
  • Initialize OpenGL states and your own variables.
  • Draw things.
  • Handle events (mouse clicks, window changes, keypresses, etc.).
• These functions are called by GLUT, not by you. They are callbacks.

Rules for callbacks in this class.

• You never call your callback functions. Only GLUT does that.
• The only job of the display function is to create an image for the user to see.
  • In particular, the display function must not alter any global data, other than GL states.
• No other function does this.
  • For the purposes of this rule, functions called by the display function are considered to be “inside” it.
  • GL state changes may be done in other functions.