X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=312acfc9095050befbcb327f27e5787a16433110;hb=8ee5d611ce7eb724a108781b67cacbae6715abde;hp=01e76fcef9c5097d9ff1d356df150cf5a50fafaa;hpb=fd08532c4c6d7673aa241238f0afca21ba3f8364;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index 01e76fc..312acfc 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,7 +44,10 @@ * decomposition needed. We use the "first" parameter in glDrawArrays to go * from face to face. */ -static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *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; @@ -59,25 +64,214 @@ static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei num glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); } -static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, GLsizei numVertices, GLsizei numEdgePerFace) +#endif + +/* Version for OpenGL (ES) >= 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_FLOAT, 0, vertices); glNormalPointer(GL_FLOAT, 0, normals); - if (numEdgePerFace==3) + 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... */ @@ -91,7 +285,7 @@ static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, 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; @@ -144,7 +338,7 @@ static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLfloat *verti /* 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;\ @@ -198,7 +392,7 @@ static GLfloat cube_n[CUBE_NUM_FACES*3] = 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, @@ -620,6 +814,81 @@ static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GL } } +static void fghGenerateSphere(GLfloat radius, GLint slices, GLint stacks, GLfloat **vertices, GLfloat **normals, int* nVert) +{ + int i,j; + int idx = 0; /* idx into vertex/normal buffer */ + GLfloat x,y,z; + + /* Pre-computed circle */ + GLfloat *sint1,*cost1; + GLfloat *sint2,*cost2; + + /* number of unique vertices */ + if (slices==0 || stacks<2) + { + /* nothing to generate */ + *nVert = 0; + return; + } + *nVert = slices*(stacks-1)+2; + + /* precompute values on unit circle */ + fghCircleTable(&sint1,&cost1,-slices,FALSE); + fghCircleTable(&sint2,&cost2, stacks,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)) + { + free(*vertices); + free(*normals); + fgError("Failed to allocate memory in fghGenerateSphere"); + } + + /* 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 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; - GLfloat *sint1,*cost1; - GLfloat *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; - 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 + { + GLushort *topIdx, *bottomIdx, *stripIdx; + /* First, generate vertex index arrays for drawing with glDrawElements + * Top and bottom are covered with a triangle fan + * Each other stack with triangle strip. Only need to generate on + * of those as we'll have to draw each stack separately, and can + * just use different offsets in glDrawElements. + */ + + /* Allocate buffers for indices, bail out if memory allocation fails */ + topIdx = malloc((slices+2)*sizeof(GLushort)); + bottomIdx = malloc((slices+2)*sizeof(GLushort)); + stripIdx = malloc((slices+1)*2*(stacks-2)*sizeof(GLushort)); + if (!(topIdx) || !(bottomIdx) || !(stripIdx)) { - glNormal3f(cost1[j]*r1, sint1[j]*r1, z1 ); - glVertex3f(cost1[j]*r1*radf, sint1[j]*r1*radf, z1*radf); + free(topIdx); + free(bottomIdx); + free(stripIdx); + fgError("Failed to allocate memory in fghGenerateSphere"); } - glEnd(); + /* TODO: Can do top and bottom as Triangle strip as well + (just need to repeat top/btoom vertex a lot). Then we can draw + the whole thing with just one index array and one for-looped call + to glDrawElements.. That'll make it easier to reuse code with other + Circular objects too + */ + topIdx[0]=0; + topIdx[1] = 1; /* repeat first slice's idx for closing off shape */ + for (j=slices, idx=2; j>0; j--, idx++) + topIdx[idx] = j; + + bottomIdx[0]=nVert-1; /* zero based index, last element in array... */ + for (j=0, idx=1; j