X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=d50c93cd951ed34390a1175c8eaef7e3a745ad11;hb=a0188f0c9f746bbb5859681f14eae9654be8c04d;hp=77b09a790678529eba45d7c9afc85e7f4be1cd58;hpb=46d1878cf7d5cee323caf1c7e65f81f20fcf91eb;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index 77b09a7..d50c93c 100644 --- a/src/fg_geometry.c +++ b/src/fg_geometry.c @@ -27,175 +27,288 @@ #include #include "fg_internal.h" +#include "fg_gl2.h" +#include /* * Need more types of polyhedra? See CPolyhedron in MRPT */ -/* General function for drawing geometry. As for all geometry we have no - * redundancy (or hardly any in the case of cones and cylinders) in terms - * of the vertex/normal combinations, we just use glDrawArrays. - * useWireMode controls the drawing of solids (false) or wire frame - * versions (TRUE) of the geometry you pass +/* General functions for drawing geometry + * Solids are drawn by glDrawArrays if composed of triangles, or by + * glDrawElements if consisting of squares or pentagons that were + * decomposed into triangles (some vertices are repeated in that case). + * WireFrame drawing will have to be done per face, using GL_LINE_LOOP and + * issuing one draw call per face. Always use glDrawArrays as no triangle + * decomposition needed. We use the "first" parameter in glDrawArrays to go + * from face to face. */ -static void fghDrawGeometry(GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLsizei numFaces, GLsizei numEdgePerFace, GLboolean useWireMode) + +/* Version for OpenGL (ES) 1.1 */ +#ifndef GL_ES_VERSION_2_0 +static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace) { -# ifdef FREEGLUT_GLES1 - /* Solid drawing is the same for OpenGL 1.x and OpenGL ES 1.x, just - * no edge flags for ES. - * WireFrame drawing will have to be done per face though, using - * GL_LINE_LOOP and issuing one draw call per face. For triangles, - * we use glDrawArrays directly on the vertex data for each face, - * while for shapes that are composed of quads or pentagons, we use - * glDrawElements with index vector {0,1,2,5} or {0,1,2,8,5}, - * respectively. - * We use the first parameter in glDrawArrays or glDrawElements to - * go from face to face. - */ - if (useWireMode) - { - /* setup reading the right elements from vertex array */ - GLubyte vertIdx4[4] = {0,1,2,5}; - GLubyte vertIdx5[5] = {0,1,2,8,5}; - GLubyte *indices = NULL; - int vertStride, i, j; - - switch (numEdgePerFace) - { - case 3: - vertStride = 3; /* there are 3 vertices for each face in the array */ - break; - case 4: - indices = vertIdx4; - vertStride = 6; /* there are 6 vertices for each face in the array */ - break; - case 5: - indices = vertIdx5; - vertStride = 9; /* there are 9 vertices for each face in the array */ - break; - } + int i; + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); + glVertexPointer(3, GL_FLOAT, 0, vertices); + glNormalPointer(GL_FLOAT, 0, normals); - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); + /* Draw per face (TODO: could use glMultiDrawArrays if available) */ + for (i=0; i= 2.0 */ +static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace, + GLint attribute_v_coord, GLint attribute_v_normal) +{ + GLuint vbo_coords, vbo_normals; + GLuint numVertices = numFaces * numEdgePerFace; - glDisableClientState(GL_VERTEX_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - return; /* done */ + int i; + + if (numVertices > 0 && attribute_v_coord != -1) { + fghGenBuffers(1, &vbo_coords); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords); + fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(vertices[0]), + vertices, FGH_STATIC_DRAW); + } + + if (numVertices > 0 && attribute_v_normal != -1) { + fghGenBuffers(1, &vbo_normals); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_normals); + fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(normals[0]), + normals, FGH_STATIC_DRAW); + } + + if (vbo_coords) { + fghEnableVertexAttribArray(attribute_v_coord); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords); + fghVertexAttribPointer( + attribute_v_coord, // attribute + 3, // number of elements per vertex, here (x,y,z) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + 0, // no extra data between each position + 0 // offset of first element + ); } -# endif - if (useWireMode) - { - glPushAttrib(GL_POLYGON_BIT); - glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); - glDisable(GL_CULL_FACE); + if (vbo_normals) { + fghEnableVertexAttribArray(attribute_v_normal); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_normals); + fghVertexAttribPointer( + attribute_v_normal, // attribute + 3, // number of elements per vertex, here (x,y,z) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + 0, // no extra data between each position + 0 // offset of first element + ); } + /* Draw per face (TODO: could use glMultiDrawArrays if available) */ + for (i=0; iWindow.attribute_v_coord; + GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal; + + if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1)) + /* User requested a 2.0 draw */ + fghDrawGeometryWire20(vertices, normals, numFaces, numEdgePerFace, + attribute_v_coord, attribute_v_normal); +#ifndef GL_ES_VERSION_2_0 + else + fghDrawGeometryWire11(vertices, normals, numFaces, numEdgePerFace); +#endif +} + + +/* Draw the geometric shape with filled triangles + * + * - If the shape is naturally triangulated (numEdgePerFace==3), each + * vertex+normal pair is used only once, so no vertex indices. + * + * - If the shape was triangulated (DECOMPOSE_TO_TRIANGLE), some + * vertex+normal pairs are reused, so use vertex indices. + */ + +/* Version for OpenGL (ES) 1.1 */ +#ifndef GL_ES_VERSION_2_0 +static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, + GLsizei numVertices, GLsizei numVertIdxs) +{ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); -# ifndef FREEGLUT_GLES1 - if (edgeFlags) - glEnableClientState(GL_EDGE_FLAG_ARRAY); -# endif - - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); -# ifndef FREEGLUT_GLES1 - if (edgeFlags) - glEdgeFlagPointer(0,edgeFlags); -# endif - glDrawArrays(GL_TRIANGLES, 0, numVertices); + + glVertexPointer(3, GL_FLOAT, 0, vertices); + glNormalPointer(GL_FLOAT, 0, normals); + if (vertIdxs == NULL) + glDrawArrays(GL_TRIANGLES, 0, numVertices); + else + glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, vertIdxs); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); -# ifndef FREEGLUT_GLES1 - if (edgeFlags) - glDisableClientState(GL_EDGE_FLAG_ARRAY); -# endif +} +#endif - if (useWireMode) - { - glPopAttrib(); +/* Version for OpenGL (ES) >= 2.0 */ +static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, + GLsizei numVertices, GLsizei numVertIdxs, + GLint attribute_v_coord, GLint attribute_v_normal) +{ + GLuint vbo_coords, vbo_normals, ibo_elements; + + if (numVertices > 0 && attribute_v_coord != -1) { + fghGenBuffers(1, &vbo_coords); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords); + fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(vertices[0]), + vertices, FGH_STATIC_DRAW); + } + + if (numVertices > 0 && attribute_v_normal != -1) { + fghGenBuffers(1, &vbo_normals); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_normals); + fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(normals[0]), + normals, FGH_STATIC_DRAW); + } + + if (vertIdxs != NULL) { + fghGenBuffers(1, &ibo_elements); + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements); + fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs * sizeof(vertIdxs[0]), + vertIdxs, FGH_STATIC_DRAW); } + + if (vbo_coords) { + fghEnableVertexAttribArray(attribute_v_coord); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords); + fghVertexAttribPointer( + attribute_v_coord, // attribute + 3, // number of elements per vertex, here (x,y,z) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + 0, // no extra data between each position + 0 // offset of first element + ); + }; + + if (vbo_normals) { + fghEnableVertexAttribArray(attribute_v_normal); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_normals); + fghVertexAttribPointer( + attribute_v_normal, // attribute + 3, // number of elements per vertex, here (x,y,z) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + 0, // no extra data between each position + 0 // offset of first element + ); + }; + + if (vertIdxs == NULL) { + glDrawArrays(GL_TRIANGLES, 0, numVertices); + } else { + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements); + glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, 0); + } + + if (vbo_coords != 0) + fghDisableVertexAttribArray(attribute_v_coord); + if (vbo_normals != 0) + fghDisableVertexAttribArray(attribute_v_normal); + + if (vbo_coords != 0) + fghDeleteBuffers(1, &vbo_coords); + if (vbo_normals != 0) + fghDeleteBuffers(1, &vbo_normals); + if (ibo_elements != 0) + fghDeleteBuffers(1, &ibo_elements); +} - /* Notes on OpenGL 3 and OpenGL ES2, drawing code for programmable pipeline: - * As above, we'll have to draw face-by-face for wireframes. On - * OpenGL 3 we can probably use glMultiDrawArrays do do this efficiently. - * other complications are VBOs and such... - */ +static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, + GLsizei numVertices, GLsizei numVertIdxs) +{ + GLint attribute_v_coord = fgStructure.CurrentWindow->Window.attribute_v_coord; + GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal; + + if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1)) + /* User requested a 2.0 draw */ + fghDrawGeometrySolid20(vertices, normals, vertIdxs, + numVertices, numVertIdxs, + attribute_v_coord, attribute_v_normal); +#ifndef GL_ES_VERSION_2_0 + else + fghDrawGeometrySolid11(vertices, normals, vertIdxs, + numVertices, numVertIdxs); +#endif } -/* Triangle decomposition and associated edgeFlags generation +/* Shape decomposition to triangles + * We'll use glDrawElements to draw all shapes that are not naturally + * composed of triangles, so generate an index vector here, using the + * below sampling scheme. * Be careful to keep winding of all triangles counter-clockwise, * assuming that input has correct winding... - * Could probably do something smarter using glDrawElements and generating - * an index vector here for all shapes that are not triangles, but this - * suffices for now. We're not talking many vertices in our objects anyway. */ -static GLubyte vertSamp3[3] = {0,1,2}; -static GLubyte vertSamp4[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */ -static GLubyte vertSamp5[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */ -static GLboolean edgeFlag3[3] = {1,1,1}; /* triangles remain triangles, all edges are external */ -static GLboolean edgeFlag4[6] = {1,1,0, 0,1,1}; -static GLboolean edgeFlag5[9] = {1,1,0, 0,0,1, 0,1,1}; - -static void fghGenerateGeometryWithEdgeFlag(int numFaces, int numEdgePerFaceIn, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLboolean *edgeFlagsOut) +static GLubyte vert4Decomp[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */ +static GLubyte vert5Decomp[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */ + +static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLubyte *vertIdxOut) { - int i,j,numEdgePerFaceOut; + int i,j,numEdgeIdxPerFace; GLubyte *vertSamps = NULL; - GLboolean *edgeFlags = NULL; - switch (numEdgePerFaceIn) + switch (numEdgePerFace) { case 3: - vertSamps = vertSamp3; - edgeFlags = edgeFlag3; - numEdgePerFaceOut = 3; /* 3 output vertices for each face */ + /* nothing to do here, we'll draw with glDrawArrays */ break; case 4: - vertSamps = vertSamp4; - edgeFlags = edgeFlag4; - numEdgePerFaceOut = 6; /* 6 output vertices for each face */ + vertSamps = vert4Decomp; + numEdgeIdxPerFace = 6; /* 6 output vertices for each face */ break; case 5: - vertSamps = vertSamp5; - edgeFlags = edgeFlag5; - numEdgePerFaceOut = 9; /* 9 output vertices for each face */ + vertSamps = vert5Decomp; + numEdgeIdxPerFace = 9; /* 9 output vertices for each face */ break; } /* - * Build array with vertices from vertex coordinates and vertex indices + * Build array with vertices using vertex coordinates and vertex indices * Do same for normals. - * Need to do this because of different normals at shared vertices - * (and because normals' coordinates need to be negated). + * Need to do this because of different normals at shared vertices. */ for (i=0; i 0 ) { - GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ + double local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ unsigned int stride = ipow(4,--numLevels)*TETRAHEDRON_VERT_ELEM_PER_OBJ; scale /= 2.0 ; for ( i = 0 ; i < TETRAHEDRON_NUM_FACES ; i++ ) @@ -644,7 +759,8 @@ static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLd /* -- Now the various shapes involving circles -- */ /* - * Compute lookup table of cos and sin values forming a cirle + * Compute lookup table of cos and sin values forming a circle + * (or half circle if halfCircle==TRUE) * * Notes: * It is the responsibility of the caller to free these tables @@ -652,25 +768,21 @@ static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLd * The last entry is exactly the same as the first * The sign of n can be flipped to get the reverse loop */ -static void fghCircleTable(double **sint,double **cost,const int n) +static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GLboolean halfCircle) { int i; - + /* Table size, the sign of n flips the circle direction */ - const int size = abs(n); /* Determine the angle between samples */ - - const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n ); + const GLfloat angle = (halfCircle?1:2)*(GLfloat)M_PI/(GLfloat)( ( n == 0 ) ? 1 : n ); /* Allocate memory for n samples, plus duplicate of first entry at the end */ - - *sint = (double *) calloc(sizeof(double), size+1); - *cost = (double *) calloc(sizeof(double), size+1); + *sint = malloc(sizeof(GLfloat) * (size+1)); + *cost = malloc(sizeof(GLfloat) * (size+1)); /* Bail out if memory allocation fails, fgError never returns */ - if (!(*sint) || !(*cost)) { free(*sint); @@ -679,25 +791,112 @@ static void fghCircleTable(double **sint,double **cost,const int n) } /* Compute cos and sin around the circle */ - (*sint)[0] = 0.0; (*cost)[0] = 1.0; for (i=1; i 65535) + fgWarning("fghSphere: too many slices or stacks requested, indices will wrap"); - double z0,z1; - double r0,r1; - - /* Pre-computed circle */ + /* Generate vertices and normals */ + fghGenerateSphere((GLfloat)radius,slices,stacks,&vertices,&normals,&nVert); + + if (nVert==0) + /* nothing to draw */ + return; - double *sint1,*cost1; - double *sint2,*cost2; + if (useWireMode) + { + GLushort *sliceIdx, *stackIdx; + /* First, generate vertex index arrays for drawing with glDrawElements + * We have a bunch of line_loops to draw for each stack, and a + * bunch for each slice. + */ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" ); + sliceIdx = malloc(slices*(stacks+1)*sizeof(GLushort)); + stackIdx = malloc(slices*(stacks-1)*sizeof(GLushort)); - fghCircleTable(&sint1,&cost1,-slices); - fghCircleTable(&sint2,&cost2,stacks*2); + /* generate for each stack */ + for (i=0,idx=0; i0)?1:0]; - r0 = 0.0; - r1 = sint2[(stacks>0)?1:0]; + /* draw */ + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); - glBegin(GL_TRIANGLE_FAN); + glVertexPointer(3, GL_FLOAT, 0, vertices); + glNormalPointer(GL_FLOAT, 0, normals); + /*draw slices*/ + for (i=0; i=0; j--) + /* cleanup allocated memory */ + free(sliceIdx); + free(stackIdx); + } + else + { + /* First, generate vertex index arrays for drawing with glDrawElements + * All stacks, including top and bottom are covered with a triangle + * strip. + */ + GLushort *stripIdx; + /* Create index vector */ + GLushort offset; + + /* Allocate buffers for indices, bail out if memory allocation fails */ + stripIdx = malloc((slices+1)*2*(stacks)*sizeof(GLushort)); + if (!(stripIdx)) { - glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 ); - glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius); + free(stripIdx); + fgError("Failed to allocate memory in fghGenerateSphere"); } - glEnd(); + /* top stack */ + for (j=0, idx=0; j 0 ) ? stacks : 1 ); - const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); + const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 ); + const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 ); /* Scaling factors for vertex normals */ - const double cosn = ( height / sqrt ( height * height + base * base )); - const double sinn = ( base / sqrt ( height * height + base * base )); +#ifdef __cplusplus + const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base )); + const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base )); +#else + const GLfloat cosn = ( (GLfloat)height / (GLfloat)sqrt( (double)(height * height + base * base) )); + const GLfloat sinn = ( (GLfloat)base / (GLfloat)sqrt( (double)(height * height + base * base) )); +#endif /* __cplusplus */ /* Pre-computed circle */ - double *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Cover the circular base with a triangle fan... */ - z0 = 0.0; + z0 = 0; z1 = zStep; - r0 = base; + r0 = (GLfloat)base; r1 = r0 - rStep; glBegin(GL_TRIANGLE_FAN); - glNormal3d(0.0,0.0,-1.0); - glVertex3d(0.0,0.0, z0 ); + glNormal3f(0,0,-1); + glVertex3f(0,0, z0 ); for (j=0; j<=slices; j++) - glVertex3d(cost[j]*r0, sint[j]*r0, z0); + glVertex3f(cost[j]*r0, sint[j]*r0, z0); glEnd(); - /* Cover each stack with a quad strip, except the top stack */ - - for( i=0; i 0 ) ? stacks : 1 ); - const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); + const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 ); + const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 ); /* Scaling factors for vertex normals */ - const double cosn = ( height / sqrt ( height * height + base * base )); - const double sinn = ( base / sqrt ( height * height + base * base )); +#ifdef __cplusplus + const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base )); + const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base )); +#else + const GLfloat cosn = ( (GLfloat)height / (GLfloat)sqrt( (double)(height * height + base * base) )); + const GLfloat sinn = ( (GLfloat)base / (GLfloat)sqrt( (double)(height * height + base * base) )); +#endif /* __cplusplus */ /* Pre-computed circle */ - double *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Draw the stacks... */ @@ -1066,8 +1291,8 @@ void FGAPIENTRY glutWireCone( GLdouble base, GLdouble height, GLint slices, GLin for( j=0; j 0 ) ? stacks : 1 ); + GLfloat radf = (GLfloat)radius; + GLfloat z0,z1; + const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 ); /* Pre-computed circle */ - double *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Cover the base and top */ glBegin(GL_TRIANGLE_FAN); - glNormal3d(0.0, 0.0, -1.0 ); - glVertex3d(0.0, 0.0, 0.0 ); + glNormal3f(0, 0, -1 ); + glVertex3f(0, 0, 0 ); for (j=0; j<=slices; j++) - glVertex3d(cost[j]*radius, sint[j]*radius, 0.0); + glVertex3f(cost[j]*radf, sint[j]*radf, 0); glEnd(); glBegin(GL_TRIANGLE_FAN); - glNormal3d(0.0, 0.0, 1.0 ); - glVertex3d(0.0, 0.0, height); + glNormal3f(0, 0, 1 ); + glVertex3f(0, 0, (GLfloat)height); for (j=slices; j>=0; j--) - glVertex3d(cost[j]*radius, sint[j]*radius, height); + glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height); glEnd(); /* Do the stacks */ - z0 = 0.0; + z0 = 0; z1 = zStep; for (i=1; i<=stacks; i++) { if (i==stacks) - z1 = height; + z1 = (GLfloat)height; - glBegin(GL_QUAD_STRIP); + glBegin(GL_TRIANGLE_STRIP); for (j=0; j<=slices; j++ ) { - glNormal3d(cost[j], sint[j], 0.0 ); - glVertex3d(cost[j]*radius, sint[j]*radius, z0 ); - glVertex3d(cost[j]*radius, sint[j]*radius, z1 ); + glNormal3f(cost[j], sint[j], 0 ); + glVertex3f(cost[j]*radf, sint[j]*radf, z0 ); + glVertex3f(cost[j]*radf, sint[j]*radf, z1 ); } glEnd(); @@ -1165,36 +1390,36 @@ void FGAPIENTRY glutSolidCylinder(GLdouble radius, GLdouble height, GLint slices /* * Draws a wire cylinder */ -void FGAPIENTRY glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks) +void FGAPIENTRY glutWireCylinder(double radius, double height, GLint slices, GLint stacks) { int i,j; /* Step in z and radius as stacks are drawn. */ - - double z = 0.0; - const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); + GLfloat radf = (GLfloat)radius; + GLfloat z = 0; + const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 ); /* Pre-computed circle */ - double *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Draw the stacks... */ for (i=0; i<=stacks; i++) { if (i==stacks) - z = height; + z = (GLfloat)height; glBegin(GL_LINE_LOOP); for( j=0; j