chapter07.html

OpenGl红宝书

</TABLE>

<BR>&nbsp;
<H3>
Antialiasing Points or Lines</H3>
To antialias points or lines, you need to turn on antialiasing with <B>glEnable()</B>,
passing in GL_POINT_SMOOTH or GL_LINE_SMOOTH, as appropriate. You might
also want to provide a quality hint with <B>glHint()</B>. (Remember that
you can set the size of a point or the width of a line. You can also stipple
a line. See Chapter 2 .) Next, follow the procedures described in one of
the following sections, depending on whether you're in RGBA or color-index
mode.
<H4>
In RGBA Mode</H4>
In RGBA mode, you need to enable blending. The blending factors you most
likely want to use are GL_SRC_ALPHA (source) and GL_ONE_MINUS_SRC_ALPHA
(destination). Alternatively, you can use GL_ONE for the destination factor
to make lines a little brighter where they intersect. Now you're ready
to draw whatever points or lines you want antialiased. The antialiased
effect is most noticeable if you use a fairly high alpha value. Remember
that since you're performing blending, you might need to consider the rendering
order as described in "Three-Dimensional Blending with the Depth Buffer"
; in most cases, however, the ordering can be ignored without significant
adverse effects. Example 7-3 initializes the necessary modes for antialiasing
and then draws a wireframe icosahedron. Note that the depth buffer isn't
enabled in this example.
<P><B>Example 7-3 : </B>An Antialiased Wireframe Icosahedron: anti.c
<PRE>#include &lt;GL/gl.h>
#include &lt;GL/glu.h>
#include "aux.h"

void myinit(void)
{
&nbsp;&nbsp;&nbsp; GLfloat values[2];
&nbsp;&nbsp;&nbsp; glGetFloatv(GL_LINE_WIDTH_GRANULARITY, values);
&nbsp;&nbsp;&nbsp; printf("GL_LINE_WIDTH_GRANULARITY value is %3.1f\n",&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; values[0]);

&nbsp;&nbsp;&nbsp; glGetFloatv(GL_LINE_WIDTH_RANGE, values);
&nbsp;&nbsp;&nbsp; printf("GL_LINE_WIDTH_RANGE values are %3.1f %3.1f\n",&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; values[0], values[1]);

&nbsp;&nbsp;&nbsp; glEnable(GL_LINE_SMOOTH);
&nbsp;&nbsp;&nbsp; glEnable(GL_BLEND);
&nbsp;&nbsp;&nbsp; glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
&nbsp;&nbsp;&nbsp; glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
&nbsp;&nbsp;&nbsp; glLineWidth(1.5);

&nbsp;&nbsp;&nbsp; glShadeModel(GL_FLAT);
&nbsp;&nbsp;&nbsp; glClearColor(0.0, 0.0, 0.0, 0.0);
&nbsp;&nbsp;&nbsp; glDepthFunc(GL_LEQUAL);
&nbsp;&nbsp;&nbsp; glEnable(GL_DEPTH_TEST);
}

void display(void)
{
&nbsp;&nbsp;&nbsp; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
&nbsp;&nbsp;&nbsp; glColor4f(1.0, 1.0, 1.0, 1.0);
&nbsp;&nbsp;&nbsp; auxWireIcosahedron(1.0);
&nbsp;&nbsp;&nbsp; glFlush();
}

void myReshape(GLsizei w, GLsizei h)
{
&nbsp;&nbsp;&nbsp; glViewport(0, 0, w, h);
&nbsp;&nbsp;&nbsp; glMatrixMode(GL_PROJECTION);
&nbsp;&nbsp;&nbsp; glLoadIdentity();
&nbsp;&nbsp;&nbsp; gluPerspective(45.0, (GLfloat) w/(GLfloat) h, 3.0, 5.0);

&nbsp;&nbsp;&nbsp; glMatrixMode(GL_MODELVIEW);
&nbsp;&nbsp;&nbsp; glLoadIdentity();
&nbsp;&nbsp;&nbsp; glTranslatef(0.0, 0.0, -4.0);&nbsp;
}


int main(int argc, char** argv)
{
&nbsp;&nbsp;&nbsp; auxInitDisplayMode(AUX_SINGLE | AUX_RGBA | AUX_DEPTH);
&nbsp;&nbsp;&nbsp; auxInitPosition(0, 0, 400, 400);
&nbsp;&nbsp;&nbsp; auxInitWindow(argv[0]);
&nbsp;&nbsp;&nbsp; myinit();
&nbsp;&nbsp;&nbsp; auxReshapeFunc(myReshape);
&nbsp;&nbsp;&nbsp; auxMainLoop(display);
}</PRE>

<H4>
In Color-Index Mode</H4>
The tricky part about antialiasing in color-index mode is loading and using
the color map. Since the last 4 bits of the color index indicate the coverage
value, you need to load sixteen contiguous indices with a color ramp from
the background color to the object's color. (The ramp has to start with
an index value that's a multiple of 16.) Then, you clear the color buffer
to the first of the sixteen colors in the ramp and draw your points or
lines using colors in the ramp. Example 7-4 demonstrates how to construct
the color ramp to draw an antialiased wireframe icosahedron in color-index
mode. In this example, the color ramp starts at index 32 and contains shades
of gray.
<P><B>Example 7-4 : </B>Antialiasing in Color-Index Mode: antiindex.c
<PRE>#include &lt;GL/gl.h>
#include &lt;GL/glu.h>
#include "aux.h"

#define RAMPSIZE 16
#define RAMPSTART 32

void myinit(void)
{
&nbsp;&nbsp;&nbsp; int i;

&nbsp;&nbsp;&nbsp; for (i = 0; i &lt; RAMPSIZE; i++) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; GLfloat shade;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; shade = (GLfloat) i/(GLfloat) RAMPSIZE;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; auxSetOneColor(RAMPSTART+(GLint)i, shade, shade, shade);
&nbsp;&nbsp;&nbsp; }

&nbsp;&nbsp;&nbsp; glEnable (GL_LINE_SMOOTH);
&nbsp;&nbsp;&nbsp; glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
&nbsp;&nbsp;&nbsp; glLineWidth (1.5);
&nbsp;&nbsp;&nbsp; glClearIndex ((GLfloat) RAMPSTART);
&nbsp;&nbsp;&nbsp; glShadeModel(GL_FLAT);
&nbsp;&nbsp;&nbsp; glDepthFunc(GL_LEQUAL);
&nbsp;&nbsp;&nbsp; glEnable(GL_DEPTH_TEST);
}

void display(void)
{
&nbsp;&nbsp;&nbsp; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
&nbsp;&nbsp;&nbsp; glIndexi(RAMPSTART);
&nbsp;&nbsp;&nbsp; auxWireIcosahedron(1.0);
&nbsp;&nbsp;&nbsp; glFlush();
}

void myReshape(GLsizei w, GLsizei h)
{
&nbsp;&nbsp;&nbsp; glViewport(0, 0, w, h);
&nbsp;&nbsp;&nbsp; glMatrixMode(GL_PROJECTION);
&nbsp;&nbsp;&nbsp; glLoadIdentity();
&nbsp;&nbsp;&nbsp; gluPerspective (45.0, (GLfloat) w/(GLfloat) h, 3.0, 5.0);

&nbsp;&nbsp;&nbsp; glMatrixMode(GL_MODELVIEW);
&nbsp;&nbsp;&nbsp; glLoadIdentity ();
&nbsp;&nbsp;&nbsp; glTranslatef (0.0, 0.0, -4.0);&nbsp;
}


