Chapter 06

State Management and Drawing Geometric Objects

Basic State management - Displaying Points, Lines and Polygons - Normal Vector -
Vertex Arrays
Basic State Management:
OpenGL maintains many states and state variables. An object may be rendered with
lighting, texturing, hidden surface removal, fog, and other states affecting its
appearance. By default, most of these states are initially inactive. These states may be
costly to activate; for example, turning on texture mapping will almost certainly slow
down the process of rendering a primitive. To turn many of these states on and off,
use these two simple commands:
void glEnable (GLenum capability);
void glDisable(GLenum capability);
glEnable() turns on a capability, and glDisable() turns it off. More than 60 enumerated
values can be passed as parameters to glEnable() or glDisable(). Some examples are
GL_BLENDGL_DEPTH_TEST, GL_FOG, GL_LINE_STIPPLE and
GL_LIGHTING. You can also check whether a state is currently enabled or disabled.
GLboolean glIsEnabled(GLenum capability); Returns GL_TRUE or GL_FALSE,
depending on whether or not the queried capability is currently activated.
Displaying Points, Lines, and Polygons:
By default, a point is drawn as a single pixel on the screen, a line is drawn solid and
1pixel wide, and polygons are drawn solidly filled in. The following discuss the
details of how to change these default display modes.
Point Details
To control the size of a rendered point, use glPointSize() and supply the desired size
in pixels as the argument.
void glPointSize(GLfloat size);
Sets the width in pixels for rendered points; size must be greater than 0.0 and by
default is 1.0. The actual collection of pixels on the screen which are drawn for
various point widths depends on whether antialiasing is enabled. (Antialiasing is a
technique for smoothing points and lines as they’re Rendered) If antialiasing is
disabled (the default), fractional widths are rounded to integer widths, and a
screen−aligned square region of pixels is drawn. Thus, if the width is 1.0, the square
is 1 pixel by 1 pixel; if the width is 2.0, the square is 2 pixels by 2 pixels, and so on.
With antialiasing enabled, a circular group of pixels is drawn, and the pixels on the
boundaries are typically drawn at less than full intensity to give the edge a smoother
appearance. In this mode, non−integer widths aren’t rounded.
Most OpenGL implementations support very large point sizes. You can query the
minimum and maximum sized for aliased points by using
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, size). Likewise, you can obtain
the range of supported sizes for antialiased points by passing
GL_SMOOTH_POINT_SIZE_RANGE toglGetFloatv(). The sizes of supported
antialiased points are evenly spaced between the minimum and maximum sizes for the

1|P a g e
range. Calling glGetFloatv() with the
parameterGL_SMOOTH_POINT_SIZE_GRANULARITY will return how accurately
a given antialiased point size is supported. For example, if you request
glPointSize(2.37) and the granularity returned is 0.1, then the point size is rounded to
2.4.
Line Details
With OpenGL, you can specify lines with different widths and lines that are stippled
in various ways - dotted, dashed, drawn with alternating dots and dashes, and so on.
Wide Lines:
void glLineWidth(GLfloat width);Sets the width, in pixels, for rendered lines; width
must be greater than 0.0 and by default is 1.0.The actual rendering of lines is affected
if either antialiasing or multisampling is enabled. Without antialiasing, widths of 1, 2,
and 3 draw lines 1, 2, and 3 pixels wide. With antialiasing enabled, noninteger line
widths are possible without antialiasing, widths of 1, 2, and 3 drawlines 1, 2, and 3
pixels wide. With antialiasing enabled, non-integer line widths are possible, and
pixels on the boundaries are typically drawn at less than full intensity.
Similar to points you can obtain the range of supported aliased line widths by using
GL_ALIASED_LINE_WIDTH_RANGE with glGetFloatv(). To determine the
supported minimum and maximum sizes of antialiased line widths, and what
granularity your implementation supports, call glGetFloatv(), with
GL_SMOOTH_LINE_WIDTH_RANGE and
GL_SMOOTH_LINE_WIDTH_GRANULARITY
Stippled Lines:
To make stippled (dotted or dashed) lines, you use the command glLineStipple() to
define the stipple pattern, and then you enable line stippling with
glEnable(GL_LINE_STIPPLE).
void glLineStipple(GLint factor, GLushort pattern);
Sets the current stippling pattern for lines. The pattern argument is a 16-bit series of
0s and 1s, and it’s repeated as necessary to stipple a given line. A 1 indicates that
drawing occurs, and a 0 that it does not, on a pixel-by-pixel basis, beginning with the
low-order bit of the pattern. The pattern can be stretched out by using factor. With the
preceding example and the pattern0x3F07 (which translates to 0011111100000111 in
binary), a line would be drawn with 3 pixels on, then 5 off, 6 on, and 2 off. If factor
had been 2, the pattern would have been elongated: 6pixels on, 10 off, 12 on, and 4

