/* 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;
glVertexPointer(3, GL_FLOAT, 0, vertices);
glNormalPointer(GL_FLOAT, 0, normals);
- /* Draw per face (TODO: could use glMultiDrawArrays if available) */
- for (i=0; i<numFaces; i++)
- glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace);
+
+ if (!vertIdxs)
+ /* Draw per face (TODO: could use glMultiDrawArrays if available) */
+ for (i=0; i<numParts; i++)
+ glDrawArrays(vertexMode, i*numVertPerPart, numVertPerPart);
+ else
+ for (i=0; i<numParts; i++)
+ glDrawElements(vertexMode,numVertPerPart,GL_UNSIGNED_SHORT,vertIdxs+i*numVertPerPart);
+
+ if (vertIdxs2)
+ for (i=0; i<numParts2; i++)
+ glDrawElements(GL_LINE_LOOP,numVertPerPart2,GL_UNSIGNED_SHORT,vertIdxs2+i*numVertPerPart2);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
#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)
+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;
}
/* Draw per face (TODO: could use glMultiDrawArrays if available) */
- for (i=0; i<numFaces; i++)
- glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace);
+ for (i=0; i<numParts; i++)
+ glDrawArrays(vertexMode, i*numVertPerPart, numVertPerPart);
if (vbo_coords != 0)
fghDeleteBuffers(1, &vbo_normals);
}
-static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace)
+static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals,
+ 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, 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
}
/* 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);
if (vertIdxs == NULL)
glDrawArrays(GL_TRIANGLES, 0, numVertices);
else
- glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, vertIdxs);
+ if (numParts>1)
+ for (i=0; i<numParts; i++)
+ glDrawElements(GL_TRIANGLE_STRIP, numVertIdxsPerPart, GL_UNSIGNED_SHORT, vertIdxs+i*numVertIdxsPerPart);
+ else
+ glDrawElements(GL_TRIANGLES, numVertIdxsPerPart, GL_UNSIGNED_SHORT, 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,
+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;
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);
}
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);
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;
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
}
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;
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 GLushort name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\
static void fgh##nameICaps##Generate()\
{\
fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
}
}
-#ifndef GL_ES_VERSION_2_0
/* -- Now the various shapes involving circles -- */
/*
* Compute lookup table of cos and sin values forming a circle
return;
}
*nVert = slices*(stacks-1)+2;
+ if ((*nVert) > 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);
/* 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);
*nVert = 0;
return;
}
- *nVert = slices*(stacks+1)+1;
+ *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))
+ if (!(*vertices) || !(*normals))
{
free(*vertices);
free(*normals);
(*normals )[1] = 0.f;
(*normals )[2] = -1.f;
idx = 3;
+ /* other on bottom (get normals right) */
+ for (j=0; j<slices; j++, idx+=3)
+ {
+ (*vertices)[idx ] = cost[j]*r;
+ (*vertices)[idx+1] = sint[j]*r;
+ (*vertices)[idx+2] = z;
+ (*normals )[idx ] = 0.f;
+ (*normals )[idx+1] = 0.f;
+ (*normals )[idx+2] = -1.f;
+ }
/* each stack */
for (i=0; i<stacks+1; i++ )
free(sint);
free(cost);
}
-#endif
+
+void fghGenerateCylinder(
+ GLfloat radius, 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 */
+
+ /* Step in z as stacks are drawn. */
+ GLfloat radf = (GLfloat)radius;
+ GLfloat z;
+ const GLfloat zStep = (GLfloat)height / ( ( stacks > 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<slices; j++, idx+=3)
+ {
+ (*vertices)[idx ] = cost[j]*radf;
+ (*vertices)[idx+1] = sint[j]*radf;
+ (*vertices)[idx+2] = z;
+ (*normals )[idx ] = 0.f;
+ (*normals )[idx+1] = 0.f;
+ (*normals )[idx+2] = -1.f;
+ }
+
+ /* each stack */
+ for (i=0; i<stacks+1; i++ )
+ {
+ for (j=0; j<slices; j++, idx+=3)
+ {
+ (*vertices)[idx ] = cost[j]*radf;
+ (*vertices)[idx+1] = sint[j]*radf;
+ (*vertices)[idx+2] = z;
+ (*normals )[idx ] = cost[j];
+ (*normals )[idx+1] = sint[j];
+ (*normals )[idx+2] = 0.f;
+ }
+
+ z += zStep;
+ }
+
+ /* other on bottom (get normals right) */
+ z -= zStep;
+ for (j=0; j<slices; j++, idx+=3)
+ {
+ (*vertices)[idx ] = cost[j]*radf;
+ (*vertices)[idx+1] = sint[j]*radf;
+ (*vertices)[idx+2] = z;
+ (*normals )[idx ] = 0.f;
+ (*normals )[idx+1] = 0.f;
+ (*normals )[idx+2] = 1.f;
+ }
+
+ /* bottom */
+ (*vertices)[idx ] = 0.f;
+ (*vertices)[idx+1] = 0.f;
+ (*vertices)[idx+2] = height;
+ (*normals )[idx ] = 0.f;
+ (*normals )[idx+1] = 0.f;
+ (*normals )[idx+2] = 1.f;
+
+ /* Release sin and cos tables */
+ free(sint);
+ free(cost);
+}
+
+void fghGenerateTorus(
+ double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings, /* input */
+ GLfloat **vertices, GLfloat **normals, int* nVert /* output */
+ )
+{
+ GLfloat iradius = (float)dInnerRadius;
+ GLfloat oradius = (float)dOuterRadius;
+ int i, j;
+
+ /* Pre-computed circle */
+ GLfloat *spsi, *cpsi;
+ GLfloat *sphi, *cphi;
+
+ /* number of unique vertices */
+ if (nSides<2 || nRings<2)
+ {
+ /* nothing to generate */
+ *nVert = 0;
+ return;
+ }
+ *nVert = nSides * nRings;
+
+ if ((*nVert) > 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<nRings; j++ )
+ {
+ for( i=0; i<nSides; i++ )
+ {
+ int offset = 3 * ( j * nSides + i ) ;
+
+ (*vertices)[offset ] = cpsi[j] * ( oradius + cphi[i] * iradius ) ;
+ (*vertices)[offset+1] = spsi[j] * ( oradius + cphi[i] * iradius ) ;
+ (*vertices)[offset+2] = sphi[i] * iradius ;
+ (*normals )[offset ] = cpsi[j] * cphi[i] ;
+ (*normals )[offset+1] = spsi[j] * cphi[i] ;
+ (*normals )[offset+2] = sphi[i] ;
+ }
+ }
+
+ /* Release sin and cos tables */
+ free(spsi);
+ free(cpsi);
+ free(sphi);
+ free(cphi);
+}
/* -- INTERNAL DRAWING functions --------------------------------------- */
#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\
if (useWireMode)\
{\
fghDrawGeometryWire (name##_verts,name##_norms,\
- nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\
+ 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); \
+ nameCaps##_VERT_PER_OBJ, 1, nameCaps##_VERT_PER_OBJ_TRI); \
}\
}
#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL)
if (useWireMode)
fghDrawGeometryWire(vertices, cube_norms,
- CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE);
+ 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);
+ CUBE_VERT_PER_OBJ, 1, CUBE_VERT_PER_OBJ_TRI);
if (dSize!=1.f)
/* cleanup allocated memory */
/* Draw and cleanup */
if (useWireMode)
- fghDrawGeometryWire (vertices,normals,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE);
+ fghDrawGeometryWire (vertices,normals,
+ 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,1,0);
free(vertices);
free(normals );
}
-#ifndef GL_ES_VERSION_2_0
static void fghSphere( double radius, GLint slices, GLint stacks, GLboolean useWireMode )
{
int i,j,idx, nVert;
GLfloat *vertices, *normals;
- if (slices * stacks > 65535)
- fgWarning("fghSphere: too many slices or stacks requested, indices will wrap");
-
/* Generate vertices and normals */
fghGenerateSphere((GLfloat)radius,slices,stacks,&vertices,&normals,&nVert);
{
free(stackIdx);
free(sliceIdx);
- fgError("Failed to allocate memory in fghGenerateSphere");
+ fgError("Failed to allocate memory in fghSphere");
}
/* generate for each stack */
}
/* 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<slices; i++)
- glDrawElements(GL_LINE_STRIP,stacks+1,GL_UNSIGNED_SHORT,sliceIdx+i*(stacks+1));
- /*draw stacks*/
- for (i=0; i<stacks-1; i++)
- glDrawElements(GL_LINE_LOOP, slices,GL_UNSIGNED_SHORT,stackIdx+i*slices);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
-
+ fghDrawGeometryWire(vertices,normals,
+ sliceIdx,slices,stacks+1,GL_LINE_STRIP,
+ stackIdx,stacks-1,slices);
+
/* cleanup allocated memory */
free(sliceIdx);
free(stackIdx);
if (!(stripIdx))
{
free(stripIdx);
- fgError("Failed to allocate memory in fghGenerateSphere");
+ fgError("Failed to allocate memory in fghSphere");
}
/* top stack */
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw stacks*/
- for (i=0; i<stacks; i++)
- glDrawElements(GL_TRIANGLE_STRIP,(slices+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(slices+1)*2);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,stacks,(slices+1)*2);
/* cleanup allocated memory */
free(stripIdx);
int i,j,idx, nVert;
GLfloat *vertices, *normals;
- if (slices * stacks > 65535)
- fgWarning("fghCone: too many slices or stacks requested, indices will wrap");
-
/* Generate vertices and normals */
+ /* Note, (stacks+1)*slices vertices for side of object, slices+1 for top and bottom closures */
fghGenerateCone((GLfloat)base,(GLfloat)height,slices,stacks,&vertices,&normals,&nVert);
if (nVert==0)
* bunch for each slice.
*/
+ stackIdx = malloc(slices*stacks*sizeof(GLushort));
+ sliceIdx = malloc(slices*2 *sizeof(GLushort));
+ if (!(stackIdx) || !(sliceIdx))
+ {
+ free(stackIdx);
+ free(sliceIdx);
+ fgError("Failed to allocate memory in fghCone");
+ }
+
+ /* generate for each stack */
+ for (i=0,idx=0; i<stacks; i++)
+ {
+ GLushort offset = 1+(i+1)*slices; /* start at 1 (0 is top vertex), and we advance one stack down as we go along */
+ for (j=0; j<slices; j++, idx++)
+ {
+ stackIdx[idx] = offset+j;
+ }
+ }
+
+ /* generate for each slice */
+ for (i=0,idx=0; i<slices; i++)
+ {
+ GLushort offset = 1+i; /* start at 1 (0 is top vertex), and we advance one slice as we go along */
+ sliceIdx[idx++] = offset+slices;
+ sliceIdx[idx++] = offset+(stacks+1)*slices;
+ }
+
+ /* draw */
+ fghDrawGeometryWire(vertices,normals,
+ sliceIdx,1,slices*2,GL_LINES,
+ stackIdx,stacks,slices);
+
+ /* 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+1)*sizeof(GLushort)); /*stacks +1 because of closing off bottom */
+ if (!(stripIdx))
+ {
+ free(stripIdx);
+ fgError("Failed to allocate memory in fghCone");
+ }
+
+ /* top stack */
+ for (j=0, idx=0; j<slices; j++, idx+=2)
+ {
+ stripIdx[idx ] = 0;
+ stripIdx[idx+1] = j+1; /* 0 is top vertex, 1 is first for first stack */
+ }
+ stripIdx[idx ] = 0; /* repeat first slice's idx for closing off shape */
+ stripIdx[idx+1] = 1;
+ idx+=2;
+
+ /* middle stacks: */
+ /* Strip indices are relative to first index belonging to strip, NOT relative to first vertex/normal pair in array */
+ for (i=0; i<stacks; i++, idx+=2)
+ {
+ offset = 1+(i+1)*slices; /* triangle_strip indices start at 1 (0 is top vertex), and we advance one stack down as we go along */
+ for (j=0; j<slices; j++, idx+=2)
+ {
+ stripIdx[idx ] = offset+j;
+ stripIdx[idx+1] = offset+j+slices;
+ }
+ stripIdx[idx ] = offset; /* repeat first slice's idx for closing off shape */
+ stripIdx[idx+1] = offset+slices;
+ }
+
+ /* draw */
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,stacks+1,(slices+1)*2);
+
+ /* cleanup allocated memory */
+ free(stripIdx);
+ }
+
+ /* cleanup allocated memory */
+ free(vertices);
+ free(normals);
+}
+
+static void fghCylinder( double radius, double height, GLint slices, GLint stacks, GLboolean useWireMode )
+{
+ int i,j,idx, nVert;
+ GLfloat *vertices, *normals;
+
+ /* 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);
+
+ if (nVert==0)
+ /* nothing to draw */
+ return;
+
+ 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.
+ */
+
stackIdx = malloc(slices*(stacks+1)*sizeof(GLushort));
sliceIdx = malloc(slices*2 *sizeof(GLushort));
if (!(stackIdx) || !(sliceIdx))
{
free(stackIdx);
free(sliceIdx);
- fgError("Failed to allocate memory in fghGenerateCone");
+ fgError("Failed to allocate memory in fghCylinder");
}
/* generate for each stack */
for (i=0,idx=0; i<stacks+1; i++)
{
- GLushort offset = 1+i*slices; /* start at 1 (0 is top vertex), and we advance one stack down as we go along */
+ GLushort offset = 1+(i+1)*slices; /* start at 1 (0 is top vertex), and we advance one stack down as we go along */
for (j=0; j<slices; j++, idx++)
{
stackIdx[idx] = offset+j;
for (i=0,idx=0; i<slices; i++)
{
GLushort offset = 1+i; /* start at 1 (0 is top vertex), and we advance one slice as we go along */
- sliceIdx[idx++] = offset;
- sliceIdx[idx++] = offset+stacks*slices;
+ sliceIdx[idx++] = offset+slices;
+ sliceIdx[idx++] = offset+(stacks+1)*slices;
}
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw slices*/
- glDrawElements(GL_LINES,slices*2,GL_UNSIGNED_SHORT,sliceIdx);
- /*draw stacks*/
- for (i=0; i<stacks; i++)
- glDrawElements(GL_LINE_LOOP, slices,GL_UNSIGNED_SHORT,stackIdx+i*slices);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometryWire(vertices,normals,
+ sliceIdx,1,slices*2,GL_LINES,
+ stackIdx,stacks+1,slices);
/* cleanup allocated memory */
free(sliceIdx);
GLushort offset;
/* Allocate buffers for indices, bail out if memory allocation fails */
- stripIdx = malloc((slices+1)*2*(stacks+1)*sizeof(GLushort));
+ stripIdx = malloc((slices+1)*2*(stacks+2)*sizeof(GLushort)); /*stacks +2 because of closing off bottom and top */
if (!(stripIdx))
{
free(stripIdx);
- fgError("Failed to allocate memory in fghGenerateCone");
+ fgError("Failed to allocate memory in fghCylinder");
}
/* top stack */
/* Strip indices are relative to first index belonging to strip, NOT relative to first vertex/normal pair in array */
for (i=0; i<stacks; i++, idx+=2)
{
- offset = 1+i*slices; /* triangle_strip indices start at 1 (0 is top vertex), and we advance one stack down as we go along */
+ offset = 1+(i+1)*slices; /* triangle_strip indices start at 1 (0 is top vertex), and we advance one stack down as we go along */
for (j=0; j<slices; j++, idx+=2)
{
stripIdx[idx ] = offset+j;
stripIdx[idx+1] = offset+slices;
}
+ /* top stack */
+ offset = 1+(stacks+2)*slices;
+ for (j=0; j<slices; j++, idx+=2)
+ {
+ stripIdx[idx ] = offset+j;
+ stripIdx[idx+1] = nVert-1; /* zero based index, last element in array (bottom vertex)... */
+ }
+ stripIdx[idx ] = offset;
+ stripIdx[idx+1] = nVert-1; /* repeat first slice's idx for closing off shape */
+
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,stacks+2,(slices+1)*2);
+
+ /* cleanup allocated memory */
+ free(stripIdx);
+ }
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw stacks*/
- for (i=0; i<stacks+1; i++)
- glDrawElements(GL_TRIANGLE_STRIP,(slices+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(slices+1)*2);
+ /* cleanup allocated memory */
+ free(vertices);
+ free(normals);
+}
+
+static void fghTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings, GLboolean useWireMode )
+{
+ int i,j,idx, nVert;
+ GLfloat *vertices, *normals;
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ /* Generate vertices and normals */
+ fghGenerateTorus((GLfloat)dInnerRadius,(GLfloat)dOuterRadius,nSides,nRings, &vertices,&normals,&nVert);
+
+ if (nVert==0)
+ /* nothing to draw */
+ return;
+
+ 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.
+ */
+
+ 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");
+ }
+
+ /* generate for each ring */
+ for( j=0,idx=0; j<nRings; j++ )
+ for( i=0; i<nSides; i++, idx++ )
+ ringIdx[idx] = j * nSides + i;
+
+ /* generate for each side */
+ for( i=0,idx=0; i<nSides; i++ )
+ for( j=0; j<nRings; j++, idx++ )
+ sideIdx[idx] = j * nSides + i;
+
+ /* draw */
+ fghDrawGeometryWire(vertices,normals,
+ ringIdx,nRings,nSides,GL_LINE_LOOP,
+ sideIdx,nSides,nRings);
+
+ /* cleanup allocated memory */
+ free(sideIdx);
+ free(ringIdx);
+ }
+ else
+ {
+ /* First, generate vertex index arrays for drawing with glDrawElements
+ * All stacks, including top and bottom are covered with a triangle
+ * strip.
+ */
+ GLushort *stripIdx;
+
+ /* Allocate buffers for indices, bail out if memory allocation fails */
+ stripIdx = malloc((nRings+1)*2*nSides*sizeof(GLushort));
+ if (!(stripIdx))
+ {
+ free(stripIdx);
+ fgError("Failed to allocate memory in fghTorus");
+ }
+
+ for( i=0, idx=0; i<nSides; i++ )
+ {
+ int ioff = 1;
+ if (i==nSides-1)
+ ioff = -i;
+
+ for( j=0; j<nRings; j++, idx+=2 )
+ {
+ int offset = j * nSides + i;
+ stripIdx[idx ] = offset;
+ stripIdx[idx+1] = offset + ioff;
+ }
+ /* repeat first to close off shape */
+ stripIdx[idx ] = i;
+ stripIdx[idx+1] = i + ioff;
+ idx +=2;
+ }
+
+ /* draw */
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,nSides,(nRings+1)*2);
/* cleanup allocated memory */
free(stripIdx);
fghSphere( radius, slices, stacks, TRUE );
}
-#endif /* GL_ES_VERSION_2_0 */
-#ifndef EGL_VERSION_1_0
/*
* Draws a solid cone
*/
*/
void FGAPIENTRY glutSolidCylinder(double radius, double height, GLint slices, GLint stacks)
{
- int i,j;
-
- /* Step in z and radius as stacks are drawn. */
- GLfloat radf = (GLfloat)radius;
- GLfloat z0,z1;
- const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
-
- /* Pre-computed circle */
-
- GLfloat *sint,*cost;
-
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
- fghCircleTable(&sint,&cost,-slices,FALSE);
-
- /* Cover the base and top */
-
- 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();
-
- glBegin(GL_TRIANGLE_FAN);
- glNormal3f(0, 0, 1 );
- glVertex3f(0, 0, (GLfloat)height);
- for (j=slices; j>=0; j--)
- glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height);
- glEnd();
-
- /* Do the stacks */
-
- z0 = 0;
- z1 = zStep;
-
- for (i=1; i<=stacks; i++)
- {
- if (i==stacks)
- z1 = (GLfloat)height;
-
- glBegin(GL_TRIANGLE_STRIP);
- for (j=0; j<=slices; j++ )
- {
- glNormal3f(cost[j], sint[j], 0 );
- glVertex3f(cost[j]*radf, sint[j]*radf, z0 );
- glVertex3f(cost[j]*radf, sint[j]*radf, z1 );
- }
- glEnd();
-
- z0 = z1; z1 += zStep;
- }
-
- /* Release sin and cos tables */
-
- free(sint);
- free(cost);
+ fghCylinder( radius, height, slices, stacks, FALSE );
}
/*
*/
void FGAPIENTRY glutWireCylinder(double radius, double height, GLint slices, GLint stacks)
{
- int i,j;
-
- /* Step in z and radius as stacks are drawn. */
- GLfloat radf = (GLfloat)radius;
- GLfloat z = 0;
- const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
-
- /* Pre-computed circle */
-
- GLfloat *sint,*cost;
-
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
- fghCircleTable(&sint,&cost,-slices,FALSE);
-
- /* Draw the stacks... */
-
- for (i=0; i<=stacks; i++)
- {
- if (i==stacks)
- z = (GLfloat)height;
-
- glBegin(GL_LINE_LOOP);
-
- for( j=0; j<slices; j++ )
- {
- glNormal3f(cost[j], sint[j], 0);
- glVertex3f(cost[j]*radf, sint[j]*radf, z);
- }
-
- glEnd();
-
- z += zStep;
- }
-
- /* Draw the slices */
-
- glBegin(GL_LINES);
-
- for (j=0; j<slices; j++)
- {
- glNormal3f(cost[j], sint[j], 0 );
- glVertex3f(cost[j]*radf, sint[j]*radf, 0 );
- glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height);
- }
-
- glEnd();
-
- /* Release sin and cos tables */
-
- free(sint);
- free(cost);
+ fghCylinder( radius, height, slices, stacks, TRUE );
}
/*
*/
void FGAPIENTRY glutWireTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
{
- GLfloat iradius = (float)dInnerRadius, oradius = (float)dOuterRadius;
- GLfloat phi, psi, dpsi, dphi;
- GLfloat *vertex, *normal;
- int i, j;
- GLfloat spsi, cpsi, sphi, cphi ;
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
-
- if ( nSides < 1 ) nSides = 1;
- if ( nRings < 1 ) nRings = 1;
-
- /* Allocate the vertices array */
- vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
- normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
-
- glPushMatrix();
-
- dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings) ;
- dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides) ;
- psi = 0.0f;
-
- for( j=0; j<nRings; j++ )
- {
-#ifdef __cplusplus
- cpsi = cosf( psi ) ;
- spsi = sinf( psi ) ;
-#else
- cpsi = (float)cos( (double)psi ) ;
- spsi = (float)sin( (double)psi ) ;
-#endif /* __cplusplus */
- phi = 0.0f;
-
- for( i=0; i<nSides; i++ )
- {
- int offset = 3 * ( j * nSides + i ) ;
-#ifdef __cplusplus
- cphi = cosf( phi ) ;
- sphi = sinf( phi ) ;
-#else
- cphi = (float)cos( (double)phi ) ;
- sphi = (float)sin( (double)phi ) ;
-#endif /* __cplusplus */
- *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
- *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
- *(vertex + offset + 2) = sphi * iradius ;
- *(normal + offset + 0) = cpsi * cphi ;
- *(normal + offset + 1) = spsi * cphi ;
- *(normal + offset + 2) = sphi ;
- phi += dphi;
- }
-
- psi += dpsi;
- }
-
- for( i=0; i<nSides; i++ )
- {
- glBegin( GL_LINE_LOOP );
-
- for( j=0; j<nRings; j++ )
- {
- int offset = 3 * ( j * nSides + i ) ;
- glNormal3fv( normal + offset );
- glVertex3fv( vertex + offset );
- }
-
- glEnd();
- }
-
- for( j=0; j<nRings; j++ )
- {
- glBegin(GL_LINE_LOOP);
-
- for( i=0; i<nSides; i++ )
- {
- int offset = 3 * ( j * nSides + i ) ;
- glNormal3fv( normal + offset );
- glVertex3fv( vertex + offset );
- }
-
- glEnd();
- }
-
- free ( vertex ) ;
- free ( normal ) ;
- glPopMatrix();
+ fghTorus(dInnerRadius, dOuterRadius, nSides, nRings, TRUE);
}
/*
*/
void FGAPIENTRY glutSolidTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
{
- GLfloat iradius = (float)dInnerRadius, oradius = (float)dOuterRadius;
- GLfloat phi, psi, dpsi, dphi;
- GLfloat *vertex, *normal;
- int i, j;
- GLfloat spsi, cpsi, sphi, cphi ;
-
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );
-
- if ( nSides < 1 ) nSides = 1;
- if ( nRings < 1 ) nRings = 1;
-
- /* Increment the number of sides and rings to allow for one more point than surface */
- nSides ++ ;
- nRings ++ ;
-
- /* Allocate the vertices array */
- vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
- normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
-
- glPushMatrix();
-
- dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings - 1) ;
- dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides - 1) ;
- psi = 0.0f;
-
- for( j=0; j<nRings; j++ )
- {
-#ifdef __cplusplus
- cpsi = cosf( psi ) ;
- spsi = sinf( psi ) ;
-#else
- cpsi = (float)cos( (double)psi ) ;
- spsi = (float)sin( (double)psi ) ;
-#endif /* __cplusplus */
- phi = 0.0f;
-
- for( i=0; i<nSides; i++ )
- {
- int offset = 3 * ( j * nSides + i ) ;
-#ifdef __cplusplus
- cphi = cosf( phi ) ;
- sphi = sinf( phi ) ;
-#else
- cphi = (float)cos( (double)phi ) ;
- sphi = (float)sin( (double)phi ) ;
-#endif /* __cplusplus */
- *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
- *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
- *(vertex + offset + 2) = sphi * iradius ;
- *(normal + offset + 0) = cpsi * cphi ;
- *(normal + offset + 1) = spsi * cphi ;
- *(normal + offset + 2) = sphi ;
- phi += dphi;
- }
-
- psi += dpsi;
- }
-
- glBegin( GL_QUADS );
- for( i=0; i<nSides-1; i++ )
- {
- for( j=0; j<nRings-1; j++ )
- {
- int offset = 3 * ( j * nSides + i ) ;
- glNormal3fv( normal + offset );
- glVertex3fv( vertex + offset );
- glNormal3fv( normal + offset + 3 );
- glVertex3fv( vertex + offset + 3 );
- glNormal3fv( normal + offset + 3 * nSides + 3 );
- glVertex3fv( vertex + offset + 3 * nSides + 3 );
- glNormal3fv( normal + offset + 3 * nSides );
- glVertex3fv( vertex + offset + 3 * nSides );
- }
- }
-
- glEnd();
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );
- free ( vertex ) ;
- free ( normal ) ;
- glPopMatrix();
+ fghTorus(dInnerRadius, dOuterRadius, nSides, nRings, FALSE);
}
-#endif /* EGL_VERSION_1_0 */