Some arguments of OpenGL functions can be assigned values using a vector that lists a set of data values. This is an option for specifying a list of values as a pointer to an array, rather than specifying each element of the list explicitly as a parameter argument. A typical example of the use of this option is in specifying xyz coordinate values.

RELATED LIBRARIES AND ROUTINES

In addition to the basic, or core, library of functions, a set of "macro" routines that use core functions are available in the OpenGL Utility Library (GLU). These routines provide methods for setting up viewing projection matrices, describing complex objects with line and polygon approximations, surface rendering, and other complex tasks. In particular, GLU provides methods for displaying quadrics using linear-equation approximations.

There are a number of window-system libraries that support OpenGL functions. The OpenGL Extension to the X Window System (GLX) provides a set of routines that are prefixed with the letters glX. The WGL routines provide a Microsoft Windows-to-OpenGL interface. These routines are prefixed with the letters wgl. The PGL routines, which are prefixed with pgl, provide a Presentation Manager to OpenGL interface for the IBM OS/2. And the GLUT (OpenGL Utility Toolkit) routines, prefixed with glut, provide a toolkit that is independent of any window system. This set of routines also contains methods for describing and rendering quadric curves and surfaces.

An object-oriented toolkit based on OpenGL, called Open Inventor, provides routines and predefined object shapes for interactive three-dimensional applications. This toolkit is written in C++.

HEADER FILES

And we would also need a window interface library. Alternatively, we can just include the GLUT header file:

#include <GL/glut.h>

Includes the OpenGL Utility Toolkit header file. This statement automatically includes gl.h, glu.h, and glx.h. And with Microsoft Windows, it includes the appropriate header file to access WGL.

SETTING UP DISPLAY WINDOWS USING GLUT

Various options for the window are set with the glutInitDisplayMode function. These options include the color mode and single or double buffering. The default is RGB color mode with single buffering.

SETTING THE WINDOW COLOR

Background color for a window is set with the functions glClearColor and glClear. For example, the following two statements set the background color to black (the default), then this color is applied to the color buffer which displays the window with the specified color.

	glClearColor (0.0, 0.0, 0.0, 0.0); 
	glClear (GL_COLOR_BUFFER_BIT);

In the glClearColor function, the first three parameters set the RGB color components in the range from 0 to 1. The fourth parameter is used to set an "alpha value", as discussed in the section Attributes of Output Primitives, Color.

WINDOW COORDINATES AND SCREEN DISPLAY AREA

There are a number of options for setting viewing parameters and generating a screen display of a scene. The various options for generating views of two-dimensional and three-dimensional scenes are discussed in the section on Viewing Transformations.

For a two-dimensional application, we can obtain a screen display of a defined scene with the following code segment which sets up a coordinate "viewing" range and specifies an area of the screen for displaying the scene.

	glViewport (xvmin, yvmin, vpWidth, vpHeight);
	glMatrixMode (GL_PROJECTION);
	glLoadIdentity (); 
	gluOrtho2D (xwmin, xwmax, ywmin, ywmax); 

The first command above defines the rectangular screen area (called the "viewport") that is to be used for the display of the scene. All parameters in the glViewport function are assigned integer screen coordinate values, and the lower left corner of the viewport is displayed at screen position(xvmin, yvmin) in the display "window" set up by the window manager. The second command sets the mode for matrix operations. In this case, we want to project a scene description to the screen. The third command initializes the transformation matrix for these operations to the identity matrix. And the fourth and last command defines the range of coordinates that will map to the viewport, with coordinate values expressed as floating-point numbers. This fourth function defines a "clipping window", so that objects inside this rectangle are displayed within the viewport. Objects outside this rectangle are clipped; i.e., not displayed. As an alternative, the function gluOrtho2D could be replaced with glOrtho, as discussed in the section on Viewing Transformations.

DISPLAYING A SCENE USING GLUT

After initializing GLUT, setting the window parameters (position, size, and background color), and specifying the coordinate system, we can display a scene with the following functions

	glutDisplayFunc(sceneDescrip);
	glutMainLoop ();

The parameter sceneDescrip in the first function is a routine that describes the primitives and attribute settings for the scene. Rendering and display of window contents are effective with the final GLUT function: glutMainLoop.

OUTPUT PRIMITIVES

POINT PLOTTING

