further worked on the teapot drawing code:

cleaned up some debug stuff, and generalized the code
now added teacup and teaspoon too, so we have Newell's set complete
As source attribution, i copied in the whole original email message that the data was taken from, and where i downloaded that email message
fixed z offset as well, so all three objects now drawn centered

git-svn-id: https://svn.code.sf.net/p/freeglut/code/trunk@1569 7f0cb862-5218-0410-a997-914c9d46530a
This commit is contained in:
dcnieho 2013-04-01 11:46:20 +00:00
parent 78b4e988c4
commit 1af0007c38
7 changed files with 1380 additions and 225 deletions

View File

@ -174,6 +174,15 @@ FGAPI void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, double offs
FGAPI void FGAPIENTRY glutWireCylinder( double radius, double height, GLint slices, GLint stacks);
FGAPI void FGAPIENTRY glutSolidCylinder( double radius, double height, GLint slices, GLint stacks);
/*
* Rest of functions for rendering Newell's teaset, found in freeglut_teapot.c
* NB: front facing polygons have clockwise winding, not counter clockwise
*/
FGAPI void FGAPIENTRY glutWireTeacup( double size );
FGAPI void FGAPIENTRY glutSolidTeacup( double size );
FGAPI void FGAPIENTRY glutWireTeaspoon( double size );
FGAPI void FGAPIENTRY glutSolidTeaspoon( double size );
/*
* Extension functions, see freeglut_ext.c
*/

View File

@ -559,10 +559,8 @@ FGAPI void FGAPIENTRY glutSolidIcosahedron( void );
* Teapot rendering functions, found in freeglut_teapot.c
* NB: front facing polygons have clockwise winding, not counter clockwise
*/
#ifndef EGL_VERSION_1_0
FGAPI void FGAPIENTRY glutWireTeapot( double size );
FGAPI void FGAPIENTRY glutSolidTeapot( double size );
#endif
/*
* Game mode functions, see freeglut_gamemode.c

View File

@ -462,24 +462,22 @@ static void drawSolidCone(void) { glutSolidCone(irad,orad,slices,
static void drawWireCone(void) { glutWireCone(irad,orad,slices,stacks); } /* irad doubles as base input, and orad as height input */
static void drawSolidCylinder(void) { glutSolidCylinder(irad,orad,slices,stacks); } /* irad doubles as radius input, and orad as height input */
static void drawWireCylinder(void) { glutWireCylinder(irad,orad,slices,stacks); } /* irad doubles as radius input, and orad as height input */
/* per Glut manpage, it should be noted that the teapot is rendered
* with clockwise winding for front facing polygons...
* Same for the teacup and teaspoon
*/
static void drawSolidTeapot(void)
{
/* per Glut manpage, it should be noted that the teapot is rendered
* with clockwise winding for front facing polygons...
*/
glFrontFace(GL_CW);
glutSolidTeapot(orad); /* orad doubles as size input */
glFrontFace(GL_CCW);
}
{ glFrontFace(GL_CW); glutSolidTeapot(orad); glFrontFace(GL_CCW); /* orad doubles as size input */}
static void drawWireTeapot(void)
{
/* per Glut manpage, it should be noted that the teapot is rendered
* with clockwise winding for front facing polygons...
*/
glFrontFace(GL_CW);
glutWireTeapot(orad); /* orad doubles as size input */
glFrontFace(GL_CCW);
}
{ glFrontFace(GL_CW); glutWireTeapot(orad); glFrontFace(GL_CCW); /* orad doubles as size input */}
static void drawSolidTeacup(void)
{ glFrontFace(GL_CW); glutSolidTeacup(orad); glFrontFace(GL_CCW); /* orad doubles as size input */}
static void drawWireTeacup(void)
{ glFrontFace(GL_CW); glutWireTeacup(orad); glFrontFace(GL_CCW); /* orad doubles as size input */}
static void drawSolidTeaspoon(void)
{ glFrontFace(GL_CW); glutSolidTeaspoon(orad); glFrontFace(GL_CCW); /* orad doubles as size input */}
static void drawWireTeaspoon(void)
{ glFrontFace(GL_CW); glutWireTeaspoon(orad); glFrontFace(GL_CCW); /* orad doubles as size input */}
#define RADIUSFAC 0.70710678118654752440084436210485f
@ -554,6 +552,8 @@ static const entry table [] =
ENTRY (Icosahedron,GEO_NO_SIZE),
ENTRY (SierpinskiSponge,GEO_SCALE),
ENTRY (Teapot,GEO_SIZE),
ENTRY (Teacup,GEO_SIZE),
ENTRY (Teaspoon,GEO_SIZE),
ENTRY (Torus,GEO_INNER_OUTER_RAD),
ENTRY (Sphere,GEO_RAD),
ENTRY (Cone,GEO_BASE_HEIGHT),