int main(int argc, char** argv)
{
&nbsp;&nbsp;&nbsp; auxInitDisplayMode (AUX_SINGLE | AUX_INDEX | AUX_DEPTH);
&nbsp;&nbsp;&nbsp; auxInitPosition (0, 0, 400, 400);
&nbsp;&nbsp;&nbsp; auxInitWindow (argv[0]);
&nbsp;&nbsp;&nbsp; myinit();
&nbsp;&nbsp;&nbsp; auxReshapeFunc (myReshape);
&nbsp;&nbsp;&nbsp; auxMainLoop(display);
}</PRE>
Since the color ramp goes from the background color to the object's color,
the antialiased object looks correct only when it's drawn on top of the
background. If the antialiased object is drawn on top of another object,
places where the objects intersect will have the wrong colors, unless you've
constructed your color ramps taking this into consideration. To get the
best result, use the depth buffer to ensure that the pixel colors correspond
to the "nearest" objects. In RGBA mode, however, the colors of both objects
are blended, so the results look more natural. Thus, you typically don't
use the depth buffer when rendering a scene consisting of antialiased points
and lines.
<P><B>Advanced</B>
<P>The trick described in "Three-Dimensional Blending with the Depth Buffer"
can also be used to mix antialiased points and lines with aliased, depth-buffered
polygons. To do this, draw the polygons first, then make the depth buffer
read-only and draw the points and lines. The points and lines will intersect
nicely with each other but will be obscured by nearer polygons.
<H4>
Try This</H4>
Try This
<UL>Take a previous program, such as the robot arm or solar system program
described in "Examples of Composing Several Transformations" and draw wireframe
objects with antialiasing. Try it with either RGBA or color-index mode.
Also try different line widths or point sizes to see their effects.</UL>

<H3>
Antialiasing Polygons</H3>
Antialiasing the edges of filled polygons is similar to antialiasing points
and lines. When different polygons have overlapping edges, you need to
blend the color values appropriately. You can either use the method described
in this section, or you can use the accumulation buffer to perform antialiasing
for your entire scene. Using the accumulation buffer, which is described
in Chapter 10 , is easier from your point of view, but it's much more computation-intensive
and therefore slower. However, as you'll see, the method described here
is rather cumbersome
<P>If you draw your polygons as points at the vertices or as outlines -
that is, by passing GL_POINT or GL_LINE to <B>glPolygonMode()</B> - point
or line antialiasing is applied, if enabled as described earlier. The rest
of this section addresses polygon antialiasing when you're using GL_FILL
as the polygon mode.
<P>In theory, you can antialias polygons in either RGBA or color-index
mode. However, object intersections affect polygon antialiasing more than
they affect point or line antialiasing, so rendering order and blending
accuracy become more critical. In fact, they're so critical that if you're
antialiasing more than one polygon, you need to order the polygons from
front to back and then use <B>glBlendFunc()</B> with GL_SRC_ALPHA_SATURATE
for the source factor and GL_ONE for the destination factor. Thus, antialiasing
polygons in color-index mode normally isn't practical.
<P>To antialias polygons in RGBA mode, you use the alpha value to represent
coverage values of polygon edges. You need to enable polygon antialiasing
by passing GL_POLYGON_SMOOTH to <B>glEnable()</B>. This causes pixels on
the edges of the polygon to be assigned fractional alpha values based on
their coverage, as though they were lines being antialiased. Also, if you
desire, you can supply a value for GL_POLYGON_SMOOTH_HINT.
<P>Now you need to blend overlapping edges appropriately. First, turn off
the depth buffer so that you have control over how overlapping pixels are
drawn. Then set the blending factors to GL_SRC_ALPHA_SATURATE (source)
and GL_ONE (destination). With this specialized blending function, the
final color is the sum of the destination color and the scaled source color;
the scale factor is the smaller of either the incoming source alpha value
or one minus the destination alpha value. This means that for a pixel with
a large alpha value, successive incoming pixels have little effect on the
final color because one minus the destination alpha is almost zero. With
this method, a pixel on the edge of a polygon might be blended eventually
with the colors from another polygon that's drawn later. Finally, you need
to sort all the polygons in your scene so that they're ordered from front
to back before drawing them.
<P>Example 7-5 shows how to antialias filled polygons; clicking the left
mouse button toggles the antialiasing on and off. Note that backward-facing
polygons are culled and that the alpha values in the color buffer are cleared
to zero before any drawing. (Your color buffer must store alpha values
for this technique to work correctly.)
<P><B>Example 7-5 : </B>Antialiasing Filled Polygons: antipoly.c
<PRE>#include &lt;GL/gl.h>
#include &lt;GL/glu.h>
#include "aux.h"