off.

Polygon Details:

2|P a g e
Polygons are typically drawn by filling in all the pixels enclosed within the boundary,
but you can also draw them as outlined polygons or simply as points at the vertices. A
filled polygon might be solidly filled or stippled with a certain pattern.
Polygons as Points, Outlines, or Solids:
A polygon has two sides front and back and might be rendered differently depending
on which side is facing the viewer. This allows you to have cutaway views of solid
objects in which there is an obvious distinction between the parts that are inside and
those that are outside. By default, both front and back faces are drawn in the same
way. To change this, or to draw only outlines or vertices, use glPolygonMode().
void glPolygonMode(GLenum face, GLenum mode);
Controls the drawing mode for a polygon’s front and back faces. The parameter face
can be GL_FRONT_AND_BACK, GL_FRONT, or GL_BACK; mode can be
GL_POINT, GL_LINE, or GL_FILL to indicate whether the polygon should be
drawn as points, outlined, or filled. By default, both the front and back faces are
drawn filled.
For example; you can have the front faces filled and the back faces outlined with two
calls to this routine:
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_LINE);
Reversing and Culling Polygon Faces:
Polygons whose vertices appear in counterclockwise order on the screen are called
front-facing. You can construct the surface of any orientation. You can use all
clockwise polygons or all counterclockwise polygons.
void glFrontFace(GLenum mode);
Controls how front-facing polygons are determined. By default, mode is GL_CCW,
which corresponds to a counterclockwise orientation of the ordered vertices of a
projected polygon in window coordinates. If mode is GL_CW, faces with a clockwise
orientation are considered front-facing
void glCullFace(GLenum mode);
Indicates which polygons should be discarded (culled) before they’re converted to
screen coordinates. The mode is either GL_FRONT, GL_BACK, or
GL_FRONT_AND_BACK to indicate front-facing, back-facing, or all polygons. To
take effect, culling must be enabled using glEnable() with GL_CULL_FACE; it can
be disabled with glDisable() and the same argument.
Normal Vectors
A normal vector (or normal, for short) is a vector that points in a direction that’s
perpendicular to a surface. For a flat surface, one perpendicular direction is the same
for every point on the surface, but for a general curved surface, the normal direction
might be different at each point on the surface. With OpenGL, you can specify a
normal for each polygon or for each vertex. Vertices of the same polygon might share
the same normal (for a flat surface) or have different normals (for a curved surface).
You can’t assign normals anywhere other than at the vertices. normal vectors define
the orientation of its surface in space in particular, its orientation relative to light

3|P a g e
sources. These vectors are used by OpenGL to determine how muchlight the object
receives at its vertices.
An object’s normal vectors define the orientation of its surface in space—in
particular, its orientation relative to light sources. These vectors are used by OpenGL
to determine how much light the object receives at its vertices. Lighting is large topic
by itself. You use glNormal*() to set the current normal to the value of the argument
passed in. Subsequent calls to glVertex*() cause the specified vertices to be assigned
the current normal. Often, each vertex has a different normal, which necessitates a
series of alternating calls, as in the below Example.
glBegin (GL_POLYGON);
glNormal3fv(n0);
glVertex3fv(v0);
glNormal3fv(n1);
glVertex3fv(v1);
glNormal3fv(n2);
glVertex3fv(v2);
glNormal3fv(n3);
glVertex3fv(v3);
glEnd();
void glNormal3{bsidf(TYPE nx, TYPE ny, TYPE nz);
void glNormal3{bsidf}v(const TYPE *v);
Sets the current normal vector as specified by the arguments. The non vector version
(without the v) takes three arguments, which specify an (nx, ny, nz) vector that’s
taken to be the normal.
Alternatively, you can use the vector version of this function (with the v) and supply a
single array of three elements to specify the desired normal.
Vertex Array:
You may have noticed that OpenGL requires many function calls to render geometric
primitives. Drawing a 20-sided polygon requires at least 22 function calls: one call to
glBegin(), one call for each of the vertices, and a final call to glEnd(). For some
systems, function calls have a great deal of overhead and can hinder performance. An
additional problem is the redundant processing of vertices that are shared between
adjacent polygons. For example, the cube in Figure has six faces and eight shared
vertices. Unfortunately, if the standard method of describing this object is used, each
vertex has to be specified three times: once for every face that uses it. Therefore, 24
vertices are processed, even though eight would be enough

4|P a g e
Using vertex arrays can reduces the number of function calls, which improves
performance. Also, using vertex arrays may allow reuse of already processed shared
vertices.
There are three steps to using vertex arrays to render geometry:
1. Enabling Arrays
Activate (enable) the appropriate arrays, with each storing a different type of data:
vertex coordinates, surface normals, RGBA colors, secondary colors, color indices,
fog coordinates, texture coordinates, polygon edge flags, or vertex attributes for use in
a vertex shader.
2.Specifying Data for the Arrays
Put data into the array or arrays. The arrays are accessed by the addresses of that is,
pointers to) their memory locations
3.Dereferencing and Rendering
Draw geometry with the data. OpenGL obtains the data from all activated arrays by
dereferencing the pointers.
1. Enabling Arrays:
The first step is to call glEnableClientState() with an enumerated parameter, which
activates the chosen array. void glEnableClientState(GLenum array)Specifies the
array to enable. The symbolic constants GL_VERTEX_ARRAY,
GL_COLOR_ARRAY, GL_SECONDARY_COLOR_ARRAY,
GL_INDEX_ARRAY, GL_NORMAL_ARRAY, GL_FOG_COORD_ARRAY,
GL_TEXTURE_COORD_ARRAY, and GL_EDGE_FLAG_ARRAY are acceptable
parameters. If you use lighting, you may want to define a surface normal for every
vertex. To use vertex arrays for that case, you activate both the surface normal and
vertex coordinate arrays:
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
To deactivate the above functions: use the glEnableClientState() with the same above
symbolic constants

void glDisableClientState(GLenum array);

5|P a g e
 2. Specifying Data for the Arrays:
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid
*pointer);
Specifies where spatial coordinate data can be accessed. pointer is the memory
addressof the first coordinate of the first vertex in the array. type specifies the data
type (GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE) of each coordinate in
the array. size is the number of coordinates per vertex, which must be 2, 3, or 4. stride
is the byte offset between consecutive vertices. If stride is 0, the vertices are
understood to be tightly packed in the array. Other similar methods are:
void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid
*pointer);
void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const
GLvoid *pointer);
void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid
*pointer);
void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);

Step 3: Dereferencing and Rendering

In Step 3, contents of the arrays are obtained, sent to the server, and then sent down
thegraphics processing pipeline for rendering.
Dereferencing a Single Array Element:
void glArrayElement(GLint ith)Obtains the data of one (the ith) vertex for all
currently enabled arrays. For the vertex coordinate array, the corresponding command
would be glVertex[size][type]v(), where size is one of [2, 3, 4], and type is one of
[s,i,f,d] for GLshort, GLint, GLfloat, and GLdouble, respectively. Both size and type
were defined by glVertexPointer(). For other enabled arrays, glArrayElement() calls
glEdgeFlagv(), glTexCoord[size][type]v(), glColor[size][type]v(),
glSecondaryColor3[type]v(), glIndex[type]v(), glNormal3[type]v(), and
glFogCoord[type]v().glArrayElement() is usually called between glBegin() and
glEnd().
Example Using glArrayElement() to Define Colors and Vertices
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(3, GL_FLOAT, 0, colors);
glVertexPointer(2, GL_INT, 0, vertices);
glBegin(GL_TRIANGLES);
glArrayElement(2);
glArrayElement(3);
glArrayElement(5);
glEnd();

6|P a g e