We define world-coordinate positions with glVertex functions placed between a glBegin/glEnd pair using the primitive type constant: GL_POINTS. Coordinate positions can be specified in two or three dimensions. We can also use homogeneous-coordinate representations (four dimensional). Default values for the z coordinate and the h parameter in coordinate specifications are z = 0 and h = 1. We use a suffix (2, 3, or 4) on the glVertex to indicate the coordinate dimension.

The data type to be used in specifying a particular cordinate position is also indicated with a suffix code on the glVertex function. These suffix codes are double (d), float (f), integer (i), and short (s). Coordinate values can be explicitly listed, or they can be given in a separate array designation. For an array specification of a coordinate position, we append a third suffix code: v (for "vector").

In the following example, three points are plotted along a two-dimensional straight-line path with a slope of 2. Coordinates are given as integers.

	glBegin (GL_POINTS);
	  glVertex2i (50, 100);
	  glVertex2i (75, 150);
	  glVertex2i (100, 200); 
	glEnd ();

Alternatively, we could have used a vector specification for coordinate positions by replacing each of the statements between the glBegin/glEnd pair with a statement of the form

	glVertex2iv (endpointCoords1);

where parameter endpointCoords1 is a pointer to an array of coordinate values.

LINE FUNCTIONS

As with point plotting, straight line segments are specified with glVertex functions that are placed within glBegin/glEnd pairs. In this case however, the coordinate positions are interpreted as line endpoint positions. Straight line segments are drawn as solid lines, unless other attribute options are selected. There are three primitive types in OpenGL that we can use to generate line segments:

Example:

	glBegin (lineMode); 
	  glVertex2i (50,150);
	  glVertex2i (150, 150);
	  glVertex2i (150, 50);
	  glVertex2i (50, 50);
	glEnd (); 

If parameter lineMode in this example is set to the value GL_LINES, we obtain two unconnected line segments that are horizontal and parallel. With GL_LINE_STRIP, we have a connected polyline with three line segments between position (50, 150) and position (50, 50). And with GL_LINE_LOOP, we draw the four edges of a square, where each edge is 100 pixels long.

DISPLAYING CURVED LINES

Since curves cannot be precisely described with linear equations, there are no simple curve functions, such as those for points and straight lines, in OpenGL. One way to display a curve is to approximate it with discrete points or straight-line segments. For example, we could set up routines to implement midpoint methods for any given function, although this is generally not straightforward for complex curves. Another approach is to generate curves using the spline methods that are available in OpenGL. For quadrics, such as circles and ellipses, there are routines available in the OpenGL Utility Library (GLU).

FILL-AREA FUNCTIONS

We display filled polygons with the same procedures that we used for straight-line drawing, except that the glVertex function is now used to give the polygon vertex coordinates. Different shapes are obtained by specifying different polygon type constants in the glBegin command. By default, polygons are displayed with a solid fill color. Other attribute options, such as pattern fill and border display, are also available. There are six polygon fill primitives available in OpenGL:

Each polygon that we specify has two faces: a back face and a front face. In OpenGL, attributes can be set for each face separately, and back/front identification is needed in both two-dimensional and three-dimensional viewing routines. Therefore, polygon vertices should be specified in a counterclockwise order as we view the "outside" face of the polygon. This identifies the front face for that polygon.

As an example, the following code section generates a filled square version of the polygon that was described using line segments (only edges displayed) in the line-function example of the previous section.

	glBegin (GL_POLYGON); 
	  glVertex2i (50, 50);
	  glVertex2i (150, 50);
	  glVertex2i (150, 150);
	  glVertex2i (50, 150);	  
	glEnd ();

When polygons or other objects are to be specified with a large number of coordinate positions, we can reduce the number of function calls by setting up arrays to store the coordinate data. These arrays are referred to as vertex arrays in OpenGL. Similar arrays can be used for other types of data as well, such as color values.

IMAGES AND BITMAPS

In addition to straight lines and polygons, we can use rectangular grid patterns to define shapes or scenes as a set of two-dimensional color points. The grid pattern could be a scanned image or it could be a shape we constructed by hand or with a program. This primitive is referred to as an image or as pixel data in OpenGL. In some other packages, the grid of color points is called a cell array. We display such a defined shape with the function

	glDrawPixels (width, height, pixelFormat, dataType, image);