GLboolean polySmooth;

void myinit(void)
{
&nbsp;&nbsp;&nbsp; GLfloat mat_ambient[] = { 0.0, 0.0, 0.0, 1.00 };
&nbsp;&nbsp;&nbsp; GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.00 };
&nbsp;&nbsp;&nbsp; GLfloat mat_shininess[] = { 15.0 };

&nbsp;&nbsp;&nbsp; glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
&nbsp;&nbsp;&nbsp; glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
&nbsp;&nbsp;&nbsp; glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

&nbsp;&nbsp;&nbsp; glEnable (GL_LIGHTING);
&nbsp;&nbsp;&nbsp; glEnable (GL_LIGHT0);
&nbsp;&nbsp;&nbsp; glEnable (GL_BLEND);
&nbsp;&nbsp;&nbsp; glCullFace (GL_BACK);
&nbsp;&nbsp;&nbsp; glEnable (GL_CULL_FACE);
&nbsp;&nbsp;&nbsp; glEnable (GL_POLYGON_SMOOTH);
&nbsp;&nbsp;&nbsp; polySmooth = GL_TRUE;

&nbsp;&nbsp;&nbsp; glClearColor (0.0, 0.0, 0.0, 0.0);
}

void toggleSmooth (AUX_EVENTREC *event)
{
&nbsp;&nbsp;&nbsp; if (polySmooth) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; polySmooth = GL_FALSE;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glDisable (GL_BLEND);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glDisable (GL_POLYGON_SMOOTH);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glEnable (GL_DEPTH_TEST);
&nbsp;&nbsp;&nbsp; }
&nbsp;&nbsp;&nbsp; else {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; polySmooth = GL_TRUE;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glEnable (GL_BLEND);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glEnable (GL_POLYGON_SMOOTH);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glDisable (GL_DEPTH_TEST);
&nbsp;&nbsp;&nbsp; }
}

void display(void)
{
&nbsp;&nbsp;&nbsp; GLfloat position[] = { 0.0, 0.0, 1.0, 0.0 };
&nbsp;&nbsp;&nbsp; GLfloat mat_cube1[] = { 0.75, 0.75, 0.0, 1.0 };
&nbsp;&nbsp;&nbsp; GLfloat mat_cube2[] = { 0.0, 0.75, 0.75, 1.0 };

&nbsp;&nbsp;&nbsp; if (polySmooth)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glClear (GL_COLOR_BUFFER_BIT);
&nbsp;&nbsp;&nbsp; else&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

&nbsp;&nbsp;&nbsp; glPushMatrix ();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glTranslatef (0.0, 0.0, -8.0);&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glLightfv (GL_LIGHT0, GL_POSITION, position);

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glBlendFunc (GL_SRC_ALPHA_SATURATE, GL_ONE);

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glPushMatrix ();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glRotatef (30.0, 1.0, 0.0, 0.0);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glRotatef (60.0, 0.0, 1.0, 0.0);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_cube1);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; auxSolidCube (1.0, 1.0, 1.0);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glPopMatrix ();

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glTranslatef (0.0, 0.0, -2.0);&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_cube2);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glRotatef (30.0, 0.0, 1.0, 0.0);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; glRotatef (60.0, 1.0, 0.0, 0.0);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; auxSolidCube (1.0);

&nbsp;&nbsp;&nbsp; glPopMatrix ();

&nbsp;&nbsp;&nbsp; glFlush ();
}