X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=e41f01dbfdf0e6ccc52d4b4480e49ca002967d9b;hb=207c3128bf025b5e025bace5c0425d380dd72aa9;hp=3a19a3b021b223c7297766fd4c7eecd97f54fc8c;hpb=9634525a2e112501938d7cc5c48ce75f8b975a38;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index 3a19a3b..e41f01d 100644 --- a/src/fg_geometry.c +++ b/src/fg_geometry.c @@ -1,5 +1,5 @@ /* - * freeglut_geometry.c + * fg_geometry.c * * Freeglut geometry rendering methods. * @@ -27,1270 +27,2153 @@ #include #include "fg_internal.h" +#include "fg_gl2.h" +#include /* - * TODO BEFORE THE STABLE RELEASE: - * - * See fghTetrahedron - * - * Following functions have been contributed by Andreas Umbach. - * - * glutWireCube() -- looks OK - * glutSolidCube() -- OK - * - * Those functions have been implemented by John Fay. - * - * glutWireTorus() -- looks OK - * glutSolidTorus() -- looks OK - * glutWireDodecahedron() -- looks OK - * glutSolidDodecahedron() -- looks OK - * glutWireOctahedron() -- looks OK - * glutSolidOctahedron() -- looks OK - * glutWireTetrahedron() -- looks OK - * glutSolidTetrahedron() -- looks OK - * glutWireIcosahedron() -- looks OK - * glutSolidIcosahedron() -- looks OK + * A note: We do not use the GLuint data type for vertex index arrays + * in this code as Open GL ES1 only supports GLushort. This affects the + * cylindrical objects only (Torus, Sphere, Cylinder and Cone) and limits + * their number of vertices to 65535 (2^16-1). Thats about 256*256 + * subdivisions, which is sufficient for just about any usage case, so + * I am not going to worry about it for now. + * One could do compile time detection of the gluint type through CMake, + * but it is likely that we'll eventually move to runtime selection + * of OpenGL or GLES1/2, which would make that strategy useless... + */ + +/* declare for drawing using the different OpenGL versions here so we can + have a nice code order below */ +static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode, + GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2 + ); +static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart); +static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode, + GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2, + GLint attribute_v_coord, GLint attribute_v_normal + ); +static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart, + GLint attribute_v_coord, GLint attribute_v_normal, GLint attribute_v_texture); +/* declare function for generating visualization of normals */ +static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices); +static void fghDrawNormalVisualization11(); +static void fghDrawNormalVisualization20(GLint attribute_v_coord); + +/* Drawing geometry: + * Explanation of the functions has to be separate for the polyhedra and + * the non-polyhedra (objects with a circular cross-section). + * Polyhedra: + * - We have only implemented the five platonic solids and the rhomboid + * dodecahedron. If you need more types of polyhedra, please see + * CPolyhedron in MRPT + * - Solids are drawn by glDrawArrays if composed of triangular faces + * (the tetrahedron, octahedron, and icosahedron), or are first + * decomposed into triangles and then drawn by glDrawElements if its + * faces are squares or pentagons (cube, dodecahedron and rhombic + * dodecahedron) as some vertices are repeated in that case. + * - WireFrame drawing is done using a GL_LINE_LOOP per face, and thus + * issuing one draw call per face. glDrawArrays is always used as no + * triangle decomposition is needed to draw faces. We use the "first" + * parameter in glDrawArrays to go from face to face. + * + * Non-polyhedra: + * - We have implemented the sphere, cylinder, cone and torus. + * - All shapes are characterized by two parameters: the number of + * subdivisions along two axes used to construct the shape's vertices + * (e.g. stacks and slices for the sphere). + * As different subdivisions are most suitable for different shapes, + * and are thus also named differently, I wont provide general comments + * on them here. + * - Solids are drawn using glDrawArrays and GL_TRIANGLE_STRIP. Each + * strip covers one revolution around one of the two subdivision axes + * of the shape. + * - WireFrame drawing is done for the subdivisions along the two axes + * separately, usually using GL_LINE_LOOP. Vertex index arrays are + * built containing the vertices to be drawn for each loop, which are + * then drawn using multiple calls to glDrawElements. As the number of + * subdivisions along the two axes is not guaranteed to be equal, the + * vertex indices for e.g. stacks and slices are stored in separate + * arrays, which makes the input to the drawing function a bit clunky, + * but allows for the same drawing function to be used for all shapes. + */ + + +/** + * Draw geometric shape in wire mode (only edges) * - * The Following functions have been updated by Nigel Stewart, based - * on FreeGLUT 2.0.0 implementations: + * Arguments: + * GLfloat *vertices, GLfloat *normals, GLsizei numVertices + * The vertex coordinate and normal buffers, and the number of entries in + * those + * GLushort *vertIdxs + * a vertex indices buffer, optional (never passed for the polyhedra) + * GLsizei numParts, GLsizei numVertPerPart + * polyhedra: number of faces, and the number of vertices for drawing + * each face + * non-polyhedra: number of edges to draw for first subdivision (not + * necessarily equal to number of subdivisions requested by user, e.g. + * as each subdivision is enclosed by two edges), and number of + * vertices for drawing each + * numParts * numVertPerPart gives the number of entries in the vertex + * array vertIdxs + * GLenum vertexMode + * vertex drawing mode (e.g. always GL_LINE_LOOP for polyhedra, varies + * for others) + * GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2 + * non-polyhedra only: same as the above, but now for subdivisions along + * the other axis. Always drawn as GL_LINE_LOOP. * - * glutWireSphere() -- looks OK - * glutSolidSphere() -- looks OK - * glutWireCone() -- looks OK - * glutSolidCone() -- looks OK + * Feel free to contribute better naming ;) */ +void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode, + GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2 + ) +{ + 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 */ + fghDrawGeometryWire20(vertices, normals, numVertices, + vertIdxs, numParts, numVertPerPart, vertexMode, + vertIdxs2, numParts2, numVertPerPart2, + attribute_v_coord, attribute_v_normal); + else + fghDrawGeometryWire11(vertices, normals, + vertIdxs, numParts, numVertPerPart, vertexMode, + vertIdxs2, numParts2, numVertPerPart2); +} - -/* - * 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 +/* Draw the geometric shape with filled triangles + * + * Arguments: + * GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices + * The vertex coordinate, normal and texture coordinate buffers, and the + * number of entries in those + * GLushort *vertIdxs + * a vertex indices buffer, optional (not passed for the polyhedra with + * triangular faces) + * GLsizei numParts, GLsizei numVertPerPart + * polyhedra: not used for polyhedra with triangular faces + (numEdgePerFace==3), as each vertex+normal pair is drawn only once, + so no vertex indices are used. + Else, the shape was triangulated (DECOMPOSE_TO_TRIANGLE), leading to + reuse of some vertex+normal pairs, and thus the need to draw with + glDrawElements. numParts is always 1 in this case (we can draw the + whole object with one call to glDrawElements as the vertex index + array contains separate triangles), and numVertPerPart indicates + the number of vertex indices in the vertex array. + * non-polyhedra: number of parts (GL_TRIANGLE_STRIPs) to be drawn + separately (numParts calls to glDrawElements) to create the object. + numVertPerPart indicates the number of vertex indices to be + processed at each draw call. + * numParts * numVertPerPart gives the number of entries in the vertex + * array vertIdxs */ -static void fghDrawGeometry(GLenum vertexMode, double* vertices, double* normals, GLsizei numVertices, GLboolean useWireMode) +void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart) { - if (useWireMode) + GLint attribute_v_coord = fgStructure.CurrentWindow->Window.attribute_v_coord; + GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal; + GLint attribute_v_texture = fgStructure.CurrentWindow->Window.attribute_v_texture; + + if (fgStructure.CurrentWindow->State.VisualizeNormals) + /* generate normals for each vertex to be drawn as well */ + fghGenerateNormalVisualization(vertices, normals, numVertices); + + if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1)) { - glPushAttrib(GL_POLYGON_BIT); - glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + /* User requested a 2.0 draw */ + fghDrawGeometrySolid20(vertices, normals, textcs, numVertices, + vertIdxs, numParts, numVertIdxsPerPart, + attribute_v_coord, attribute_v_normal, attribute_v_texture); + + if (fgStructure.CurrentWindow->State.VisualizeNormals) + /* draw normals for each vertex as well */ + fghDrawNormalVisualization20(attribute_v_coord); } + else + { + fghDrawGeometrySolid11(vertices, normals, textcs, numVertices, + vertIdxs, numParts, numVertIdxsPerPart); + if (fgStructure.CurrentWindow->State.VisualizeNormals) + /* draw normals for each vertex as well */ + fghDrawNormalVisualization11(); + } +} + + + +/* Version for OpenGL (ES) 1.1 */ +static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode, + GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2 + ) +{ + int i; + glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); - glDrawArrays(vertexMode,0,numVertices); + glVertexPointer(3, GL_FLOAT, 0, vertices); + glNormalPointer(GL_FLOAT, 0, normals); + + + if (!vertIdxs) + /* Draw per face (TODO: could use glMultiDrawArrays if available) */ + for (i=0; i1) + for (i=0; i= 2.0 */ +static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode, + GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2, + GLint attribute_v_coord, GLint attribute_v_normal) { + GLuint vbo_coords = 0, vbo_normals = 0, + ibo_elements = 0, ibo_elements2 = 0; + GLsizei numVertIdxs = numParts * numVertPerPart; + GLsizei numVertIdxs2 = numParts2 * numVertPerPart2; int i; - /* Table size, the sign of n flips the circle direction */ - - const int size = abs(n); - - /* Determine the angle between samples */ + 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); + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0); + } - const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n ); + if (vertIdxs2 != NULL) { + fghGenBuffers(1, &ibo_elements2); + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements2); + fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs2 * sizeof(vertIdxs2[0]), + vertIdxs2, FGH_STATIC_DRAW); + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0); + } - /* Allocate memory for n samples, plus duplicate of first entry at the end */ + 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 */ + ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + } - *sint = (double *) calloc(sizeof(double), size+1); - *cost = (double *) calloc(sizeof(double), size+1); + 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 */ + ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + } - /* Bail out if memory allocation fails, fgError never returns */ + if (!vertIdxs) { + /* Draw per face (TODO: could use glMultiDrawArrays if available) */ + for (i=0; i= 2.0 */ +static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart, + GLint attribute_v_coord, GLint attribute_v_normal, GLint attribute_v_texture) +{ + GLuint vbo_coords = 0, vbo_normals = 0, vbo_textcs = 0, ibo_elements = 0; + GLsizei numVertIdxs = numParts * numVertIdxsPerPart; + 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); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + } + + 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); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + } - (*sint)[size] = (*sint)[0]; - (*cost)[size] = (*cost)[0]; + if (numVertices > 0 && attribute_v_texture != -1 && textcs) { + fghGenBuffers(1, &vbo_textcs); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_textcs); + fghBufferData(FGH_ARRAY_BUFFER, numVertices * 2 * sizeof(textcs[0]), + textcs, FGH_STATIC_DRAW); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + } + + 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); + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0); + } + + 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 */ + ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + }; + + 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 */ + ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + }; + + if (vbo_textcs) { + fghEnableVertexAttribArray(attribute_v_texture); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_textcs); + fghVertexAttribPointer( + attribute_v_texture,/* attribute */ + 2, /* number of elements per vertex, here (s,t) */ + 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 */ + ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + }; + + if (vertIdxs == NULL) { + glDrawArrays(GL_TRIANGLES, 0, numVertices); + } else { + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements); + if (numParts>1) { + for (i=0; i - */ -void FGAPIENTRY glutWireCube( GLdouble dSize ) +/* Version for OpenGL (ES) 1.1 */ +static void fghDrawNormalVisualization11() { - double size = dSize * 0.5; + GLfloat currentColor[4]; + /* Setup draw color: (1,1,1)-shape's color */ + glGetFloatv(GL_CURRENT_COLOR,currentColor); + glColor4f(1-currentColor[0],1-currentColor[1],1-currentColor[2],currentColor[3]); - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" ); + glEnableClientState(GL_VERTEX_ARRAY); -# define V(a,b,c) glVertex3d( a size, b size, c size ); -# define N(a,b,c) glNormal3d( a, b, c ); + glVertexPointer(3, GL_FLOAT, 0, verticesForNormalVisualization); + glDrawArrays(GL_LINES, 0, numNormalVertices); - /* PWO: I dared to convert the code to use macros... */ - glBegin( GL_LINE_LOOP ); N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); glEnd(); - glBegin( GL_LINE_LOOP ); N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); glEnd(); - glBegin( GL_LINE_LOOP ); N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); glEnd(); - glBegin( GL_LINE_LOOP ); N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); glEnd(); - glBegin( GL_LINE_LOOP ); N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); glEnd(); - glBegin( GL_LINE_LOOP ); N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); glEnd(); + glDisableClientState(GL_VERTEX_ARRAY); -# undef V -# undef N + /* Done, free memory, reset color */ + free(verticesForNormalVisualization); + glColor4f(currentColor[0],currentColor[1],currentColor[2],currentColor[3]); } -/* - * Draws a solid cube. Code contributed by Andreas Umbach - */ -void FGAPIENTRY glutSolidCube( GLdouble dSize ) +/* Version for OpenGL (ES) >= 2.0 */ +static void fghDrawNormalVisualization20(GLint attribute_v_coord) { - double size = dSize * 0.5; + GLuint vbo_coords = 0; - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" ); + if (attribute_v_coord != -1) { + fghGenBuffers(1, &vbo_coords); + fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords); + fghBufferData(FGH_ARRAY_BUFFER, numNormalVertices * 3 * sizeof(verticesForNormalVisualization[0]), + verticesForNormalVisualization, FGH_STATIC_DRAW); + } -# define V(a,b,c) glVertex3d( a size, b size, c size ); -# define N(a,b,c) glNormal3d( a, b, c ); - - /* PWO: Again, I dared to convert the code to use macros... */ - glBegin( GL_QUADS ); - N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); - N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); - N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); - N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); - N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); - N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); - glEnd(); - -# undef V -# undef N -} + 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 */ + ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + } -/* - * Draws a solid sphere + glDrawArrays(GL_LINES, 0, numNormalVertices); + + if (vbo_coords != 0) + fghDisableVertexAttribArray(attribute_v_coord); + + if (vbo_coords != 0) + fghDeleteBuffers(1, &vbo_coords); + + /* Done, free memory */ + free(verticesForNormalVisualization); +} + +/** + * Generate all combinations of vertices and normals needed to draw object. + * Optional 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... */ -void FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks) +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, GLushort *vertIdxOut) { - int i,j; + int i,j,numEdgeIdxPerFace; + GLubyte *vertSamps = NULL; + switch (numEdgePerFace) + { + case 3: + /* nothing to do here, we'll draw with glDrawArrays */ + break; + case 4: + vertSamps = vert4Decomp; + numEdgeIdxPerFace = 6; /* 6 output vertices for each face */ + break; + case 5: + vertSamps = vert5Decomp; + numEdgeIdxPerFace = 9; /* 9 output vertices for each face */ + break; + } + /* + * 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. + */ + for (i=0; i0)?1:0]; - r0 = 0.0; - r1 = sint2[(stacks>0)?1:0]; +/* Vertex indices, as quads, before triangulation */ +static GLubyte cube_vi[CUBE_VERT_PER_OBJ] = +{ + 0,1,2,3, + 0,3,4,5, + 0,5,6,1, + 1,6,7,2, + 7,4,3,2, + 4,7,6,5 +}; +DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE) + +/* -- Dodecahedron -- */ +/* Magic Numbers: It is possible to create a dodecahedron by attaching two + * pentagons to each face of of a cube. The coordinates of the points are: + * (+-x,0, z); (+-1, 1, 1); (0, z, x ) + * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or + * x = 0.61803398875 and z = 1.61803398875. + */ +#define DODECAHEDRON_NUM_VERT 20 +#define DODECAHEDRON_NUM_FACES 12 +#define DODECAHEDRON_NUM_EDGE_PER_FACE 5 +#define DODECAHEDRON_VERT_PER_OBJ (DODECAHEDRON_NUM_FACES*DODECAHEDRON_NUM_EDGE_PER_FACE) +#define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ*3) +#define DODECAHEDRON_VERT_PER_OBJ_TRI (DODECAHEDRON_VERT_PER_OBJ+DODECAHEDRON_NUM_FACES*4) /* 4 extra edges per face when drawing pentagons as triangles */ +/* Vertex Coordinates */ +static GLfloat dodecahedron_v[DODECAHEDRON_NUM_VERT*3] = +{ + 0.0f, 1.61803398875f, 0.61803398875f, + - 1.0f, 1.0f, 1.0f, + -0.61803398875f, 0.0f, 1.61803398875f, + 0.61803398875f, 0.0f, 1.61803398875f, + 1.0f, 1.0f, 1.0f, + 0.0f, 1.61803398875f, -0.61803398875f, + 1.0f, 1.0f, - 1.0f, + 0.61803398875f, 0.0f, -1.61803398875f, + -0.61803398875f, 0.0f, -1.61803398875f, + - 1.0f, 1.0f, - 1.0f, + 0.0f, -1.61803398875f, 0.61803398875f, + 1.0f, - 1.0f, 1.0f, + - 1.0f, - 1.0f, 1.0f, + 0.0f, -1.61803398875f, -0.61803398875f, + - 1.0f, - 1.0f, - 1.0f, + 1.0f, - 1.0f, - 1.0f, + 1.61803398875f, -0.61803398875f, 0.0f, + 1.61803398875f, 0.61803398875f, 0.0f, + -1.61803398875f, 0.61803398875f, 0.0f, + -1.61803398875f, -0.61803398875f, 0.0f +}; +/* Normal Vectors */ +static GLfloat dodecahedron_n[DODECAHEDRON_NUM_FACES*3] = +{ + 0.0f, 0.525731112119f, 0.850650808354f, + 0.0f, 0.525731112119f, -0.850650808354f, + 0.0f, -0.525731112119f, 0.850650808354f, + 0.0f, -0.525731112119f, -0.850650808354f, + + 0.850650808354f, 0.0f, 0.525731112119f, + -0.850650808354f, 0.0f, 0.525731112119f, + 0.850650808354f, 0.0f, -0.525731112119f, + -0.850650808354f, 0.0f, -0.525731112119f, + + 0.525731112119f, 0.850650808354f, 0.0f, + 0.525731112119f, -0.850650808354f, 0.0f, + -0.525731112119f, 0.850650808354f, 0.0f, + -0.525731112119f, -0.850650808354f, 0.0f, +}; - glBegin(GL_TRIANGLE_FAN); +/* Vertex indices */ +static GLubyte dodecahedron_vi[DODECAHEDRON_VERT_PER_OBJ] = +{ + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 10, 11, 3, 2, 12, + 13, 14, 8, 7, 15, + + 3, 11, 16, 17, 4, + 2, 1, 18, 19, 12, + 7, 6, 17, 16, 15, + 8, 14, 19, 18, 9, + + 17, 6, 5, 0, 4, + 16, 11, 10, 13, 15, + 18, 1, 0, 5, 9, + 19, 14, 13, 10, 12 +}; +DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON) - glNormal3d(0,0,1); - glVertex3d(0,0,radius); - for (j=slices; j>=0; j--) - { - glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 ); - glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius); - } +/* -- Icosahedron -- */ +#define ICOSAHEDRON_NUM_VERT 12 +#define ICOSAHEDRON_NUM_FACES 20 +#define ICOSAHEDRON_NUM_EDGE_PER_FACE 3 +#define ICOSAHEDRON_VERT_PER_OBJ (ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE) +#define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ*3) +#define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ +/* Vertex Coordinates */ +static GLfloat icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = +{ + 1.0f, 0.0f, 0.0f, + 0.447213595500f, 0.894427191000f, 0.0f, + 0.447213595500f, 0.276393202252f, 0.850650808354f, + 0.447213595500f, -0.723606797748f, 0.525731112119f, + 0.447213595500f, -0.723606797748f, -0.525731112119f, + 0.447213595500f, 0.276393202252f, -0.850650808354f, + -0.447213595500f, -0.894427191000f, 0.0f, + -0.447213595500f, -0.276393202252f, 0.850650808354f, + -0.447213595500f, 0.723606797748f, 0.525731112119f, + -0.447213595500f, 0.723606797748f, -0.525731112119f, + -0.447213595500f, -0.276393202252f, -0.850650808354f, + - 1.0f, 0.0f, 0.0f +}; +/* Normal Vectors: + * icosahedron_n[i][0] = ( icosahedron_v[icosahedron_vi[i][1]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) * ( icosahedron_v[icosahedron_vi[i][2]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) - ( icosahedron_v[icosahedron_vi[i][1]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) * ( icosahedron_v[icosahedron_vi[i][2]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) ; + * icosahedron_n[i][1] = ( icosahedron_v[icosahedron_vi[i][1]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) * ( icosahedron_v[icosahedron_vi[i][2]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) - ( icosahedron_v[icosahedron_vi[i][1]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) * ( icosahedron_v[icosahedron_vi[i][2]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) ; + * icosahedron_n[i][2] = ( icosahedron_v[icosahedron_vi[i][1]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) * ( icosahedron_v[icosahedron_vi[i][2]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) - ( icosahedron_v[icosahedron_vi[i][1]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) * ( icosahedron_v[icosahedron_vi[i][2]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) ; +*/ +static GLfloat icosahedron_n[ICOSAHEDRON_NUM_FACES*3] = +{ + 0.760845213037948f, 0.470228201835026f, 0.341640786498800f, + 0.760845213036861f, -0.179611190632978f, 0.552786404500000f, + 0.760845213033849f, -0.581234022404097f, 0.0f, + 0.760845213036861f, -0.179611190632978f, -0.552786404500000f, + 0.760845213037948f, 0.470228201835026f, -0.341640786498800f, + 0.179611190628666f, 0.760845213037948f, 0.552786404498399f, + 0.179611190634277f, -0.290617011204044f, 0.894427191000000f, + 0.179611190633958f, -0.940456403667806f, 0.0f, + 0.179611190634278f, -0.290617011204044f, -0.894427191000000f, + 0.179611190628666f, 0.760845213037948f, -0.552786404498399f, + -0.179611190633958f, 0.940456403667806f, 0.0f, + -0.179611190634277f, 0.290617011204044f, 0.894427191000000f, + -0.179611190628666f, -0.760845213037948f, 0.552786404498399f, + -0.179611190628666f, -0.760845213037948f, -0.552786404498399f, + -0.179611190634277f, 0.290617011204044f, -0.894427191000000f, + -0.760845213036861f, 0.179611190632978f, -0.552786404500000f, + -0.760845213033849f, 0.581234022404097f, 0.0f, + -0.760845213036861f, 0.179611190632978f, 0.552786404500000f, + -0.760845213037948f, -0.470228201835026f, 0.341640786498800f, + -0.760845213037948f, -0.470228201835026f, -0.341640786498800f, +}; - glEnd(); +/* Vertex indices */ +static GLubyte icosahedron_vi[ICOSAHEDRON_VERT_PER_OBJ] = +{ + 0, 1, 2 , + 0, 2, 3 , + 0, 3, 4 , + 0, 4, 5 , + 0, 5, 1 , + 1, 8, 2 , + 2, 7, 3 , + 3, 6, 4 , + 4, 10, 5 , + 5, 9, 1 , + 1, 9, 8 , + 2, 8, 7 , + 3, 7, 6 , + 4, 6, 10 , + 5, 10, 9 , + 11, 9, 10 , + 11, 8, 9 , + 11, 7, 8 , + 11, 6, 7 , + 11, 10, 6 +}; +DECLARE_SHAPE_CACHE(icosahedron,Icosahedron,ICOSAHEDRON) - /* Cover each stack with a quad strip, except the top and bottom stacks */ +/* -- Octahedron -- */ +#define OCTAHEDRON_NUM_VERT 6 +#define OCTAHEDRON_NUM_FACES 8 +#define OCTAHEDRON_NUM_EDGE_PER_FACE 3 +#define OCTAHEDRON_VERT_PER_OBJ (OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE) +#define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ*3) +#define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ - for( i=1; i 0 ) + { + 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++ ) + { + int idx = i*3; + local_offset[0] = offset[0] + scale * tetrahedron_v[idx ]; + local_offset[1] = offset[1] + scale * tetrahedron_v[idx+1]; + local_offset[2] = offset[2] + scale * tetrahedron_v[idx+2]; + fghSierpinskiSpongeGenerate ( numLevels, local_offset, scale, vertices+i*stride, normals+i*stride ); + } + } } +/* -- Now the various non-polyhedra (shapes involving circles) -- */ /* - * Draws a wire sphere + * 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 + * The size of the table is (n+1) to form a connected loop + * The last entry is exactly the same as the first + * The sign of n can be flipped to get the reverse loop */ -void FGAPIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks) +static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GLboolean halfCircle) { - int i,j; - - /* Adjust z and radius as stacks and slices are drawn. */ - - double r; - double x,y,z; - - /* Pre-computed circle */ + int i; + + /* Table size, the sign of n flips the circle direction */ + const int size = abs(n); - double *sint1,*cost1; - double *sint2,*cost2; + /* Determine the angle between samples */ + const GLfloat angle = (halfCircle?1:2)*(GLfloat)M_PI/(GLfloat)( ( n == 0 ) ? 1 : n ); - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" ); + /* Allocate memory for n samples, plus duplicate of first entry at the end */ + *sint = malloc(sizeof(GLfloat) * (size+1)); + *cost = malloc(sizeof(GLfloat) * (size+1)); - fghCircleTable(&sint1,&cost1,-slices ); - fghCircleTable(&sint2,&cost2, stacks*2); + /* Bail out if memory allocation fails, fgError never returns */ + if (!(*sint) || !(*cost)) + { + free(*sint); + free(*cost); + fgError("Failed to allocate memory in fghCircleTable"); + } - /* Draw a line loop for each stack */ + /* Compute cos and sin around the circle */ + (*sint)[0] = 0.0; + (*cost)[0] = 1.0; - for (i=1; i 65535) + /* + * limit of glushort, thats 256*256 subdivisions, should be enough in practice. See note above + */ + fgWarning("fghGenerateSphere: too many slices or stacks requested, indices will wrap"); + + /* precompute values on unit circle */ + fghCircleTable(&sint1,&cost1,-slices,GL_FALSE); + fghCircleTable(&sint2,&cost2, stacks,GL_TRUE); + + /* Allocate vertex and normal buffers, bail out if memory allocation fails */ + *vertices = malloc((*nVert)*3*sizeof(GLfloat)); + *normals = malloc((*nVert)*3*sizeof(GLfloat)); + if (!(*vertices) || !(*normals)) { - glBegin(GL_LINE_STRIP); - - for(j=0; j<=stacks; j++) - { - x = cost1[i]*sint2[j]; - y = sint1[i]*sint2[j]; - z = cost2[j]; - - glNormal3d(x,y,z); - glVertex3d(x*radius,y*radius,z*radius); - } + free(*vertices); + free(*normals); + fgError("Failed to allocate memory in fghGenerateSphere"); + } - glEnd(); + /* top */ + (*vertices)[0] = 0.f; + (*vertices)[1] = 0.f; + (*vertices)[2] = radius; + (*normals )[0] = 0.f; + (*normals )[1] = 0.f; + (*normals )[2] = 1.f; + idx = 3; + + /* each stack */ + for( i=1; i 0 ) ? stacks : 1 ); - const double rStep = 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 )); + int idx = 0; /* idx into vertex/normal buffer */ /* Pre-computed circle */ + GLfloat *sint,*cost; - double *sint,*cost; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" ); - - fghCircleTable(&sint,&cost,-slices); - - /* Cover the circular base with a triangle fan... */ - - z0 = 0.0; - z1 = zStep; - - r0 = base; - r1 = r0 - rStep; - - glBegin(GL_TRIANGLE_FAN); + /* Step in z and radius as stacks are drawn. */ + GLfloat z = 0; + GLfloat r = (GLfloat)base; - glNormal3d(0.0,0.0,-1.0); - glVertex3d(0.0,0.0, z0 ); + const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 ); + const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 ); - for (j=0; j<=slices; j++) - glVertex3d(cost[j]*r0, sint[j]*r0, z0); + /* Scaling factors for vertex normals */ + const GLfloat cosn = (GLfloat) (height / sqrt( height * height + base * base )); + const GLfloat sinn = (GLfloat) (base / sqrt( height * height + base * base )); - glEnd(); - /* Cover each stack with a quad strip, except the top stack */ - for( i=0; i 65535) + /* + * limit of glushort, thats 256*256 subdivisions, should be enough in practice. See note above + */ + fgWarning("fghGenerateCone: too many slices or stacks requested, indices will wrap"); - z0 = z1; z1 += zStep; - r0 = r1; r1 -= rStep; + /* Pre-computed circle */ + fghCircleTable(&sint,&cost,-slices,GL_FALSE); - glEnd(); + /* Allocate vertex and normal buffers, bail out if memory allocation fails */ + *vertices = malloc((*nVert)*3*sizeof(GLfloat)); + *normals = malloc((*nVert)*3*sizeof(GLfloat)); + if (!(*vertices) || !(*normals)) + { + free(*vertices); + free(*normals); + fgError("Failed to allocate memory in fghGenerateCone"); } - /* The top stack is covered with individual triangles */ - - glBegin(GL_TRIANGLES); - - glNormal3d(cost[0]*sinn, sint[0]*sinn, cosn); + /* bottom */ + (*vertices)[0] = 0.f; + (*vertices)[1] = 0.f; + (*vertices)[2] = z; + (*normals )[0] = 0.f; + (*normals )[1] = 0.f; + (*normals )[2] = -1.f; + idx = 3; + /* other on bottom (get normals right) */ + for (j=0; j 0 ) ? stacks : 1 ); - const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); - const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); + /* Pre-computed circle */ + GLfloat *sint,*cost; - /* Scaling factors for vertex normals */ + /* number of unique vertices */ + if (slices==0 || stacks<1) + { + /* nothing to generate */ + *nVert = 0; + return; + } + *nVert = slices*(stacks+3)+2; /* need two extra stacks for closing off top and bottom with correct normals */ - const double cosn = ( height / sqrt ( height * height + base * base )); - const double sinn = ( base / sqrt ( height * height + base * base )); + if ((*nVert) > 65535) + /* + * limit of glushort, thats 256*256 subdivisions, should be enough in practice. See note above + */ + fgWarning("fghGenerateCylinder: too many slices or stacks requested, indices will wrap"); /* Pre-computed circle */ + fghCircleTable(&sint,&cost,-slices,GL_FALSE); - double *sint,*cost; + /* Allocate vertex and normal buffers, bail out if memory allocation fails */ + *vertices = malloc((*nVert)*3*sizeof(GLfloat)); + *normals = malloc((*nVert)*3*sizeof(GLfloat)); + if (!(*vertices) || !(*normals)) + { + free(*vertices); + free(*normals); + fgError("Failed to allocate memory in fghGenerateCylinder"); + } - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" ); + z=0; + /* top on Z-axis */ + (*vertices)[0] = 0.f; + (*vertices)[1] = 0.f; + (*vertices)[2] = 0.f; + (*normals )[0] = 0.f; + (*normals )[1] = 0.f; + (*normals )[2] = -1.f; + idx = 3; + /* other on top (get normals right) */ + for (j=0; j 65535) + /* + * limit of glushort, thats 256*256 subdivisions, should be enough in practice. See note above + */ + fgWarning("fghGenerateTorus: too many slices or stacks requested, indices will wrap"); + + /* precompute values on unit circle */ + fghCircleTable(&spsi,&cpsi, nRings,GL_FALSE); + fghCircleTable(&sphi,&cphi,-nSides,GL_FALSE); + + /* Allocate vertex and normal buffers, bail out if memory allocation fails */ + *vertices = malloc((*nVert)*3*sizeof(GLfloat)); + *normals = malloc((*nVert)*3*sizeof(GLfloat)); + if (!(*vertices) || !(*normals)) + { + free(*vertices); + free(*normals); + fgError("Failed to allocate memory in fghGenerateTorus"); + } - for (j=0; j 0 ) ? stacks : 1 ); + if (dSize!=1.f) + { + /* Need to build new vertex list containing vertices for cube of different size */ + int i; - /* Pre-computed circle */ + vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLfloat)); - double *sint,*cost; + /* Bail out if memory allocation fails, fgError never returns */ + if (!vertices) + { + free(vertices); + fgError("Failed to allocate memory in fghCube"); + } - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" ); + for (i=0; i=0; j--) - glVertex3d(cost[j]*radius, sint[j]*radius, height); - glEnd(); - /* Do the stacks */ +static void fghSphere( GLfloat radius, GLint slices, GLint stacks, GLboolean useWireMode ) +{ + int i,j,idx, nVert; + GLfloat *vertices, *normals; - z0 = 0.0; - z1 = zStep; + /* Generate vertices and normals */ + fghGenerateSphere(radius,slices,stacks,&vertices,&normals,&nVert); + + if (nVert==0) + /* nothing to draw */ + return; - for (i=1; i<=stacks; i++) + if (useWireMode) { - if (i==stacks) - z1 = height; + 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. + */ + + sliceIdx = malloc(slices*(stacks+1)*sizeof(GLushort)); + stackIdx = malloc(slices*(stacks-1)*sizeof(GLushort)); + if (!(stackIdx) || !(sliceIdx)) + { + free(stackIdx); + free(sliceIdx); + fgError("Failed to allocate memory in fghSphere"); + } - glBegin(GL_QUAD_STRIP); - for (j=0; j<=slices; j++ ) + /* generate for each stack */ + for (i=0,idx=0; i 0 ) ? stacks : 1 ); - /* Pre-computed circle */ + /* draw */ + fghDrawGeometrySolid(vertices,normals,NULL,nVert,stripIdx,stacks,(slices+1)*2); - double *sint,*cost; + /* cleanup allocated memory */ + free(stripIdx); + } + + /* cleanup allocated memory */ + free(vertices); + free(normals); +} - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" ); +static void fghCone( GLfloat base, GLfloat height, GLint slices, GLint stacks, GLboolean useWireMode ) +{ + int i,j,idx, nVert; + GLfloat *vertices, *normals; - fghCircleTable(&sint,&cost,-slices); + /* Generate vertices and normals */ + /* Note, (stacks+1)*slices vertices for side of object, slices+1 for top and bottom closures */ + fghGenerateCone(base,height,slices,stacks,&vertices,&normals,&nVert); - /* Draw the stacks... */ + if (nVert==0) + /* nothing to draw */ + return; - for (i=0; i<=stacks; i++) + if (useWireMode) { - if (i==stacks) - z = height; - - glBegin(GL_LINE_LOOP); + 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. + */ + + stackIdx = malloc(slices*stacks*sizeof(GLushort)); + sliceIdx = malloc(slices*2 *sizeof(GLushort)); + if (!(stackIdx) || !(sliceIdx)) + { + free(stackIdx); + free(sliceIdx); + fgError("Failed to allocate memory in fghCone"); + } - for( j=0; j 0 ) - { - GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ - num_levels -- ; - scale /= 2.0 ; - for ( i = 0 ; i < TETR_NUM_FACES ; i++ ) - { - local_offset[0] = offset[0] + scale * tet_r[i][0] ; - local_offset[1] = offset[1] + scale * tet_r[i][1] ; - local_offset[2] = offset[2] + scale * tet_r[i][2] ; - glutWireSierpinskiSponge ( num_levels, local_offset, scale ) ; +/* -- INTERFACE FUNCTIONS -------------------------------------------------- */ +/* Macro to generate interface functions */ +#define DECLARE_SHAPE_INTERFACE(nameICaps)\ + void FGAPIENTRY glutWire##nameICaps( void )\ + {\ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWire"#nameICaps );\ + fgh##nameICaps( GL_TRUE );\ + }\ + void FGAPIENTRY glutSolid##nameICaps( void )\ + {\ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolid"#nameICaps );\ + fgh##nameICaps( GL_FALSE );\ } - } -} -void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale ) +void FGAPIENTRY glutWireCube( double dSize ) { - int i, j ; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" ); - - if ( num_levels == 0 ) - { - glBegin ( GL_TRIANGLES ) ; - - for ( i = 0 ; i < TETR_NUM_FACES ; i++ ) - { - glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ; - for ( j = 0; j < 3; j++ ) - { - double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ; - double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ; - double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ; - glVertex3d ( x, y, z ) ; - } - } - - glEnd () ; - } - else if ( num_levels > 0 ) - { - GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ - num_levels -- ; - scale /= 2.0 ; - for ( i = 0 ; i < TETR_NUM_FACES ; i++ ) - { - local_offset[0] = offset[0] + scale * tet_r[i][0] ; - local_offset[1] = offset[1] + scale * tet_r[i][1] ; - local_offset[2] = offset[2] + scale * tet_r[i][2] ; - glutSolidSierpinskiSponge ( num_levels, local_offset, scale ) ; - } - } + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" ); + fghCube( (GLfloat)dSize, GL_TRUE ); +} +void FGAPIENTRY glutSolidCube( double dSize ) +{ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" ); + fghCube( (GLfloat)dSize, GL_FALSE ); } +DECLARE_SHAPE_INTERFACE(Dodecahedron) +DECLARE_SHAPE_INTERFACE(Icosahedron) +DECLARE_SHAPE_INTERFACE(Octahedron) +DECLARE_SHAPE_INTERFACE(RhombicDodecahedron) - -/* -- INTERFACE FUNCTIONS -------------------------------------------------- */ - - -void FGAPIENTRY glutWireTetrahedron( void ) +void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, double offset[3], double scale ) { - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" ); - - fghTetrahedron( TRUE ); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" ); + fghSierpinskiSponge ( num_levels, offset, (GLfloat)scale, GL_TRUE ); } -void FGAPIENTRY glutSolidTetrahedron( void ) +void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, double offset[3], double scale ) { - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" ); - - fghTetrahedron( FALSE ); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" ); + fghSierpinskiSponge ( num_levels, offset, (GLfloat)scale, GL_FALSE ); } +DECLARE_SHAPE_INTERFACE(Tetrahedron) + /*** END OF FILE ***/