Parameters width and height give the dimensions of the color array image. We use parameter pixelFormat to specify the format for the color specification. For example, this parameter could be assigned one of the constants: GL_RGB, GL_RED, GL_GREEN, GL_BLUE, GL_COLOR_INDEX, etc. And we use parameter dataType to specify the type of data in the array. We assign this parameter one of the constants: GL_FLOAT, GL_INT, GL_BYTE, etc.

When a rectangular gird of color points is specified, it is placed into the frame buffer so that the lower left corner of the grid is at the current position. We set the value of the current position with the function

Coordinates can two-, three-, or four-dimensional, and we can specify coordinate values in a variety of formats. Suffixes for specifying dimension and format are the same as for the glVertex function. The specified coordinates are transformed to screen coordinates by the viewing routines.

Two other image functions are available in OpenGL. We can store a rectangular section of the frame buffer in a designated array with the function glReadPixels, and we can copy a rectangular section of the frame buffer to another location within the frame buffer with glCopyPixels.

Another method for defining shapes using a rectangular grid is with the function

	glBitmap (width, height, x0, y0, xOffset, yOffset, image);

Parameters width and height are the same as in the function glDrawPixels. Parameter image is now a binary array, so that each pixel position in the grid is displayed at the same color. When the current position is set, the current color setting is applied to the bitmap. Coordinate position (x0, y0) defines the "origin" of the bitmap relative to the lower left corner of the rectangular grid. Coordinate values for the bitmap origin may be positive or negative. The bitmap is displayed by positioning the bitmap origin at the current position within the frame buffer. Values xOffset and yOffset are used as coordinate offsets to update the current frame buffer position after the bitmap is displayed.

CHARACTER GENERATION

Only low-level support is provided in OpenGL for displaying characters and text. One method for generating text is to define each character as a bitmap.

Another method for setting up a text definition is to use a display list, which is simply a set of OpenGL commands. In this approach, the character codes for a particular font are used to index a set of bitmaps. To display a character string, we execute the corresponding display lists.

ATTRIBUTES OF OUTPUT PRIMITIVES

COLOR

We can specify color settings for primitives using either the RGB mode (or RGBA mode) or the color-index mode. Once we specify a particular set of color values, these values apply to all subsequently defined primitives until the color settings are changed. A new color then affects only the objects we define after the color change.

In RGB mode, we specify values for the red, green, and blue components of a color. We can also set a fourth color parameter, called the alpha value. The complete, four-dimensional, color specification is then referred to as the RGBA color. This fourth color parameter is used to control color blending for overlapping objects. An important application of color blending is in the simulation of transparency effects. For these calculations, the alpha value corresponds to the transparency coefficient.

To use RGB (or RGBA) mode, we simply set the current color with the function:

Integer, floating-point, or other numerical formats can be used to specify the RGB components of a color. Just as with the glVertex function, we use suffix codes such as 3, 4, d, f, and i to indicate color dimension and data format. For example, the following function specifies RGB color components in floating point and sets the current color to the highest intensity blue:

	glColor3f (0.0, 0.0, 1.0);

The default RGB color is white (1, 1, 1), and the default alpha value is 1. Optionally, we can set color values using arrays. In this case, we add a third suffix, v, to the function, and we set a single argument as a pointer to an array of color values. Using an array, we set the color in the above example as

	glColor3fv (colorArray);

Another method for setting color values is to use the color-index mode, which references color tables. We use this mode when we have limited storage available. With this mode, the current color is set from a color table using the function

	glIndex (index);

which specifies an index position within an array of color values. This function also requires a data-type suffix such as d, f, or i for the index value. We can set up a color table with the function

	glIndexPointer (type, offset, ptr);

where parameter type gives the data type, parameter offset gives the spacing between consecutive color values, and parameter ptr is a pointer to the first element in the color array.

POINT ATTRIBUTES

We can set two attributes for points: color and size. Color is controlled by the current color setting, and we set the size for a point with

LINE ATTRIBUTES

Basic attributes for a straight line segment are line type, line width, and line color. Other possible line effects, such as pen or brush type, can be implemented with adaptions of line type and width functions.

A single color for display of a line segment is determined by the current color settings. Another possibility for color display of a solid line is to vary the color along the line path. One way to do this is to assign a different color to each line endpoint as we define the line, instead of setting a current color for the line as a whole. To illustrate this method, the following code segment assigns the color blue to one endpoint and red to the other endpoint as the endpoint coordinates are defined. The solid line is then displayed as a linear interpolation of the colors at the two endpoints.

	glBegin (GL_LINES); 
	  glColor3f (0.0, 0.0, 1.0);
	  glVertex2i (50,50);
	  glColor3f (1.0, 0.0, 0.0);
	  glVertex2i (250,250);
	glEnd (); 

