fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, 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);
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);
free(sint2);
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<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++ )
+ {
+ 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 ] = cost[j]*sinn;
+ (*normals )[idx+1] = sint[j]*sinn;
+ (*normals )[idx+2] = cosn;
+ }
+
+ z += zStep;
+ r -= rStep;
+ }
+
+ /* Release sin and cos tables */
+ free(sint);
+ free(cost);
+}
+
+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);
+}
#endif
/* -- INTERNAL DRAWING functions --------------------------------------- */
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);
sliceIdx = malloc(slices*(stacks+1)*sizeof(GLushort));
stackIdx = malloc(slices*(stacks-1)*sizeof(GLushort));
-
- /* generate for each stack */
- for (i=0,idx=0; i<slices; i++)
+ if (!(stackIdx) || !(sliceIdx))
{
- GLushort offset = 1+i; /* start at 1 (0 is top vertex), and we advance one slice as we go along */
- sliceIdx[idx++] = 0; /* vertex on top */
- for (j=0; j<stacks-1; j++, idx++)
- {
- sliceIdx[idx] = offset+j*slices;
- }
- sliceIdx[idx++] = nVert-1; /* zero based index, last element in array... */
+ free(stackIdx);
+ free(sliceIdx);
+ fgError("Failed to allocate memory in fghSphere");
}
/* generate for each stack */
}
}
+ /* 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++] = 0; /* vertex on top */
+ for (j=0; j<stacks-1; j++, idx++)
+ {
+ sliceIdx[idx] = offset+j*slices;
+ }
+ sliceIdx[idx++] = nVert-1; /* zero based index, last element in array... */
+ }
+
/* draw */
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
if (!(stripIdx))
{
free(stripIdx);
- fgError("Failed to allocate memory in fghGenerateSphere");
+ fgError("Failed to allocate memory in fghSphere");
}
/* top stack */
free(normals);
}
-
-
-/* -- INTERFACE FUNCTIONS ---------------------------------------------- */
-
-
-/*
- * Draws a solid sphere
- */
-void FGAPIENTRY glutSolidSphere(double radius, GLint slices, GLint stacks)
-{
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );
-
- fghSphere( radius, slices, stacks, FALSE );
-}
-
-/*
- * Draws a wire sphere
- */
-void FGAPIENTRY glutWireSphere(double radius, GLint slices, GLint stacks)
+static void fghCone( double base, double height, GLint slices, GLint stacks, GLboolean useWireMode )
{
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
-
- fghSphere( radius, slices, stacks, TRUE );
-
-}
-#endif /* GL_ES_VERSION_2_0 */
+ int i,j,idx, nVert;
+ GLfloat *vertices, *normals;
-#ifndef EGL_VERSION_1_0
-/*
- * Draws a solid cone
- */
-void FGAPIENTRY glutSolidCone( double base, double height, GLint slices, GLint stacks )
-{
- int i,j;
+ /* 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);
- /* Step in z and radius as stacks are drawn. */
+ if (nVert==0)
+ /* nothing to draw */
+ return;
- GLfloat z0,z1;
- GLfloat r0,r1;
+ 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.
+ */
- const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
- const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 );
+ 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");
+ }
- /* Scaling factors for vertex normals */
+ /* 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;
+ }
+ }
-#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 */
+ /* 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;
+ }
- /* Pre-computed circle */
+ /* draw */
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- GLfloat *sint,*cost;
+ 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);
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
- fghCircleTable(&sint,&cost,-slices,FALSE);
-
- /* Cover the circular base with a triangle fan... */
-
- z0 = 0;
- z1 = zStep;
-
- r0 = (GLfloat)base;
- r1 = r0 - rStep;
-
- glBegin(GL_TRIANGLE_FAN);
-
- glNormal3f(0,0,-1);
- glVertex3f(0,0, z0 );
-
- for (j=0; j<=slices; j++)
- glVertex3f(cost[j]*r0, sint[j]*r0, z0);
+ /* 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;
- glEnd();
+ /* 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");
+ }
- /* Cover each stack with a triangle strip */
- for( i=0; i<stacks; i++ )
- {
- glBegin(GL_TRIANGLE_STRIP);
+ /* 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;
- for(j=0; j<=slices; j++)
+ /* 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)
{
- glNormal3f(cost[j]*cosn, sint[j]*cosn, sinn);
- glVertex3f(cost[j]*r0, sint[j]*r0, z0 );
- glVertex3f(cost[j]*r1, sint[j]*r1, z1 );
+ 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;
+ }
- z0 = z1; z1 += zStep;
- r0 = r1; r1 -= rStep;
+ /* draw */
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- glEnd();
- }
+ 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);
- /* Release sin and cos tables */
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
- free(sint);
- free(cost);
+ /* cleanup allocated memory */
+ free(stripIdx);
+ }
+
+ /* cleanup allocated memory */
+ free(vertices);
+ free(normals);
}
-/*
- * Draws a wire cone
- */
-void FGAPIENTRY glutWireCone( double base, double height, GLint slices, GLint stacks)
+static void fghCylinder( double radius, double height, GLint slices, GLint stacks, GLboolean useWireMode )
{
- int i,j;
-
- /* 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 */
-
- /* 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<stacks; i++)
+ if (useWireMode)
{
- glBegin(GL_LINE_LOOP);
+ 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 fghCylinder");
+ }
- for( j=0; j<slices; j++ )
+ /* generate for each stack */
+ for (i=0,idx=0; i<stacks+1; 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++)
{
- glNormal3f(cost[j]*sinn, sint[j]*sinn, cosn);
- glVertex3f(cost[j]*r, sint[j]*r, z );
+ stackIdx[idx] = offset+j;
}
+ }
- glEnd();
+ /* 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;
+ }
- z += zStep;
- r -= rStep;
- }
+ /* draw */
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- /* Draw the slices */
+ 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+1; i++)
+ glDrawElements(GL_LINE_LOOP, slices,GL_UNSIGNED_SHORT,stackIdx+i*slices);
- r = (GLfloat)base;
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
- glBegin(GL_LINES);
+ /* 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;
- for (j=0; j<slices; j++)
+ /* Allocate buffers for indices, bail out if memory allocation fails */
+ stripIdx = malloc((slices+1)*2*(stacks+2)*sizeof(GLushort)); /*stacks +2 because of closing off bottom and top */
+ if (!(stripIdx))
{
- glNormal3f(cost[j]*sinn, sint[j]*sinn, cosn );
- glVertex3f(cost[j]*r, sint[j]*r, 0 );
- glVertex3f(0, 0, (GLfloat)height);
+ free(stripIdx);
+ fgError("Failed to allocate memory in fghCylinder");
}
- glEnd();
-
- /* Release sin and cos tables */
-
- free(sint);
- free(cost);
-}
-
-
-/*
- * Draws a solid cylinder
- */
-void FGAPIENTRY glutSolidCylinder(double radius, double height, GLint slices, GLint stacks)
-{
- int i,j;
+ /* 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;
- /* 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 );
+ /* 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;
+ }
- /* Pre-computed circle */
+ /* 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 */
- GLfloat *sint,*cost;
+ /* draw */
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
+ glVertexPointer(3, GL_FLOAT, 0, vertices);
+ glNormalPointer(GL_FLOAT, 0, normals);
+ /*draw stacks*/
+ for (i=0; i<stacks+2; i++)
+ glDrawElements(GL_TRIANGLE_STRIP,(slices+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(slices+1)*2);
- fghCircleTable(&sint,&cost,-slices,FALSE);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
- /* Cover the base and top */
+ /* cleanup allocated memory */
+ free(stripIdx);
+ }
- 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();
+ /* cleanup allocated memory */
+ free(vertices);
+ free(normals);
+}
- 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();
+static void fghTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings, GLboolean useWireMode )
+{
+ int i,j,idx, nVert;
+ GLfloat *vertices, *normals;
- /* Do the stacks */
+ /* Generate vertices and normals */
+ fghGenerateTorus((GLfloat)dInnerRadius,(GLfloat)dOuterRadius,nSides,nRings, &vertices,&normals,&nVert);
- z0 = 0;
- z1 = zStep;
+ if (nVert==0)
+ /* nothing to draw */
+ return;
- for (i=1; i<=stacks; i++)
+ if (useWireMode)
{
- 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);
-}
-
-/*
- * Draws a wire cylinder
- */
-void FGAPIENTRY glutWireCylinder(double radius, double height, GLint slices, GLint stacks)
-{
- int i,j;
+ 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.
+ */
- /* 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 );
+ 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");
+ }
- /* Pre-computed circle */
+ /* generate for each ring */
+ for( j=0,idx=0; j<nRings; j++ )
+ for( i=0; i<nSides; i++, idx++ )
+ ringIdx[idx] = j * nSides + i;
- GLfloat *sint,*cost;
+ /* generate for each side */
+ for( i=0,idx=0; i<nSides; i++ )
+ for( j=0; j<nRings; j++, idx++ )
+ sideIdx[idx] = j * nSides + i;
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
+ /* draw */
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- fghCircleTable(&sint,&cost,-slices,FALSE);
+ glVertexPointer(3, GL_FLOAT, 0, vertices);
+ glNormalPointer(GL_FLOAT, 0, normals);
+ /*draw rings*/
+ for( i=0; i<nSides; i++ )
+ glDrawElements(GL_LINE_LOOP,nRings,GL_UNSIGNED_SHORT,ringIdx+i*nRings);
+ /*draw sides*/
+ for (i=0; i<nRings; i++)
+ glDrawElements(GL_LINE_LOOP,nSides,GL_UNSIGNED_SHORT,sideIdx+i*nSides);
- /* Draw the stacks... */
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
- for (i=0; i<=stacks; i++)
+ /* cleanup allocated memory */
+ free(sideIdx);
+ free(ringIdx);
+ }
+ else
{
- if (i==stacks)
- z = (GLfloat)height;
+ /* clearly, this branch is TODO */
+ /* First, generate vertex index arrays for drawing with glDrawElements
+ * All stacks, including top and bottom are covered with a triangle
+ * strip.
+ */
+ GLushort *stripIdx;
- glBegin(GL_LINE_LOOP);
+ /* 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( j=0; j<slices; j++ )
+ 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 )
{
- glNormal3f(cost[j], sint[j], 0);
- glVertex3f(cost[j]*radf, sint[j]*radf, z);
+ 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;
+ }
- glEnd();
+ /* draw */
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- z += zStep;
- }
+ glVertexPointer(3, GL_FLOAT, 0, vertices);
+ glNormalPointer(GL_FLOAT, 0, normals);
+ for (i=0; i<nSides; i++)
+ glDrawElements(GL_TRIANGLE_STRIP,(nRings+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(nRings+1)*2);
- /* Draw the slices */
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
- glBegin(GL_LINES);
+ /* cleanup allocated memory */
+ free(stripIdx);
+ }
- 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);
- }
+ /* cleanup allocated memory */
+ free(vertices);
+ free(normals);
+}
- glEnd();
- /* Release sin and cos tables */
+/* -- INTERFACE FUNCTIONS ---------------------------------------------- */
- free(sint);
- free(cost);
-}
/*
- * Draws a wire torus
+ * Draws a solid sphere
*/
-void FGAPIENTRY glutWireTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
+void FGAPIENTRY glutSolidSphere(double radius, GLint slices, GLint stacks)
{
- 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 ( "glutSolidSphere" );
- if ( nSides < 1 ) nSides = 1;
- if ( nRings < 1 ) nRings = 1;
+ fghSphere( radius, slices, stacks, FALSE );
+}
- /* Allocate the vertices array */
- vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
- normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
+/*
+ * Draws a wire sphere
+ */
+void FGAPIENTRY glutWireSphere(double radius, GLint slices, GLint stacks)
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
- glPushMatrix();
+ fghSphere( radius, slices, stacks, TRUE );
+
+}
+#endif /* GL_ES_VERSION_2_0 */
- dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings) ;
- dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides) ;
- psi = 0.0f;
+#ifndef EGL_VERSION_1_0
+/*
+ * Draws a solid cone
+ */
+void FGAPIENTRY glutSolidCone( double base, double height, GLint slices, GLint stacks )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );
- 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;
+ fghCone( base, height, slices, stacks, FALSE );
+}
- 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;
- }
+/*
+ * Draws a wire cone
+ */
+void FGAPIENTRY glutWireCone( double base, double height, GLint slices, GLint stacks)
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" );
- psi += dpsi;
- }
+ fghCone( base, height, slices, stacks, TRUE );
+}
- 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 );
- }
+/*
+ * Draws a solid cylinder
+ */
+void FGAPIENTRY glutSolidCylinder(double radius, double height, GLint slices, GLint stacks)
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
- glEnd();
- }
+ fghCylinder( radius, height, slices, stacks, FALSE );
+}
- for( j=0; j<nRings; j++ )
- {
- glBegin(GL_LINE_LOOP);
+/*
+ * Draws a wire cylinder
+ */
+void FGAPIENTRY glutWireCylinder(double radius, double height, GLint slices, GLint stacks)
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
- for( i=0; i<nSides; i++ )
- {
- int offset = 3 * ( j * nSides + i ) ;
- glNormal3fv( normal + offset );
- glVertex3fv( vertex + offset );
- }
+ fghCylinder( radius, height, slices, stacks, TRUE );
+}
- glEnd();
- }
+/*
+ * Draws a wire torus
+ */
+void FGAPIENTRY glutWireTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
- 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 */