View File

@ -135,10 +135,12 @@ static GLUTproc fghGetGLUTProcAddress( const char* procName )
CHECK_NAME(glutSolidTorus);
CHECK_NAME(glutWireCylinder);
CHECK_NAME(glutSolidCylinder);
#ifndef EGL_VERSION_1_0
CHECK_NAME(glutWireTeapot);
CHECK_NAME(glutSolidTeapot);
#endif
CHECK_NAME(glutWireTeacup);
CHECK_NAME(glutSolidTeacup);
CHECK_NAME(glutWireTeaspoon);
CHECK_NAME(glutSolidTeaspoon);
CHECK_NAME(glutWireCube);
CHECK_NAME(glutSolidCube);
CHECK_NAME(glutWireDodecahedron);

View File

@ -37,14 +37,9 @@
/* -- STATIC VARS: CACHES ---------------------------------------------------- */
/* Teapot defs */
#define GLUT_TEAPOT_N_PATCHES (6*4 + 4*2) /* 6 patches are reproduced (rotated) 4 times, 4 patches (flipped) 2 times */
#define GLUT_SOLID_TEAPOT_N_SUBDIV 10
#define GLUT_SOLID_TEAPOT_N_VERT GLUT_SOLID_TEAPOT_N_SUBDIV*GLUT_SOLID_TEAPOT_N_SUBDIV * GLUT_TEAPOT_N_PATCHES /* N_SUBDIV^2 vertices per patch */
#define GLUT_SOLID_TEAPOT_N_TRI (GLUT_SOLID_TEAPOT_N_SUBDIV-1)*(GLUT_SOLID_TEAPOT_N_SUBDIV-1) * GLUT_TEAPOT_N_PATCHES * 2 /* if e.g. 7x7 vertices for each patch, there are 6*6 squares for each patch. Each square is decomposed into 2 triangles */
#define GLUT_WIRE_TEAPOT_N_SUBDIV 7
#define GLUT_WIRE_TEAPOT_N_VERT GLUT_WIRE_TEAPOT_N_SUBDIV*GLUT_WIRE_TEAPOT_N_SUBDIV * GLUT_TEAPOT_N_PATCHES /* N_SUBDIV^2 vertices per patch */
/* General defs */
#define GLUT_SOLID_N_SUBDIV 8
#define GLUT_WIRE_N_SUBDIV 10
/* Bernstein coefficients only have to be precomputed once (number of patch subdivisions is fixed)
* Can thus define arrays for them here, they will be filled upon first use.
@ -52,28 +47,89 @@
* Have separate caches for solid and wire as they use a different number of subdivisions
* _0 is for Bernstein polynomials, _1 for their first derivative (which we need for normals)
*/
static GLfloat bernWire_0 [GLUT_WIRE_TEAPOT_N_SUBDIV] [4];
static GLfloat bernWire_1 [GLUT_WIRE_TEAPOT_N_SUBDIV] [4];
static GLfloat bernSolid_0[GLUT_SOLID_TEAPOT_N_SUBDIV][4];
static GLfloat bernSolid_1[GLUT_SOLID_TEAPOT_N_SUBDIV][4];
static GLfloat bernWire_0 [GLUT_WIRE_N_SUBDIV] [4];
static GLfloat bernWire_1 [GLUT_WIRE_N_SUBDIV] [4];
static GLfloat bernSolid_0[GLUT_SOLID_N_SUBDIV][4];
static GLfloat bernSolid_1[GLUT_SOLID_N_SUBDIV][4];
/* Teapot defs */
#define GLUT_TEAPOT_N_PATCHES (6*4 + 4*2) /* 6 patches are reproduced (rotated) 4 times, 4 patches (flipped) 2 times */
#define GLUT_SOLID_TEAPOT_N_VERT GLUT_SOLID_N_SUBDIV*GLUT_SOLID_N_SUBDIV * GLUT_TEAPOT_N_PATCHES /* N_SUBDIV^2 vertices per patch */
#define GLUT_SOLID_TEAPOT_N_TRI (GLUT_SOLID_N_SUBDIV-1)*(GLUT_SOLID_N_SUBDIV-1) * GLUT_TEAPOT_N_PATCHES * 2 /* if e.g. 7x7 vertices for each patch, there are 6*6 squares for each patch. Each square is decomposed into 2 triangles */
#define GLUT_WIRE_TEAPOT_N_VERT GLUT_WIRE_N_SUBDIV*GLUT_WIRE_N_SUBDIV * GLUT_TEAPOT_N_PATCHES /* N_SUBDIV^2 vertices per patch */
/* Bit of caching:
* vertex indices and normals only need to be generated once for
* a given number of subdivisions as they don't change with scale.
* Vertices can be cached and reused if scale didn't change.
*/
static GLushort vertIdxsSolid[GLUT_SOLID_TEAPOT_N_TRI*3];
static GLfloat normsSolid [GLUT_SOLID_TEAPOT_N_VERT*3];
static GLfloat vertsSolid [GLUT_SOLID_TEAPOT_N_VERT*3];
static GLfloat texcsSolid [GLUT_SOLID_TEAPOT_N_VERT*2];
static GLfloat lastScaleSolid = 0.f;
static GLboolean initedSolid = GL_FALSE;
static GLushort vertIdxsTeapotS[GLUT_SOLID_TEAPOT_N_TRI*3];
static GLfloat normsTeapotS [GLUT_SOLID_TEAPOT_N_VERT*3];
static GLfloat vertsTeapotS [GLUT_SOLID_TEAPOT_N_VERT*3];
static GLfloat texcsTeapotS [GLUT_SOLID_TEAPOT_N_VERT*2];
static GLfloat lastScaleTeapotS = 0.f;
static GLboolean initedTeapotS = GL_FALSE;
static GLushort vertIdxsTeapotW[GLUT_WIRE_TEAPOT_N_VERT*2];
static GLfloat normsTeapotW [GLUT_WIRE_TEAPOT_N_VERT*3];
static GLfloat vertsTeapotW [GLUT_WIRE_TEAPOT_N_VERT*3];
static GLfloat lastScaleTeapotW = 0.f;
static GLboolean initedTeapotW = GL_FALSE;
/* Teacup defs */
#define GLUT_TEACUP_N_PATCHES (6*4 + 1*2) /* 6 patches are reproduced (rotated) 4 times, 1 patch (flipped) 2 times */
#define GLUT_SOLID_TEACUP_N_VERT GLUT_SOLID_N_SUBDIV*GLUT_SOLID_N_SUBDIV * GLUT_TEACUP_N_PATCHES /* N_SUBDIV^2 vertices per patch */
#define GLUT_SOLID_TEACUP_N_TRI (GLUT_SOLID_N_SUBDIV-1)*(GLUT_SOLID_N_SUBDIV-1) * GLUT_TEACUP_N_PATCHES * 2 /* if e.g. 7x7 vertices for each patch, there are 6*6 squares for each patch. Each square is decomposed into 2 triangles */
#define GLUT_WIRE_TEACUP_N_VERT GLUT_WIRE_N_SUBDIV*GLUT_WIRE_N_SUBDIV * GLUT_TEACUP_N_PATCHES /* N_SUBDIV^2 vertices per patch */
/* Bit of caching:
* vertex indices and normals only need to be generated once for
* a given number of subdivisions as they don't change with scale.
* Vertices can be cached and reused if scale didn't change.
*/
static GLushort vertIdxsTeacupS[GLUT_SOLID_TEACUP_N_TRI*3];
static GLfloat normsTeacupS [GLUT_SOLID_TEACUP_N_VERT*3];
static GLfloat vertsTeacupS [GLUT_SOLID_TEACUP_N_VERT*3];
static GLfloat texcsTeacupS [GLUT_SOLID_TEACUP_N_VERT*2];
static GLfloat lastScaleTeacupS = 0.f;
static GLboolean initedTeacupS = GL_FALSE;
static GLushort vertIdxsTeacupW[GLUT_WIRE_TEACUP_N_VERT*2];
static GLfloat normsTeacupW [GLUT_WIRE_TEACUP_N_VERT*3];
static GLfloat vertsTeacupW [GLUT_WIRE_TEACUP_N_VERT*3];
static GLfloat lastScaleTeacupW = 0.f;
static GLboolean initedTeacupW = GL_FALSE;
/* Teaspoon defs */
#define GLUT_TEASPOON_N_PATCHES GLUT_TEASPOON_N_INPUT_PATCHES
#define GLUT_SOLID_TEASPOON_N_VERT GLUT_SOLID_N_SUBDIV*GLUT_SOLID_N_SUBDIV * GLUT_TEASPOON_N_PATCHES /* N_SUBDIV^2 vertices per patch */
#define GLUT_SOLID_TEASPOON_N_TRI (GLUT_SOLID_N_SUBDIV-1)*(GLUT_SOLID_N_SUBDIV-1) * GLUT_TEASPOON_N_PATCHES * 2 /* if e.g. 7x7 vertices for each patch, there are 6*6 squares for each patch. Each square is decomposed into 2 triangles */
#define GLUT_WIRE_TEASPOON_N_VERT GLUT_WIRE_N_SUBDIV*GLUT_WIRE_N_SUBDIV * GLUT_TEASPOON_N_PATCHES /* N_SUBDIV^2 vertices per patch */
/* Bit of caching:
* vertex indices and normals only need to be generated once for
* a given number of subdivisions as they don't change with scale.
* Vertices can be cached and reused if scale didn't change.
*/
static GLushort vertIdxsTeaspoonS[GLUT_SOLID_TEASPOON_N_TRI*3];
static GLfloat normsTeaspoonS [GLUT_SOLID_TEASPOON_N_VERT*3];
static GLfloat vertsTeaspoonS [GLUT_SOLID_TEASPOON_N_VERT*3];
static GLfloat texcsTeaspoonS [GLUT_SOLID_TEASPOON_N_VERT*2];
static GLfloat lastScaleTeaspoonS = 0.f;
static GLboolean initedTeaspoonS = GL_FALSE;
static GLushort vertIdxsTeaspoonW[GLUT_WIRE_TEASPOON_N_VERT*2];
static GLfloat normsTeaspoonW [GLUT_WIRE_TEASPOON_N_VERT*3];
static GLfloat vertsTeaspoonW [GLUT_WIRE_TEASPOON_N_VERT*3];
static GLfloat lastScaleTeaspoonW = 0.f;
static GLboolean initedTeaspoonW = GL_FALSE;
static GLushort vertIdxsWire [GLUT_WIRE_TEAPOT_N_VERT*2];
static GLfloat normsWire [GLUT_WIRE_TEAPOT_N_VERT*3];
static GLfloat vertsWire [GLUT_WIRE_TEAPOT_N_VERT*3];
static GLfloat lastScaleWire = 0.f;
static GLboolean initedWire = GL_FALSE;
/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
extern void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
@ -271,33 +327,29 @@ static int evalBezier(GLfloat cp[4][4][3], int nSubDivs, float (*bern_0)[4], int
return nVertVals*flag;
}
static void fghTeapot( GLfloat scale, GLboolean useWireMode )
static void fghTeaset( GLfloat scale, GLboolean useWireMode,
GLfloat (*cpdata)[3], int (*patchdata)[16],
GLushort *vertIdxs,
GLfloat *verts, GLfloat *norms, GLfloat *texcs,
GLfloat *lastScale, GLboolean *inited,
GLboolean needNormalFix, GLboolean rotFlip, GLfloat zOffset,
int nVerts, int nInputPatches, int nPatches, int nTriangles )
{
/* for internal use */
int p,o;
GLfloat cp[4][4][3];
/* to hold pointers to static vars/arrays */
GLfloat (*bern_0)[4], (*bern_1)[4];
GLfloat *verts, *norms, *lastScale;
GLushort *vertIdxs;
GLboolean * inited;
int nSubDivs, nVerts;
int nSubDivs;
/* Get relevant static arrays and variables */
bern_0 = useWireMode ? bernWire_0 : bernSolid_0;
bern_1 = useWireMode ? bernWire_1 : bernSolid_1;
verts = useWireMode ? vertsWire : vertsSolid;
norms = useWireMode ? normsWire : normsSolid;
lastScale = useWireMode ? &lastScaleWire : &lastScaleSolid;
vertIdxs = useWireMode ? vertIdxsWire : vertIdxsSolid;
inited = useWireMode ? &initedWire : &initedSolid;
nSubDivs = useWireMode ? GLUT_WIRE_TEAPOT_N_SUBDIV : GLUT_SOLID_TEAPOT_N_SUBDIV;
nVerts = useWireMode ? GLUT_WIRE_TEAPOT_N_VERT : GLUT_SOLID_TEAPOT_N_VERT;
nSubDivs = useWireMode ? GLUT_WIRE_N_SUBDIV : GLUT_SOLID_N_SUBDIV;
/* check if need to generate vertices */
if (!*inited || scale != *lastScale)
{
printf("regen\n");
/* set vertex array to all 0 (not necessary for normals and vertex indices) */
memset(verts,0,nVerts*3*sizeof(GLfloat));
@ -306,26 +358,26 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
pregenBernstein(nSubDivs,bern_0,bern_1);
/* generate vertices and normals */
for (p=0, o=0; p<GLUT_TEAPOT_N_INPUT_PATCHES; p++)
for (p=0, o=0; p<nInputPatches; p++)
{
/* set flags for evalBezier function */
int flag = p<6?4:2; /* first six patches get 3 copies (rotations), last four get 2 copies (flips) */
int normalFix = p==3?1:p==5?2:0; /* Fix normal vectors for vertices on top of lid (patch 4) and on middle of bottom (patch 6). Different flag value as different normal needed */
int flag = rotFlip?p<6?4:2:1; /* For teapot and teacup, first six patches get 3 copies (rotations), others get 2 copies (flips). No rotating or flipping at all for teaspoon */
int normalFix = needNormalFix?p==3?1:p==5?2:0:0; /* For teapot, fix normal vectors for vertices on top of lid (patch 4) and on middle of bottom (patch 6). Different flag value as different normal needed */
/* collect control points */
int i;
for (i=0; i<16; i++)
{
/* Original code draw with a 270° rot around X axis, a scaling and a translation along the Z-axis.
/* Original code draws with a 270° rot around X axis, a scaling and a translation along the Z-axis.
* Incorporating these in the control points is much cheaper than transforming all the vertices.
* Original:
* glRotated( 270.0, 1.0, 0.0, 0.0 );
* glScaled( 0.5 * scale, 0.5 * scale, 0.5 * scale );
* glTranslated( 0.0, 0.0, -1.5 );
* glTranslated( 0.0, 0.0, -zOffset ); -> was 1.5 for teapot, but should be 1.575 to center it on the Z axis. Teacup and teaspoon have different offsets
*/
cp[i/4][i%4][0] = cpdata[patchdata[p][i]][0] *scale/2.f;
cp[i/4][i%4][1] = (cpdata[patchdata[p][i]][2]-1.5f)*scale/2.f;
cp[i/4][i%4][2] = -cpdata[patchdata[p][i]][1] *scale/2.f;
cp[i/4][i%4][0] = cpdata[patchdata[p][i]][0] *scale/2.f;
cp[i/4][i%4][1] = (cpdata[patchdata[p][i]][2]-zOffset)*scale/2.f;
cp[i/4][i%4][2] = -cpdata[patchdata[p][i]][1] *scale/2.f;
}
/* eval bezier patch */
@ -339,7 +391,7 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
if (!*inited)
{
int r,c;
/* generate texture coordinates if solid teapot */
/* generate texture coordinates if solid teapot/teacup/teaspoon */
if (!useWireMode)
{
/* generate for first patch */
@ -349,21 +401,21 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
for (c=0; c<nSubDivs; c++, o+=2)
{
GLfloat v = c/(nSubDivs-1.f);
texcsSolid[o+0] = u;
texcsSolid[o+1] = v;
texcs[o+0] = u;
texcs[o+1] = v;
}
}
/* copy it over for all the other patches */
for (p=1; p<GLUT_TEAPOT_N_PATCHES; p++)
memcpy(texcsSolid+p*nSubDivs*nSubDivs*2,texcsSolid,nSubDivs*nSubDivs*2*sizeof(GLfloat));
for (p=1; p<nPatches; p++)
memcpy(texcs+p*nSubDivs*nSubDivs*2,texcs,nSubDivs*nSubDivs*2*sizeof(GLfloat));
}
/* build vertex index array */
if (useWireMode)
{
/* build vertex indices to draw teapot as line strips */
/* build vertex indices to draw teapot/teacup/teaspoon as line strips */
/* first strips along increasing u, constant v */
for (p=0, o=0; p<GLUT_TEAPOT_N_PATCHES; p++)
for (p=0, o=0; p<nPatches; p++)
{
int idx = nSubDivs*nSubDivs*p;
for (c=0; c<nSubDivs; c++)
@ -372,7 +424,7 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
}
/* then strips along increasing v, constant u */
for (p=0; p<GLUT_TEAPOT_N_PATCHES; p++) /* don't reset o, we continue appending! */
for (p=0; p<nPatches; p++) /* don't reset o, we continue appending! */
{
int idx = nSubDivs*nSubDivs*p;
for (r=0; r<nSubDivs; r++)
@ -385,8 +437,8 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
}
else
{
/* build vertex indices to draw teapot as triangles */
for (p=0,o=0; p<GLUT_TEAPOT_N_PATCHES; p++)
/* build vertex indices to draw teapot/teacup/teaspoon as triangles */
for (p=0,o=0; p<nPatches; p++)
{
int idx = nSubDivs*nSubDivs*p;
for (r=0; r<nSubDivs-1; r++)
@ -415,11 +467,10 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
}
/* draw */
// TODO: texture coordinates
if (useWireMode)
fghDrawGeometryWire(verts, norms, nVerts, vertIdxs, GLUT_TEAPOT_N_PATCHES*nSubDivs*2, nSubDivs, GL_LINE_STRIP, NULL,0,0);
fghDrawGeometryWire (verts, norms, nVerts, vertIdxs, nPatches*nSubDivs*2, nSubDivs, GL_LINE_STRIP, NULL,0,0);
else
fghDrawGeometrySolid(verts,norms,texcsSolid,nVerts,vertIdxs,1,GLUT_SOLID_TEAPOT_N_TRI*3);
fghDrawGeometrySolid(verts, norms, texcs, nVerts, vertIdxs,1,nTriangles*3);
}
@ -431,8 +482,13 @@ static void fghTeapot( GLfloat scale, GLboolean useWireMode )
void FGAPIENTRY glutWireTeapot( double size )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTeapot" );
/* We will use the general teapot rendering code */
fghTeapot( (GLfloat)size, GL_TRUE );
fghTeaset( (GLfloat)size, GL_TRUE,
cpdata_teapot, patchdata_teapot,
vertIdxsTeapotW,
vertsTeapotW, normsTeapotW, NULL,
&lastScaleTeapotW, &initedTeapotW,
GL_TRUE, GL_TRUE, 1.575f,
GLUT_WIRE_TEAPOT_N_VERT, GLUT_TEAPOT_N_INPUT_PATCHES, GLUT_TEAPOT_N_PATCHES, 0);
}
/*
@ -441,13 +497,75 @@ void FGAPIENTRY glutWireTeapot( double size )
void FGAPIENTRY glutSolidTeapot( double size )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTeapot" );
/* We will use the general teapot rendering code */
fghTeapot( (GLfloat)size, GL_FALSE );
fghTeaset( (GLfloat)size, GL_FALSE,
cpdata_teapot, patchdata_teapot,
vertIdxsTeapotS,
vertsTeapotS, normsTeapotS, texcsTeapotS,
&lastScaleTeapotS, &initedTeapotS,
GL_TRUE, GL_TRUE, 1.575f,
GLUT_SOLID_TEAPOT_N_VERT, GLUT_TEAPOT_N_INPUT_PATCHES, GLUT_TEAPOT_N_PATCHES, GLUT_SOLID_TEAPOT_N_TRI);
}
/*
* Renders a wired teacup...
*/
void FGAPIENTRY glutWireTeacup( double size )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTeacup" );
fghTeaset( (GLfloat)size/2.5f, GL_TRUE,
cpdata_teacup, patchdata_teacup,
vertIdxsTeacupW,
vertsTeacupW, normsTeacupW, NULL,
&lastScaleTeacupW, &initedTeacupW,
GL_FALSE, GL_TRUE, 1.5121f,
GLUT_WIRE_TEACUP_N_VERT, GLUT_TEACUP_N_INPUT_PATCHES, GLUT_TEACUP_N_PATCHES, 0);
}
/*
* Renders a filled teacup...
*/
void FGAPIENTRY glutSolidTeacup( double size )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTeacup" );
fghTeaset( (GLfloat)size/2.5f, GL_FALSE,
cpdata_teacup, patchdata_teacup,
vertIdxsTeacupS,
vertsTeacupS, normsTeacupS, texcsTeacupS,
&lastScaleTeacupS, &initedTeacupS,
GL_FALSE, GL_TRUE, 1.5121f,
GLUT_SOLID_TEACUP_N_VERT, GLUT_TEACUP_N_INPUT_PATCHES, GLUT_TEACUP_N_PATCHES, GLUT_SOLID_TEACUP_N_TRI);
}
/*
* Renders a wired teaspoon...
*/
void FGAPIENTRY glutWireTeaspoon( double size )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTeaspoon" );
fghTeaset( (GLfloat)size/2.5f, GL_TRUE,
cpdata_teaspoon, patchdata_teaspoon,
vertIdxsTeaspoonW,
vertsTeaspoonW, normsTeaspoonW, NULL,
&lastScaleTeaspoonW, &initedTeaspoonW,
GL_FALSE, GL_FALSE, -0.0315f,
GLUT_WIRE_TEASPOON_N_VERT, GLUT_TEASPOON_N_INPUT_PATCHES, GLUT_TEASPOON_N_PATCHES, 0);
}
/*
* Renders a filled teaspoon...
*/
void FGAPIENTRY glutSolidTeaspoon( double size )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTeaspoon" );
fghTeaset( (GLfloat)size/2.5f, GL_FALSE,
cpdata_teaspoon, patchdata_teaspoon,
vertIdxsTeaspoonS,
vertsTeaspoonS, normsTeaspoonS, texcsTeaspoonS,
&lastScaleTeaspoonS, &initedTeaspoonS,
GL_FALSE, GL_FALSE, -0.0315f,
GLUT_SOLID_TEASPOON_N_VERT, GLUT_TEASPOON_N_INPUT_PATCHES, GLUT_TEASPOON_N_PATCHES, GLUT_SOLID_TEASPOON_N_TRI);
}
/*** END OF FILE ***/

File diff suppressed because it is too large Load Diff

View File

@ -117,6 +117,10 @@ EXPORTS
glutSolidSierpinskiSponge
glutWireTeapot
glutSolidTeapot
glutWireTeacup
glutSolidTeacup
glutWireTeaspoon
glutSolidTeaspoon
glutWireCylinder
glutSolidCylinder
glutGameModeString