X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=e41f01dbfdf0e6ccc52d4b4480e49ca002967d9b;hb=2c12c9eb8d63cabac2d4113b4f54fdf53da8368c;hp=fd799811dde329055e0c4aac1657ae6817769e4c;hpb=b7d69172fb2d822b3392600126be8ce8ac5ce027;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index fd79981..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. * @@ -31,23 +31,190 @@ #include /* - * Need more types of polyhedra? See CPolyhedron in MRPT + * 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) + * + * 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. + * + * 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 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. +/* 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 */ +void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart) +{ + 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)) + { + /* 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 */ -#ifndef GL_ES_VERSION_2_0 -static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace) +static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, + GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode, + GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2 + ) { int i; @@ -57,22 +224,66 @@ static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, GLsizei n glVertexPointer(3, GL_FLOAT, 0, vertices); glNormalPointer(GL_FLOAT, 0, normals); - /* 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 numFaces, GLsizei numEdgePerFace, +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; - GLuint numVertices = numFaces * numEdgePerFace; - + GLuint vbo_coords = 0, vbo_normals = 0, + ibo_elements = 0, ibo_elements2 = 0; + GLsizei numVertIdxs = numParts * numVertPerPart; + GLsizei numVertIdxs2 = numParts2 * numVertPerPart2; int i; if (numVertices > 0 && attribute_v_coord != -1) { @@ -89,6 +300,22 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n 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); + } + + 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); + } + if (vbo_coords) { fghEnableVertexAttribArray(attribute_v_coord); fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords); @@ -100,6 +327,7 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n 0, /* no extra data between each position */ 0 /* offset of first element */ ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); } if (vbo_normals) { @@ -113,12 +341,32 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n 0, /* no extra data between each position */ 0 /* offset of first element */ ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); } - /* 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 + if (ibo_elements != 0) + fghDeleteBuffers(1, &ibo_elements); + if (ibo_elements2 != 0) + fghDeleteBuffers(1, &ibo_elements2); } -/* 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); - - 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); -} -#endif /* 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) +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, ibo_elements = 0; - + 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) { @@ -195,6 +408,15 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte fghBindBuffer(FGH_ARRAY_BUFFER, vbo_normals); fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(normals[0]), normals, FGH_STATIC_DRAW); + fghBindBuffer(FGH_ARRAY_BUFFER, 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) { @@ -202,6 +424,7 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte 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) { @@ -215,6 +438,7 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte 0, /* no extra data between each position */ 0 /* offset of first element */ ); + fghBindBuffer(FGH_ARRAY_BUFFER, 0); }; if (vbo_normals) { @@ -228,52 +452,145 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte 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); - glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, 0); + if (numParts>1) { + for (i=0; iWindow.attribute_v_coord; - GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal; + int i,j; + numNormalVertices = numVertices * 2; + verticesForNormalVisualization = malloc(numNormalVertices*3 * sizeof(GLfloat)); - 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 + for (i=0,j=0; i= 2.0 */ +static void fghDrawNormalVisualization20(GLint attribute_v_coord) +{ + GLuint vbo_coords = 0; + + 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); + } + + + 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); + } + + 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); } -/* Shape decomposition to triangles +/** + * 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. @@ -283,7 +600,7 @@ static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *v 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) +static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLushort *vertIdxOut) { int i,j,numEdgeIdxPerFace; GLubyte *vertSamps = NULL; @@ -346,9 +663,9 @@ static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLfloat *verti * vertices and normals are unique. */ #define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\ - static GLboolean name##Cached = FALSE;\ - static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ - static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ + static GLboolean name##Cached = GL_FALSE;\ + static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ + static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ static void fgh##nameICaps##Generate()\ {\ fghGenerateGeometry(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ @@ -356,10 +673,10 @@ static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLfloat *verti name##_verts, name##_norms);\ } #define DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(name,nameICaps,nameCaps)\ - static GLboolean name##Cached = FALSE;\ - static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ - static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ - static GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\ + static GLboolean name##Cached = GL_FALSE;\ + static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ + static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ + static GLushort name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\ static void fgh##nameICaps##Generate()\ {\ fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ @@ -719,7 +1036,18 @@ DECLARE_SHAPE_CACHE(tetrahedron,Tetrahedron,TETRAHEDRON) /* -- Sierpinski Sponge -- */ static unsigned int ipow (int x, unsigned int y) { - return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2); + /* return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2); */ + if (y==0) + return 1; + else + { + if (y==1) + return x; + else + { + return (y%2? x: 1) * ipow(x*x, y/2); + } + } } static void fghSierpinskiSpongeGenerate ( int numLevels, double offset[3], GLfloat scale, GLfloat* vertices, GLfloat* normals ) @@ -762,8 +1090,7 @@ static void fghSierpinskiSpongeGenerate ( int numLevels, double offset[3], GLflo } } -#ifndef GL_ES_VERSION_2_0 -/* -- Now the various shapes involving circles -- */ +/* -- Now the various non-polyhedra (shapes involving circles) -- */ /* * Compute lookup table of cos and sin values forming a circle * (or half circle if halfCircle==TRUE) @@ -802,13 +1129,8 @@ static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GL for (i=1; i 65535) /* TODO: must have a better solution than this low limit, at least for architectures where gluint is available */ + if ((*nVert) > 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,FALSE); - fghCircleTable(&sint2,&cost2, stacks,TRUE); + 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)); @@ -921,13 +1246,8 @@ void fghGenerateCone( const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 ); /* Scaling factors for vertex normals */ -#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 */ + const GLfloat cosn = (GLfloat) (height / sqrt( height * height + base * base )); + const GLfloat sinn = (GLfloat) (base / sqrt( height * height + base * base )); @@ -941,10 +1261,13 @@ void fghGenerateCone( *nVert = slices*(stacks+2)+1; /* need an extra stack for closing off bottom with correct normals */ if ((*nVert) > 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"); /* Pre-computed circle */ - fghCircleTable(&sint,&cost,-slices,FALSE); + fghCircleTable(&sint,&cost,-slices,GL_FALSE); /* Allocate vertex and normal buffers, bail out if memory allocation fails */ *vertices = malloc((*nVert)*3*sizeof(GLfloat)); @@ -953,7 +1276,7 @@ void fghGenerateCone( { free(*vertices); free(*normals); - fgError("Failed to allocate memory in fghGenerateSphere"); + fgError("Failed to allocate memory in fghGenerateCone"); } /* bottom */ @@ -983,9 +1306,9 @@ void fghGenerateCone( (*vertices)[idx ] = cost[j]*r; (*vertices)[idx+1] = sint[j]*r; (*vertices)[idx+2] = z; - (*normals )[idx ] = cost[j]*sinn; - (*normals )[idx+1] = sint[j]*sinn; - (*normals )[idx+2] = cosn; + (*normals )[idx ] = cost[j]*cosn; + (*normals )[idx+1] = sint[j]*cosn; + (*normals )[idx+2] = sinn; } z += zStep; @@ -1023,10 +1346,13 @@ void fghGenerateCylinder( *nVert = slices*(stacks+3)+2; /* need two extra stacks for closing off top and bottom with correct normals */ 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,FALSE); + fghCircleTable(&sint,&cost,-slices,GL_FALSE); /* Allocate vertex and normal buffers, bail out if memory allocation fails */ *vertices = malloc((*nVert)*3*sizeof(GLfloat)); @@ -1122,11 +1448,14 @@ void fghGenerateTorus( *nVert = nSides * nRings; if ((*nVert) > 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,FALSE); - fghCircleTable(&sphi,&cphi,-nSides,FALSE); + 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)); @@ -1159,7 +1488,6 @@ void fghGenerateTorus( free(sphi); free(cphi); } -#endif /* -- INTERNAL DRAWING functions --------------------------------------- */ #define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\ @@ -1173,13 +1501,14 @@ void fghGenerateTorus( \ if (useWireMode)\ {\ - fghDrawGeometryWire (name##_verts,name##_norms,\ - nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\ + fghDrawGeometryWire (name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ, \ + NULL,nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE,GL_LINE_LOOP,\ + NULL,0,0);\ }\ else\ {\ - fghDrawGeometrySolid(name##_verts,name##_norms,vertIdxs,\ - nameCaps##_VERT_PER_OBJ, nameCaps##_VERT_PER_OBJ_TRI); \ + fghDrawGeometrySolid(name##_verts,name##_norms,NULL,nameCaps##_VERT_PER_OBJ,\ + vertIdxs, 1, nameCaps##_VERT_PER_OBJ_TRI); \ }\ } #define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL) @@ -1216,11 +1545,12 @@ static void fghCube( GLfloat dSize, GLboolean useWireMode ) vertices = cube_verts; if (useWireMode) - fghDrawGeometryWire(vertices, cube_norms, - CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE); + fghDrawGeometryWire(vertices, cube_norms, CUBE_VERT_PER_OBJ, + NULL,CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE,GL_LINE_LOOP, + NULL,0,0); else - fghDrawGeometrySolid(vertices, cube_norms, cube_vertIdxs, - CUBE_VERT_PER_OBJ, CUBE_VERT_PER_OBJ_TRI); + fghDrawGeometrySolid(vertices, cube_norms, NULL, CUBE_VERT_PER_OBJ, + cube_vertIdxs, 1, CUBE_VERT_PER_OBJ_TRI); if (dSize!=1.f) /* cleanup allocated memory */ @@ -1259,9 +1589,11 @@ static void fghSierpinskiSponge ( int numLevels, double offset[3], GLfloat scale /* Draw and cleanup */ if (useWireMode) - fghDrawGeometryWire (vertices,normals,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE); + fghDrawGeometryWire (vertices,normals,numVert, + NULL,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE,GL_LINE_LOOP, + NULL,0,0); else - fghDrawGeometrySolid(vertices,normals,NULL,numVert,numVert); + fghDrawGeometrySolid(vertices,normals,NULL,numVert,NULL,1,0); free(vertices); free(normals ); @@ -1269,14 +1601,13 @@ static void fghSierpinskiSponge ( int numLevels, double offset[3], GLfloat scale } -#ifndef GL_ES_VERSION_2_0 -static void fghSphere( double radius, GLint slices, GLint stacks, GLboolean useWireMode ) +static void fghSphere( GLfloat radius, GLint slices, GLint stacks, GLboolean useWireMode ) { int i,j,idx, nVert; GLfloat *vertices, *normals; /* Generate vertices and normals */ - fghGenerateSphere((GLfloat)radius,slices,stacks,&vertices,&normals,&nVert); + fghGenerateSphere(radius,slices,stacks,&vertices,&normals,&nVert); if (nVert==0) /* nothing to draw */ @@ -1322,21 +1653,10 @@ static void fghSphere( double radius, GLint slices, GLint stacks, GLboolean useW } /* draw */ - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - - glVertexPointer(3, GL_FLOAT, 0, vertices); - glNormalPointer(GL_FLOAT, 0, normals); - /*draw slices*/ - for (i=0; i