X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=96c712c758b4f233cdd37dc38446c1f3073ef0df;hb=a28bca657173033061d5af4fc9846a32597700c0;hp=f9973fbd406ac5f4b3032a503fca82dd7f0c8a58;hpb=87653f06a12512952a629eb3380980cfe445584c;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index f9973fb..96c712c 100644 --- a/src/fg_geometry.c +++ b/src/fg_geometry.c @@ -27,6 +27,8 @@ #include #include "fg_internal.h" +#include "fg_gl2.h" +#include /* * Need more types of polyhedra? See CPolyhedron in MRPT @@ -42,15 +44,18 @@ * decomposition needed. We use the "first" parameter in glDrawArrays to go * from face to face. */ -static void fghDrawGeometryWire(GLdouble *vertices, GLdouble *normals, GLsizei numFaces, GLsizei numEdgePerFace) + +/* Version for OpenGL (ES) 1.1 */ +#ifndef GL_ES_VERSION_2_0 +static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace) { int i; glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); + glVertexPointer(3, GL_FLOAT, 0, vertices); + glNormalPointer(GL_FLOAT, 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; + + 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 + ); + } + + 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); - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); - if (numEdgePerFace==3) + glVertexPointer(3, GL_FLOAT, 0, vertices); + glNormalPointer(GL_FLOAT, 0, normals); + if (vertIdxs == NULL) glDrawArrays(GL_TRIANGLES, 0, numVertices); else - glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_BYTE, vertIdxs); + 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) +{ + 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); +} + +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 +} /* Shape decomposition to triangles - * We'll use glDrawElements to draw all shapes that are not triangles, so - * generate an index vector here, using the below sampling scheme. + * 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... */ 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, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLubyte *vertIdxOut) +static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLubyte *vertIdxOut) { int i,j,numEdgeIdxPerFace; GLubyte *vertSamps = NULL; switch (numEdgePerFace) { case 3: - /* nothing to do here, we'll drawn with glDrawArrays */ + /* nothing to do here, we'll draw with glDrawArrays */ break; case 4: vertSamps = vert4Decomp; @@ -132,7 +326,7 @@ static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, } } -static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut) +static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut) { /* This function does the same as fghGenerateGeometryWithIndexArray, just skipping the index array generation... */ fghGenerateGeometryWithIndexArray(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL); @@ -144,12 +338,12 @@ static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vert /* Cache of input to glDrawArrays or glDrawElements * In general, we build arrays with all vertices or normals. * We cant compress this and use glDrawElements as all combinations of - * vertex and normals are unique. + * vertices and normals are unique. */ #define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\ static GLboolean name##Cached = FALSE;\ - static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ - static GLdouble name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ + 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,\ @@ -158,8 +352,8 @@ static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vert } #define DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(name,nameICaps,nameCaps)\ static GLboolean name##Cached = FALSE;\ - static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ - static GLdouble name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ + 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 void fgh##nameICaps##Generate()\ {\ @@ -176,29 +370,29 @@ static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vert #define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ*3) #define CUBE_VERT_PER_OBJ_TRI (CUBE_VERT_PER_OBJ+CUBE_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ /* Vertex Coordinates */ -static GLdouble cube_v[CUBE_NUM_VERT*3] = +static GLfloat cube_v[CUBE_NUM_VERT*3] = { - .5, .5, .5, - -.5, .5, .5, - -.5,-.5, .5, - .5,-.5, .5, - .5,-.5,-.5, - .5, .5,-.5, - -.5, .5,-.5, - -.5,-.5,-.5 + .5f, .5f, .5f, + -.5f, .5f, .5f, + -.5f,-.5f, .5f, + .5f,-.5f, .5f, + .5f,-.5f,-.5f, + .5f, .5f,-.5f, + -.5f, .5f,-.5f, + -.5f,-.5f,-.5f }; /* Normal Vectors */ -static GLdouble cube_n[CUBE_NUM_FACES*3] = +static GLfloat cube_n[CUBE_NUM_FACES*3] = { - 0.0, 0.0, 1.0, - 1.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - -1.0, 0.0, 0.0, - 0.0,-1.0, 0.0, - 0.0, 0.0,-1.0 + 0.0f, 0.0f, 1.0f, + 1.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, + -1.0f, 0.0f, 0.0f, + 0.0f,-1.0f, 0.0f, + 0.0f, 0.0f,-1.0f }; -/* Vertex indices */ +/* Vertex indices, as quads, before triangulation */ static GLubyte cube_vi[CUBE_VERT_PER_OBJ] = { 0,1,2,3, @@ -224,46 +418,46 @@ DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE); #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 GLdouble dodecahedron_v[DODECAHEDRON_NUM_VERT*3] = +static GLfloat dodecahedron_v[DODECAHEDRON_NUM_VERT*3] = { - 0.0 , 1.61803398875, 0.61803398875, - -1.0 , 1.0 , 1.0 , - -0.61803398875, 0.0 , 1.61803398875, - 0.61803398875, 0.0 , 1.61803398875, - 1.0 , 1.0 , 1.0 , - 0.0 , 1.61803398875, -0.61803398875, - 1.0 , 1.0 , -1.0 , - 0.61803398875, 0.0 , -1.61803398875, - -0.61803398875, 0.0 , -1.61803398875, - -1.0 , 1.0 , -1.0 , - 0.0 , -1.61803398875, 0.61803398875, - 1.0 , -1.0 , 1.0 , - -1.0 , -1.0 , 1.0 , - 0.0 , -1.61803398875, -0.61803398875, - -1.0 , -1.0 , -1.0 , - 1.0 , -1.0 , -1.0 , - 1.61803398875, -0.61803398875, 0.0 , - 1.61803398875, 0.61803398875, 0.0 , - -1.61803398875, 0.61803398875, 0.0 , - -1.61803398875, -0.61803398875, 0.0 + 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 GLdouble dodecahedron_n[DODECAHEDRON_NUM_FACES*3] = +static GLfloat dodecahedron_n[DODECAHEDRON_NUM_FACES*3] = { - 0.0 , 0.525731112119, 0.850650808354, - 0.0 , 0.525731112119, -0.850650808354, - 0.0 , -0.525731112119, 0.850650808354, - 0.0 , -0.525731112119, -0.850650808354, - - 0.850650808354, 0.0 , 0.525731112119, - -0.850650808354, 0.0 , 0.525731112119, - 0.850650808354, 0.0 , -0.525731112119, - -0.850650808354, 0.0 , -0.525731112119, - - 0.525731112119, 0.850650808354, 0.0 , - 0.525731112119, -0.850650808354, 0.0 , - -0.525731112119, 0.850650808354, 0.0 , - -0.525731112119, -0.850650808354, 0.0 , + 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, }; /* Vertex indices */ @@ -295,48 +489,48 @@ DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON #define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ*3) #define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ /* Vertex Coordinates */ -static GLdouble icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = +static GLfloat icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = { - 1.0, 0.0, 0.0 , - 0.447213595500, 0.894427191000, 0.0 , - 0.447213595500, 0.276393202252, 0.850650808354, - 0.447213595500, -0.723606797748, 0.525731112119, - 0.447213595500, -0.723606797748, -0.525731112119, - 0.447213595500, 0.276393202252, -0.850650808354, - -0.447213595500, -0.894427191000, 0.0 , - -0.447213595500, -0.276393202252, 0.850650808354, - -0.447213595500, 0.723606797748, 0.525731112119, - -0.447213595500, 0.723606797748, -0.525731112119, - -0.447213595500, -0.276393202252, -0.850650808354, - -1.0, 0.0, 0.0 + 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 GLdouble icosahedron_n[ICOSAHEDRON_NUM_FACES*3] = +static GLfloat icosahedron_n[ICOSAHEDRON_NUM_FACES*3] = { - 0.760845213037948, 0.470228201835026, 0.341640786498800, - 0.760845213036861, -0.179611190632978, 0.552786404500000, - 0.760845213033849, -0.581234022404097, 0, - 0.760845213036861, -0.179611190632978, -0.552786404500000, - 0.760845213037948, 0.470228201835026, -0.341640786498800, - 0.179611190628666, 0.760845213037948, 0.552786404498399, - 0.179611190634277, -0.290617011204044, 0.894427191000000, - 0.179611190633958, -0.940456403667806, 0, - 0.179611190634278, -0.290617011204044, -0.894427191000000, - 0.179611190628666, 0.760845213037948, -0.552786404498399, - -0.179611190633958, 0.940456403667806, 0, - -0.179611190634277, 0.290617011204044, 0.894427191000000, - -0.179611190628666, -0.760845213037948, 0.552786404498399, - -0.179611190628666, -0.760845213037948, -0.552786404498399, - -0.179611190634277, 0.290617011204044, -0.894427191000000, - -0.760845213036861, 0.179611190632978, -0.552786404500000, - -0.760845213033849, 0.581234022404097, 0, - -0.760845213036861, 0.179611190632978, 0.552786404500000, - -0.760845213037948, -0.470228201835026, 0.341640786498800, - -0.760845213037948, -0.470228201835026, -0.341640786498800, + 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, }; /* Vertex indices */ @@ -374,27 +568,27 @@ DECLARE_SHAPE_CACHE(icosahedron,Icosahedron,ICOSAHEDRON); #define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ /* Vertex Coordinates */ -static GLdouble octahedron_v[OCTAHEDRON_NUM_VERT*3] = +static GLfloat octahedron_v[OCTAHEDRON_NUM_VERT*3] = { - 1., 0., 0., - 0., 1., 0., - 0., 0., 1., - -1., 0., 0., - 0., -1., 0., - 0., 0., -1., + 1.f, 0.f, 0.f, + 0.f, 1.f, 0.f, + 0.f, 0.f, 1.f, + -1.f, 0.f, 0.f, + 0.f, -1.f, 0.f, + 0.f, 0.f, -1.f, }; /* Normal Vectors */ -static GLdouble octahedron_n[OCTAHEDRON_NUM_FACES*3] = +static GLfloat octahedron_n[OCTAHEDRON_NUM_FACES*3] = { - 0.577350269189, 0.577350269189, 0.577350269189, /* sqrt(1/3) */ - 0.577350269189, 0.577350269189,-0.577350269189, - 0.577350269189,-0.577350269189, 0.577350269189, - 0.577350269189,-0.577350269189,-0.577350269189, - -0.577350269189, 0.577350269189, 0.577350269189, - -0.577350269189, 0.577350269189,-0.577350269189, - -0.577350269189,-0.577350269189, 0.577350269189, - -0.577350269189,-0.577350269189,-0.577350269189 + 0.577350269189f, 0.577350269189f, 0.577350269189f, /* sqrt(1/3) */ + 0.577350269189f, 0.577350269189f,-0.577350269189f, + 0.577350269189f,-0.577350269189f, 0.577350269189f, + 0.577350269189f,-0.577350269189f,-0.577350269189f, + -0.577350269189f, 0.577350269189f, 0.577350269189f, + -0.577350269189f, 0.577350269189f,-0.577350269189f, + -0.577350269189f,-0.577350269189f, 0.577350269189f, + -0.577350269189f,-0.577350269189f,-0.577350269189f }; @@ -421,38 +615,38 @@ DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON); #define RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ /* Vertex Coordinates */ -static GLdouble rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] = +static GLfloat rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] = { - 0.0, 0.0, 1.0, - 0.707106781187, 0.0 , 0.5, - 0.0 , 0.707106781187, 0.5, - -0.707106781187, 0.0 , 0.5, - 0.0 , -0.707106781187, 0.5, - 0.707106781187, 0.707106781187, 0.0, - -0.707106781187, 0.707106781187, 0.0, - -0.707106781187, -0.707106781187, 0.0, - 0.707106781187, -0.707106781187, 0.0, - 0.707106781187, 0.0 , -0.5, - 0.0 , 0.707106781187, -0.5, - -0.707106781187, 0.0 , -0.5, - 0.0 , -0.707106781187, -0.5, - 0.0, 0.0, -1.0 + 0.0f, 0.0f, 1.0f, + 0.707106781187f, 0.0f, 0.5f, + 0.0f, 0.707106781187f, 0.5f, + -0.707106781187f, 0.0f, 0.5f, + 0.0f, -0.707106781187f, 0.5f, + 0.707106781187f, 0.707106781187f, 0.0f, + -0.707106781187f, 0.707106781187f, 0.0f, + -0.707106781187f, -0.707106781187f, 0.0f, + 0.707106781187f, -0.707106781187f, 0.0f, + 0.707106781187f, 0.0f, -0.5f, + 0.0f, 0.707106781187f, -0.5f, + -0.707106781187f, 0.0f, -0.5f, + 0.0f, -0.707106781187f, -0.5f, + 0.0f, 0.0f, -1.0f }; /* Normal Vectors */ -static GLdouble rhombicdodecahedron_n[RHOMBICDODECAHEDRON_NUM_FACES*3] = +static GLfloat rhombicdodecahedron_n[RHOMBICDODECAHEDRON_NUM_FACES*3] = { - 0.353553390594, 0.353553390594, 0.5, - -0.353553390594, 0.353553390594, 0.5, - -0.353553390594, -0.353553390594, 0.5, - 0.353553390594, -0.353553390594, 0.5, - 0.0 , 1.0 , 0.0, - -1.0 , 0.0 , 0.0, - 0.0 , -1.0 , 0.0, - 1.0 , 0.0 , 0.0, - 0.353553390594, 0.353553390594, -0.5, - -0.353553390594, 0.353553390594, -0.5, - -0.353553390594, -0.353553390594, -0.5, - 0.353553390594, -0.353553390594, -0.5 + 0.353553390594f, 0.353553390594f, 0.5f, + -0.353553390594f, 0.353553390594f, 0.5f, + -0.353553390594f, -0.353553390594f, 0.5f, + 0.353553390594f, -0.353553390594f, 0.5f, + 0.0f, 1.0f, 0.0f, + - 1.0f, 0.0f, 0.0f, + 0.0f, - 1.0f, 0.0f, + 1.0f, 0.0f, 0.0f, + 0.353553390594f, 0.353553390594f, -0.5f, + -0.353553390594f, 0.353553390594f, -0.5f, + -0.353553390594f, -0.353553390594f, -0.5f, + 0.353553390594f, -0.353553390594f, -0.5f }; /* Vertex indices */ @@ -491,20 +685,20 @@ DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedro #define TETRAHEDRON_VERT_PER_OBJ_TRI TETRAHEDRON_VERT_PER_OBJ /* Vertex Coordinates */ -static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] = +static GLfloat tetrahedron_v[TETRAHEDRON_NUM_VERT*3] = { - 1.0, 0.0, 0.0, - -0.333333333333, 0.942809041582, 0.0, - -0.333333333333, -0.471404520791, 0.816496580928, - -0.333333333333, -0.471404520791, -0.816496580928 + 1.0f, 0.0f, 0.0f, + -0.333333333333f, 0.942809041582f, 0.0f, + -0.333333333333f, -0.471404520791f, 0.816496580928f, + -0.333333333333f, -0.471404520791f, -0.816496580928f }; /* Normal Vectors */ -static GLdouble tetrahedron_n[TETRAHEDRON_NUM_FACES*3] = +static GLfloat tetrahedron_n[TETRAHEDRON_NUM_FACES*3] = { - - 1.0, 0.0, 0.0, - 0.333333333333, -0.942809041582, 0.0, - 0.333333333333, 0.471404520791, -0.816496580928, - 0.333333333333, 0.471404520791, 0.816496580928 + - 1.0f, 0.0f, 0.0f, + 0.333333333333f, -0.942809041582f, 0.0f, + 0.333333333333f, 0.471404520791f, -0.816496580928f, + 0.333333333333f, 0.471404520791f, 0.816496580928f }; /* Vertex indices */ @@ -523,7 +717,7 @@ 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); } -static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLdouble scale, GLdouble* vertices, GLdouble* normals ) +static void fghSierpinskiSpongeGenerate ( int numLevels, double offset[3], GLfloat scale, GLfloat* vertices, GLfloat* normals ) { int i, j; if ( numLevels == 0 ) @@ -537,9 +731,9 @@ static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLd int outIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE*3+j*3; int vertIdx = tetrahedron_vi[faceIdxVertIdx+j]*3; - vertices[outIdx ] = offset[0] + scale * tetrahedron_v[vertIdx ]; - vertices[outIdx+1] = offset[1] + scale * tetrahedron_v[vertIdx+1]; - vertices[outIdx+2] = offset[2] + scale * tetrahedron_v[vertIdx+2]; + vertices[outIdx ] = (GLfloat)offset[0] + scale * tetrahedron_v[vertIdx ]; + vertices[outIdx+1] = (GLfloat)offset[1] + scale * tetrahedron_v[vertIdx+1]; + vertices[outIdx+2] = (GLfloat)offset[2] + scale * tetrahedron_v[vertIdx+2]; normals [outIdx ] = tetrahedron_n[normIdx ]; normals [outIdx+1] = tetrahedron_n[normIdx+1]; @@ -549,7 +743,7 @@ static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLd } else if ( numLevels > 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++ ) @@ -574,7 +768,7 @@ 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(GLdouble **sint, GLdouble **cost, const int n, const GLboolean halfCircle) +static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GLboolean halfCircle) { int i; @@ -582,11 +776,11 @@ static void fghCircleTable(GLdouble **sint, GLdouble **cost, const int n, const const int size = abs(n); /* Determine the angle between samples */ - const GLdouble angle = (halfCircle?1:2)*M_PI/(GLdouble)( ( 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 = malloc(sizeof(GLdouble) * (size+1)); - *cost = malloc(sizeof(GLdouble) * (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)) @@ -602,15 +796,20 @@ static void fghCircleTable(GLdouble **sint, GLdouble **cost, const int n, const for (i=1; i 65535) + fgWarning("fghSphere: too many slices or stacks requested, indices will wrap"); - /* Pre-computed circle */ + /* Generate vertices and normals */ + fghGenerateSphere((GLfloat)radius,slices,stacks,&vertices,&normals,&nVert); + + if (nVert==0) + /* nothing to draw */ + return; - GLdouble *sint1,*cost1; - GLdouble *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,FALSE); - fghCircleTable(&sint2,&cost2, stacks,TRUE); + /* 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 GLdouble 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 GLdouble cosn = ( height / sqrt ( height * height + base * base )); - const GLdouble 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 */ - GLdouble *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" ); @@ -918,33 +1210,32 @@ void FGAPIENTRY glutSolidCone( GLdouble base, GLdouble height, GLint slices, GLi /* 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 GLdouble 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 GLdouble cosn = ( height / sqrt ( height * height + base * base )); - const GLdouble 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 */ - GLdouble *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" ); @@ -1011,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 */ - GLdouble *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" ); @@ -1066,35 +1346,35 @@ void FGAPIENTRY glutSolidCylinder(GLdouble radius, GLdouble height, GLint slices /* 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(); @@ -1110,18 +1390,18 @@ 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. */ - - GLdouble z = 0.0; - const GLdouble 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 */ - GLdouble *sint,*cost; + GLfloat *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" ); @@ -1132,14 +1412,14 @@ void FGAPIENTRY glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, for (i=0; i<=stacks; i++) { if (i==stacks) - z = height; + z = (GLfloat)height; glBegin(GL_LINE_LOOP); for( j=0; j