📄 chapter11.html
字号:
glBegin(GL_LINES);
for (j = nv1; j <= nv2; j++)
glEvalCoord2(u1 + i*(u2-u1)/nu, v1+j*(v2-v1)/nv);
glEnd();
}
for (j = nv1; j <= nv2; j++) {
glBegin(GL_LINES);
for (i = nu1; i <= nu2; i++)
glEvalCoord2(u1 + i*(u2-u1)/nu, v1+j*(v2-v1)/nv);
glEnd();
}</PRE>
or
<PRE>for (i = nu1; i < nu2; i++) { /* mode == GL_FILL */
glBegin(GL_QUAD_STRIP);
for (j = nv1; j <= nv2; j++) {
glEvalCoord2(u1 + i*(u2-u1)/nu, v1+j*(v2-v1)/nv);
glEvalCoord2(u1 + (i+1)*(u2-u1)/nu, v1+j*(v2-v1)/nv);
glEnd();
}</PRE>
Example 11-3 shows the differences necessary to draw the same B閦ier surface
as Example 11-2 , but using <B>glMapGrid2()</B> and <B>glEvalMesh2()</B>
to subdivide the square domain into a uniform 8x8 grid. This program also
adds lighting and shading, as shown in Figure 11-3 .
<P><IMG SRC="figures/bezmesh.gif" ALT="[IMAGE]" NOSAVE >
<P><B>Figure 11-3 : </B>A Lit, Shaded B閦ier Surface Drawn Using a Mesh
<BR>
<BR>
<P><B>Example 11-3 : </B>Drawing a Lit, Shaded B閦ier Surface Using a Mesh:
bezmesh.c
<PRE>void initlights(void)
{
GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 };
GLfloat position[] = { 0.0, 0.0, 2.0, 1.0 };
GLfloat mat_diffuse[] = { 0.6, 0.6, 0.6, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS, mat_shininess);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(85.0, 1.0, 1.0, 1.0);
glEvalMesh2(GL_FILL, 0, 8, 0, 8);
glPopMatrix();
glFlush();
}
void myinit(void)
{
glClearColor (0.0, 0.0, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
0, 1, 12, 4, &ctrlpoints[0][0][0]);
glEnable(GL_MAP2_VERTEX_3);
glEnable(GL_AUTO_NORMAL);
glMapGrid2f(8, 0.0, 1.0, 8, 0.0, 1.0);
initlights();
}</PRE>
<HR>
<H3>
Example: Using Evaluators for Textures</H3>
Example 11-4 enables two evaluators at the same time: The first generates
three-dimensional points on the same B閦ier surface as Example 11-3 , and
the second generates texture coordinates. In this case, the texture coordinates
are the same as the <I>u</I> and <I>v</I> coordinates of the surface, but
a special flat B閦ier patch must be created to do this.
<P>The flat patch is defined over a square with corners at (0, 0), (0,
1), (1, 0), and (1, 1); it generates (0, 0) at corner (0, 0), (0, 1) at
corner (0, 1), and so on. Since it's of order 2 (linear degree plus one),
evaluating this texture at the point (<I>u, v</I>) generates texture coordinates
(<I>s, t</I>). It's enabled at the same time as the vertex evaluator, so
both take effect when the surface is drawn. See Figure J-26 . If you want
the texture to repeat three times in each direction, change every 1.0 in
the array <B>texpts[][][]</B> to 3.0. Since the texture wraps in this example,
the surface is rendered with nine copies of the texture map.
<P><B>Example 11-4 : </B>Using Evaluators for Textures: texturesurf.c
<PRE>#include <GL/gl.h>
#include <GL/glu.h>
#include "aux.h"
#include <math.h>
GLfloat ctrlpoints[4][4][3] = {
{{ -1.5, -1.5, 4.0}, { -0.5, -1.5, 2.0},
{0.5, -1.5, -1.0}, {1.5, -1.5, 2.0}},
{{ -1.5, -0.5, 1.0}, { -0.5, -0.5, 3.0},
{0.5, -0.5, 0.0}, {1.5, -0.5, -1.0}},
{{ -1.5, 0.5, 4.0}, { -0.5, 0.5, 0.0},
{0.5, 0.5, 3.0}, {1.5, 0.5, 4.0}},
{{ -1.5, 1.5, -2.0}, { -0.5, 1.5, -2.0},
{0.5, 1.5, 0.0}, {1.5, 1.5, -1.0}}
};
GLfloat texpts[2][2][2] = {{{0.0, 0.0}, {0.0, 1.0}},
{{1.0, 0.0}, {1.0, 1.0}}};
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glEvalMesh2(GL_FILL, 0, 20, 0, 20);
glFlush();
}
#define imageWidth 64
#define imageHeight 64
GLubyte image[3*imageWidth*imageHeight];
void loadImage(void)
{
int i, j;
float ti, tj;
for (i = 0; i < imageWidth; i++) {
ti = 2.0*3.14159265*i/imageWidth;
for (j = 0; j < imageHeight; j++) {
tj = 2.0*3.14159265*j/imageHeight;
image[3*(imageHeight*i+j)] =
(GLubyte) 127*(1.0+sin(ti));
image[3*(imageHeight*i+j)+1] =
(GLubyte) 127*(1.0+cos(2*tj));
image[3*(imageHeight*i+j)+2] =
(GLubyte) 127*(1.0+cos(ti+tj));
}
}
}
void myinit(void)
{
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
0, 1, 12, 4, &ctrlpoints[0][0][0]);
glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2,
0, 1, 4, 2, &texpts[0][0][0]);
glEnable(GL_MAP2_TEXTURE_COORD_2);
glEnable(GL_MAP2_VERTEX_3);
glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
loadImage();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, 3, imageWidth, imageHeight,
0, GL_RGB, GL_UNSIGNED_BYTE, image);
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glShadeModel (GL_FLAT);
}
void myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-4.0, 4.0, -4.0*(GLfloat)h/(GLfloat)w,
4.0*(GLfloat)h/(GLfloat)w, -4.0, 4.0);
else
glOrtho(-4.0*(GLfloat)w/(GLfloat)h,
4.0*(GLfloat)w/(GLfloat)h, -4.0, 4.0, -4.0, 4.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(85.0, 1.0, 1.0, 1.0);
}
int main(int argc, char** argv)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA | AUX_DEPTH);
auxInitPosition (0, 0, 300, 300);
auxInitWindow (argv[0]);
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}</PRE>
<HR>
<H2>
The GLU NURBS Interface</H2>
Although evaluators are the only OpenGL primitive available to directly
draw curves and surfaces, and even though they can be implemented very
efficiently in hardware, they're often accessed by applications through
higher-level libraries. The GLU provides a NURBS (Non-Uniform Rational
B-Spline) interface built on top of the OpenGL evaluator commands.
<P>
<HR>
<H3>
A Simple NURBS Example</H3>
If you understand NURBS, writing OpenGL code to manipulate NURBS curves
and surfaces is relatively easy, even with lighting and texture mapping.
Follow these steps to draw NURBS curves or untrimmed NURBS surfaces. (Trimmed
surfaces are discussed in "Trimming." )
<OL>If you intend to use lighting with a NURBS surface, call <B>glEnable()</B>
with GL_AUTO_NORMAL to automatically generate surface normals. (Or you
can calculate your own.)
<BR>
<P>Use <B>gluNewNurbsRenderer()</B> to create a pointer to a NURBS object,
which is referred to when creating your NURBS curve or surface.
<BR>
<P>If desired, call <B>gluNurbsProperty()</B> to choose rendering values,
such as the maximum size of lines or polygons that are used to render your
NURBS object.
<BR>
<P>Call <B>gluNurbsCallback()</B> if you want to be notified when an error
is encountered. (Error checking may slightly degrade performance.)
<BR>
<P>Start your curve or surface by calling <B>gluBeginCurve()</B> or <B>gluBeginSurface()</B>.
<BR>
<P>Generate and render your curve or surface. Call <B>gluNurbsCurve()</B>
or <B>gluNurbsSurface()</B> at least once with the control points (rational
or nonrational), knot sequence, and order of the polynomial basis function
for your NURBS object. You might call these functions additional times
to specify surface normals and/or texture coordinates.
<BR>
<P>Call <B>gluEndCurve()</B> or <B>gluEndSurface() </B>to complete the
curve or surface.</OL>
Example 11-5 renders a NURBS surface in the shape of a symmetrical hill
with control points ranging from -3.0 to 3.0. The basis function is a cubic
B-spline, but the knot sequence is nonuniform, with a multiplicity of 4
at each endpoint, causing the basis function to behave like a B閦ier curve
in each direction. The surface is lighted, with a dark gray diffuse reflection
and white specular highlights. Figure 11-4 shows the surface as a wireframe
and lighted.
<P><IMG SRC="figures/surface.both.gif" ALT="[IMAGE]" NOSAVE >
<P><B>Figure 11-4 : </B>A NURBS Surface
<BR>
<BR>
<P><B>Example 11-5 : </B>Drawing a NURBS Surface: surface.c
<PRE>#include <GL/gl.h>
#include <GL/glu.h>
#include "aux.h"
GLfloat ctlpoints[4][4][3];
GLUnurbsObj *theNurb;
void init_surface(void)
{
int u, v;
for (u = 0; u < 4; u++) {
for (v = 0; v < 4; v++) {
ctlpoints[u][v][0] = 2.0*((GLfloat)u - 1.5);
ctlpoints[u][v][1] = 2.0*((GLfloat)v - 1.5);
if ( (u == 1 || u == 2) && (v == 1 || v == 2))
ctlpoints[u][v][2] = 3.0;
else
ctlpoints[u][v][2] = -3.0;
}
}
}
void myinit(void)
{
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glClearColor (0.0, 0.0, 0.0, 1.0);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -