X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=3e47e95f04a8083c68bd90c9639ebff14f9d6a1a;hb=87a7ed7f400541da5441336152e3cd3657aead51;hp=0ffffcb55d2d02db342f62e81098bb45e59cc77d;hpb=c72a923191b4c307d10c153eee8406b0272a0d19;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index 0ffffcb..3e47e95 100644 --- a/src/fg_geometry.c +++ b/src/fg_geometry.c @@ -47,7 +47,10 @@ /* 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,9 +60,18 @@ 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; i= 2.0 */ -static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace, - GLint attribute_v_coord, GLint attribute_v_normal) +static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, + 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 numVertices = numParts * numVertPerPart; int i; @@ -93,12 +108,12 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n 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 + 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 */ ); } @@ -106,18 +121,18 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n 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 + 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); + fghDrawGeometryWire20(vertices, normals, + vertIdxs, numParts, numVertPerPart, vertexMode, + vertIdxs2, numParts2, numVertPerPart2, + attribute_v_coord, attribute_v_normal); #ifndef GL_ES_VERSION_2_0 else - fghDrawGeometryWire11(vertices, normals, numFaces, numEdgePerFace); + fghDrawGeometryWire11(vertices, normals, + vertIdxs, numParts, numVertPerPart, vertexMode, + vertIdxs2, numParts2, numVertPerPart2); #endif } @@ -158,9 +180,11 @@ static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei num /* 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) +static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs, + GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart) { + int i; + glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); @@ -169,7 +193,11 @@ static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLubyte if (vertIdxs == NULL) glDrawArrays(GL_TRIANGLES, 0, numVertices); else - glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, vertIdxs); + if (numParts>1) + for (i=0; i= 2.0 */ -static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, - GLsizei numVertices, GLsizei numVertIdxs, +static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs, + GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart, GLint attribute_v_coord, GLint attribute_v_normal) { GLuint vbo_coords = 0, vbo_normals = 0, ibo_elements = 0; @@ -200,7 +228,7 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte if (vertIdxs != NULL) { fghGenBuffers(1, &ibo_elements); fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements); - fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs * sizeof(vertIdxs[0]), + fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxsPerPart * sizeof(vertIdxs[0]), vertIdxs, FGH_STATIC_DRAW); } @@ -208,12 +236,12 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte 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 + 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 */ ); }; @@ -221,12 +249,12 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte 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 + 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 */ ); }; @@ -234,8 +262,13 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte glDrawArrays(GL_TRIANGLES, 0, numVertices); } else { fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements); - glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, 0); + glDrawElements(GL_TRIANGLES, numVertIdxsPerPart, GL_UNSIGNED_SHORT, 0); } + + /* Clean existing bindings before clean-up */ + /* Android showed instability otherwise */ + fghBindBuffer(FGH_ARRAY_BUFFER, 0); + fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0); if (vbo_coords != 0) fghDisableVertexAttribArray(attribute_v_coord); @@ -250,8 +283,8 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte fghDeleteBuffers(1, &ibo_elements); } -static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, - GLsizei numVertices, GLsizei numVertIdxs) +static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs, + GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart) { GLint attribute_v_coord = fgStructure.CurrentWindow->Window.attribute_v_coord; GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal; @@ -259,12 +292,12 @@ static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *v if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1)) /* User requested a 2.0 draw */ fghDrawGeometrySolid20(vertices, normals, vertIdxs, - numVertices, numVertIdxs, + numVertices, numParts, numVertIdxsPerPart, attribute_v_coord, attribute_v_normal); #ifndef GL_ES_VERSION_2_0 else fghDrawGeometrySolid11(vertices, normals, vertIdxs, - numVertices, numVertIdxs); + numVertices, numParts, numVertIdxsPerPart); #endif } @@ -278,7 +311,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; @@ -304,7 +337,7 @@ static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, for (i=0; i 65535) /* TODO: must have a better solution than this low limit, at least for architectures where gluint is available */ + fgWarning("fghGenerateSphere: too many slices or stacks requested, indices will wrap"); /* precompute values on unit circle */ fghCircleTable(&sint1,&cost1,-slices,FALSE); @@ -845,7 +881,7 @@ static void fghGenerateSphere(GLfloat radius, GLint slices, GLint stacks, GLfloa /* 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)) + if (!(*vertices) || !(*normals)) { free(*vertices); free(*normals); @@ -894,6 +930,264 @@ static void fghGenerateSphere(GLfloat radius, GLint slices, GLint stacks, GLfloa free(cost2); } +void fghGenerateCone( + GLfloat base, GLfloat height, GLint slices, GLint stacks, /* input */ + GLfloat **vertices, GLfloat **normals, int* nVert /* output */ + ) +{ + int i,j; + int idx = 0; /* idx into vertex/normal buffer */ + + /* Pre-computed circle */ + GLfloat *sint,*cost; + + /* Step in z and radius as stacks are drawn. */ + GLfloat z = 0; + GLfloat r = (GLfloat)base; + + const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 ); + 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 */ + + + + /* number of unique vertices */ + if (slices==0 || stacks<1) + { + /* nothing to generate */ + *nVert = 0; + return; + } + *nVert = slices*(stacks+2)+1; /* need an extra stack for closing off bottom with correct normals */ + + if ((*nVert) > 65535) + fgWarning("fghGenerateCone: too many slices or stacks requested, indices will wrap"); + + /* Pre-computed circle */ + fghCircleTable(&sint,&cost,-slices,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 fghGenerateSphere"); + } + + /* 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 ); + + /* Pre-computed circle */ + GLfloat *sint,*cost; + + /* 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 */ + + if ((*nVert) > 65535) + fgWarning("fghGenerateCylinder: too many slices or stacks requested, indices will wrap"); + + /* Pre-computed circle */ + fghCircleTable(&sint,&cost,-slices,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 fghGenerateCylinder"); + } + + 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) + 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); + + /* 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 65535) - fgWarning("fghSphere: too many slices or stacks requested, indices will wrap"); - /* Generate vertices and normals */ fghGenerateSphere((GLfloat)radius,slices,stacks,&vertices,&normals,&nVert); @@ -1029,17 +1324,11 @@ static void fghSphere( double radius, GLint slices, GLint stacks, GLboolean useW sliceIdx = malloc(slices*(stacks+1)*sizeof(GLushort)); stackIdx = malloc(slices*(stacks-1)*sizeof(GLushort)); - - /* generate for each stack */ - for (i=0,idx=0; i 0 ) ? stacks : 1 ); - const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 ); + /* generate for each slice */ + for (i=0,idx=0; i 0 ) ? stacks : 1 ); - 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 */ - - /* Pre-computed circle */ - - GLfloat *sint,*cost; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" ); + int i,j,idx, nVert; + GLfloat *vertices, *normals; - fghCircleTable(&sint,&cost,-slices,FALSE); + /* Generate vertices and normals */ + /* Note, (stacks+1)*slices vertices for side of object, 2*slices+2 for top and bottom closures */ + fghGenerateCylinder((GLfloat)radius,(GLfloat)height,slices,stacks,&vertices,&normals,&nVert); - /* Draw the stacks... */ + if (nVert==0) + /* nothing to draw */ + return; - for (i=0; i 0 ) ? stacks : 1 ); - - /* Pre-computed circle */ + int i,j,idx, nVert; + GLfloat *vertices, *normals; - GLfloat *sint,*cost; + /* Generate vertices and normals */ + fghGenerateTorus((GLfloat)dInnerRadius,(GLfloat)dOuterRadius,nSides,nRings, &vertices,&normals,&nVert); - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" ); + if (nVert==0) + /* nothing to draw */ + return; - fghCircleTable(&sint,&cost,-slices,FALSE); + if (useWireMode) + { + GLushort *sideIdx, *ringIdx; + /* First, generate vertex index arrays for drawing with glDrawElements + * We have a bunch of line_loops to draw each side, and a + * bunch for each ring. + */ - /* Cover the base and top */ + ringIdx = malloc(nRings*nSides*sizeof(GLushort)); + sideIdx = malloc(nSides*nRings*sizeof(GLushort)); + if (!(ringIdx) || !(sideIdx)) + { + free(ringIdx); + free(sideIdx); + fgError("Failed to allocate memory in fghTorus"); + } - glBegin(GL_TRIANGLE_FAN); - glNormal3f(0, 0, -1 ); - glVertex3f(0, 0, 0 ); - for (j=0; j<=slices; j++) - glVertex3f(cost[j]*radf, sint[j]*radf, 0); - glEnd(); + /* generate for each ring */ + for( j=0,idx=0; j=0; j--) - glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height); - glEnd(); + /* generate for each side */ + for( i=0,idx=0; i 0 ) ? stacks : 1 ); - - /* Pre-computed circle */ - - GLfloat *sint,*cost; +/* -- INTERFACE FUNCTIONS ---------------------------------------------- */ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" ); - fghCircleTable(&sint,&cost,-slices,FALSE); +/* + * Draws a solid sphere + */ +void FGAPIENTRY glutSolidSphere(double radius, GLint slices, GLint stacks) +{ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" ); - /* Draw the stacks... */ + fghSphere( radius, slices, stacks, FALSE ); +} - for (i=0; i<=stacks; i++) - { - if (i==stacks) - z = (GLfloat)height; +/* + * Draws a wire sphere + */ +void FGAPIENTRY glutWireSphere(double radius, GLint slices, GLint stacks) +{ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" ); - glBegin(GL_LINE_LOOP); + fghSphere( radius, slices, stacks, TRUE ); + +} +#endif /* GL_ES_VERSION_2_0 */ - for( j=0; j