The default line-type attribute is solid. Lines can also be displayed as dashed, dotted, or dash-dotted. And we can vary the length of the dashes and the spacing between dashes or dots. A particular line type composed of single-color dots or dashes is specified with the OpenGL function

	glLineStipple (repeatFactor, pattern);

which specifies a pixel pattern for line display. Parameter pattern gives a 16-bit binary pattern (1 = pixel on, 0 = pixel off), and integer parameter repeatFactor specifies how many times each bit in the pattern is to be repeated. The pattern is applied to the pixels along the line path starting with the low-order bits in the pattern.

As an example of specifying a line type, suppose parameter pattern is assigned the hexadecimal representation 0x00FF and the repeat factor is 1. This would produce dashed lines with 8 pixels in each dash and 8 pixels in each space between the dashes. Also, since low-order bits are applied first, each line would begin with a dash drawn from the first endpoint along the line path. This would be followed by equal length space-dash combinations until the second endpoint position is reached. With a series of connected line segments, a specified line-type pattern is not restarted at the beginning of each segment. It is applied continuously across all the segments, starting at the first endpoint and ending at the final endpoint for the last segment in the series.

To apply a specified line type composed of dases and dots, we must enable it. Otherwise, the line is displayed with the default pattern: 0xFFFF. Enabling is accomplished with the function:

	glEnable (GL_LINE_STIPPLE);

We turn off a line-type pattern with glDisable.

Line width is set with the function

	glLineWidth (width);

The default value of parameter width is 1, and floating-point values are rounded to the nearest integer when antialiasing is not applied. With antialiasing enabled, fractional width values are possible.

AREA-FILL ATTRIBUTES

For polygons, the basic attribute is the fill style we chose. Polygons can be filled with a single color, a specified fill pattern, or in a "hollow" style by displaying only the edges or the vertex points. And we can select different attributes for the front and back faces of a polygon, reverse the definition of front and back, and eliminate the display of polygons that are either back facing or front facing.

A fill pattern is applied to a polygon with the function

	glPolygonStipple (fillPattern);

Parameter fillPattern is a pointer to a 32-bit by 32-bit mask. A value of 1 in the mask indicates that the corresponding pixel is to be turned on, and a 0 indicates pixel off. The fill pattern is specified in bytes, using the OpenGL data type Glubyte, and pixel intensity is set according to the current color setting. We specify the bit pattern with hexadecimal values, as for example,

	GLubyte fillPattern[] = {
		0xff, 0x00,0xff, 0x00, ...};

The bits must be specified starting with the bottom row of the pattern, and continuing up to the topmost row (32) of the pattern. The pattern is then applied across the current window, filling in the specified polygon where the pattern overlaps the polygon interior. Once we set the current fill pattern with glPolygonStipple, we need to enable the fill routines before we specify the vertices for the polygons that are to be filled with the current pattern. We do this with the statement

	glEnable (GL_POLYGON_STIPPLE);

Similarly, we turn off pattern filling with

	glDisable (GL_POLYGON_STIPPLE);

Another method for filling polygons is to use texture patterns, as discussed in the section on Surface Rendering. Also, the interpolation schemes for surface shading of three-dimensional objects can be adapted to fill the interior of two-dimensional polygons. We obtain an interpolation coloring of a polygon interior just as we did with the line primitive: A color is assigned to each vertex as we specify the polygon shape. As an example, the following code segment assigns a different color to each of the three vertices of a triangle and displays a triangle interior as a linear interpolation of the colors from each vertex.

	glBegin (GL_TRIANGLES); 
	  glColor3f (0.0, 0.0, 1.0);
	  glVertex2i (50, 50);	
	  glColor3f (1.0, 0.0, 0.0);
	  glVertex2i (150, 50);	  
	  glColor3f (0.0, 1.0, 0.0);
	  glVertex2i (75, 150);
	glEnd ();

If a single color is set for the polygon as a whole, the polygon is filled with that one color.

We can also choose to draw only polygon edges, thus displaying the polygon in wireframe or "hollow" form. And we could display a polygon by only plotting the vertex positions. These options are selected with function

	glPolygonMode (face, displayMode;

We use parameter face to select one of the two polygon faces by assigning this parameter one of the following constant values: GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. Then, if we want only the polygon edges displayed for this face, we assign the constant GL_LINE to parameter displayMode. To plot only the polygon vertex points, we assign the constant GL_POINTS to parameter displayMode. We can also assign this parameter the value GL-FILL, which is the default.

We can only apply rendering routines to convex polygons in OpenGL. For a concave polygon, we must apply a splitting algorithm to convert the polygon into a set of convex polygons, typically all triangles. If we then want to display the split polygon in wireframe form, we need to tell OpenGL which lines are part of the original polygon boundary. We do this with the glEdgeFlag function, which we use to indicate whether or not a vertex is the first endpoint of a boundary edge of the original polygon. The following function is used between glBegin/glEnd pairs.

	glEdgeFlag (GL_FALSE);

This command indicates that the next vertex does not precede a boundary edge. Also, it applies to all subsequently specified vertices until the next call to glEdgeFlag is made. The argument GL_TRUE indicates that a vertex does initialize an edge of the polygon boundary.

The definition of a polygon "front" face is set with the function

	glFrontFace (vertexOrder);

We can choose either a counterclockwise or a clockwise ordering of the vertices as the defining property of a front face. This is done by assigning one of the constant values GL_CCW or GL_CW to parameter vertexOrder . The default ordering is counterclockwise. This function can be used to swap faces of a polygon for which we have specified vertices in a clockwise order.

ANTIALIASING

We activate the antialiasing routines with the function

	glEnable (primitiveType);

where parameter primitiveType is assigned one of the values: GL_POINT_SMOOTH, GL_LINE_SMOOTH, or GL_POLYGON_SMOOTH. For antialiasing color points and fill patterns, we also need to apply blending functions.

INQUIRY FUNCTIONS

We can retrieve values for current attribute settings and for various other parameters using an appropriate "Get" function such as glGetIntegerv (), glGetFloatv (), glGetPolygonStipple ().

For instance, we can retrieve the current color settings with

	glGetFloatv (GL_CURRENT_COLOR, colorArray);

	glTranslatef (25.0, 25.0, 0.0);

	glMatrixMode (GL_MODELVIEW);

	glMatrixMode (GL_MODELVIEW);
	glLoadIdentity ();;
	glMultMatrixf (M1);
	glMultMatrixf (M2);

	glViewport (xvmin, yvmin, vpWidth, vpHeight);

	glMatrixMode (GL_PROJECTION);
	glLoadIdentity ();

	gluOrtho2D (xwmin, xwmax, ywmin, ywmax);

	glOrtho (xwmin, xwmax, ywmin, ywmax, -1.0, 1.0);

	glMatrixMode (GL_PROJECTION);

	gluLookAt (x0, y0, z0, xref, yref, zref, Vx, Vy, Vz);

	glOrtho (xwmin, xwmax, ywmin, ywmax, dNear, dFar);

	glFrustum (xwmin, xwmax, ywmin, ywmax, dNear, dFar);

	gluPerspective (fovAngle, aspectRatio, dNear, dFar);

	glClipPlane (id, paramArray); 
	glEnable (id);

	glEnable (GL_CULL_FACE);
	glCullFace (GL_BACK);

	glEnable (GL_DEPTH_TEST); 
	glClear (GL_DEPTH_BUFFER_BIT); 

	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glDepthFunction (depthTestOption);

	glLight (id, property, propertyValue);

	glLightfv (GL_LIGHT1, GL_POSITION, ptCoords);

	GLfloat rgbaSpecValues[] = {1.0, 1.0, 1.0, 1.0};
	glLightfv (GL_LIGHT2, GL_SPECULAR, rgbaSpecValues);

	GLfloat spotDirVector[] = {1.0, 0.0, 0.0, 1.0};
	glLightfv (GL_LIGHT3, GL_SPOT_DIRECTION, spotDirVector);
	glLightf (GL_LIGHT3, GL_SPOT_CUTOFF, 30.0);

	glLightModel (globalProperty, globalPropertyValue);

	glMaterial (face, surfaceProperty, surfacePropertyValue);

	glShadeModel (renderingType);	

	glEnable (GL_BLEND);
	glBlendFunc (surfaceParameter, rasterParameter);

	glEnable (GL_LIGHTING);