#include "fg_internal.h"
/*
- *
* Need more types of polyhedra? See CPolyhedron in MRPT
- *
- * TODO BEFORE THE STABLE RELEASE:
- *
- * See fghTetrahedron
- *
- * Following functions have been contributed by Andreas Umbach.
- *
- * glutWireCube() -- looks OK
- * glutSolidCube() -- OK
- *
- * Those functions have been implemented by John Fay.
- *
- * glutWireTorus() -- looks OK
- * glutSolidTorus() -- looks OK
- * glutWireDodecahedron() -- looks OK
- * glutSolidDodecahedron() -- looks OK
- * glutWireOctahedron() -- looks OK
- * glutSolidOctahedron() -- looks OK
- * glutWireTetrahedron() -- looks OK
- * glutSolidTetrahedron() -- looks OK
- * glutWireIcosahedron() -- looks OK
- * glutSolidIcosahedron() -- looks OK
- *
- * The Following functions have been updated by Nigel Stewart, based
- * on FreeGLUT 2.0.0 implementations:
- *
- * glutWireSphere() -- looks OK
- * glutSolidSphere() -- looks OK
- * glutWireCone() -- looks OK
- * glutSolidCone() -- looks OK
*/
-/* General function for drawing geometry. As for all geometry we have no
- * redundancy (or hardly any in the case of cones and cylinders) in terms
- * of the vertex/normal combinations, we just use glDrawArrays.
- * useWireMode controls the drawing of solids (false) or wire frame
- * versions (TRUE) of the geometry you pass
+/* General functions for drawing geometry
+ * Solids are drawn by glDrawArrays if composed of triangles, or by
+ * glDrawElements if consisting of squares or pentagons that were
+ * decomposed into triangles (some vertices are repeated in that case).
+ * WireFrame drawing will have to be done per face, using GL_LINE_LOOP and
+ * issuing one draw call per face. Always use glDrawArrays as no triangle
+ * decomposition needed. We use the "first" parameter in glDrawArrays to go
+ * from face to face.
*/
-static void fghDrawGeometry(GLenum vertexMode, GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLboolean useWireMode)
+static void fghDrawGeometryWire(GLdouble *vertices, GLdouble *normals, GLsizei numFaces, GLsizei numEdgePerFace)
{
- if (useWireMode)
- {
- glPushAttrib(GL_POLYGON_BIT);
- glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
- glDisable(GL_CULL_FACE);
- }
+ int i;
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
- if (1)
- {
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
- if (edgeFlags)
- glEnableClientState(GL_EDGE_FLAG_ARRAY);
-
- glVertexPointer(3, GL_DOUBLE, 0, vertices);
- glNormalPointer(GL_DOUBLE, 0, normals);
- if (edgeFlags)
- glEdgeFlagPointer(0,edgeFlags);
- glDrawArrays(vertexMode, 0, numVertices);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
- if (edgeFlags)
- glDisableClientState(GL_EDGE_FLAG_ARRAY);
- }
+ glVertexPointer(3, GL_DOUBLE, 0, vertices);
+ glNormalPointer(GL_DOUBLE, 0, normals);
+
+ /* Draw per face (TODO: could use glMultiDrawArrays if available) */
+ for (i=0; i<numFaces; i++)
+ glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+}
+static void fghDrawGeometrySolid(GLdouble *vertices, GLdouble *normals, GLubyte *vertIdxs, GLsizei numVertices, GLsizei numEdgePerFace)
+{
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
+
+ glVertexPointer(3, GL_DOUBLE, 0, vertices);
+ glNormalPointer(GL_DOUBLE, 0, normals);
+ if (numEdgePerFace==3)
+ glDrawArrays(GL_TRIANGLES, 0, numVertices);
else
- {
- int i;
- glBegin(vertexMode);
- for(i=0; i<numVertices; i++)
- {
- glEdgeFlag(edgeFlags[i]);
- glNormal3dv(normals+i*3);
- printf("n(%i) = (%1.4f,%1.4f,%1.4f)\n",i,*(normals+i*3),*(normals+i*3+1),*(normals+i*3+2));
- glVertex3dv(vertices+i*3);
- printf("v(%i) = (%1.4f,%1.4f,%1.4f)\n",i,*(vertices+i*3),*(vertices+i*3+1),*(vertices+i*3+2));
- }
- glEnd();
- }
+ glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_BYTE, vertIdxs);
- if (useWireMode)
- {
- glPopAttrib();
- }
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
}
-/* triangle decomposition and associated edgeFlags
- * be careful to keep winding of all triangles counter-clockwise,
+/* 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.
+ * Be careful to keep winding of all triangles counter-clockwise,
* assuming that input has correct winding...
*/
-static GLubyte vertSamp3[3] = {0,1,2};
-static GLubyte vertSamp4[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */
-static GLubyte vertSamp5[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */
-static GLboolean edgeFlag3[3] = {1,1,1}; /* triangles remain triangles, all edges are external */
-static GLboolean edgeFlag4[6] = {1,1,0, 0,1,1};
-static GLboolean edgeFlag5[9] = {1,1,0, 0,0,1, 0,1,1};
-
-static void fghGenerateGeometryWithEdgeFlag(int numFaces, int numEdgePerFaceIn, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLboolean *edgeFlagsOut)
+static GLubyte vert4Decomp[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */
+static GLubyte vert5Decomp[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */
+
+static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLubyte *vertIdxOut)
{
- int i,j,numEdgePerFaceOut;
+ int i,j,numEdgeIdxPerFace;
GLubyte *vertSamps = NULL;
- GLboolean *edgeFlags = NULL;
- switch (numEdgePerFaceIn)
+ switch (numEdgePerFace)
{
case 3:
- vertSamps = vertSamp3;
- edgeFlags = edgeFlag3;
- numEdgePerFaceOut = 3; /* 3 output vertices for each face */
+ /* nothing to do here, we'll drawn with glDrawArrays */
break;
case 4:
- vertSamps = vertSamp4;
- edgeFlags = edgeFlag4;
- numEdgePerFaceOut = 6; /* 6 output vertices for each face */
+ vertSamps = vert4Decomp;
+ numEdgeIdxPerFace = 6; /* 6 output vertices for each face */
break;
case 5:
- vertSamps = vertSamp5;
- edgeFlags = edgeFlag5;
- numEdgePerFaceOut = 9; /* 9 output vertices for each face */
+ vertSamps = vert5Decomp;
+ numEdgeIdxPerFace = 9; /* 9 output vertices for each face */
break;
}
/*
- * Build array with vertices from vertex coordinates and vertex indices
+ * Build array with vertices using vertex coordinates and vertex indices
* Do same for normals.
- * Need to do this because of different normals at shared vertices
- * (and because normals' coordinates need to be negated).
+ * Need to do this because of different normals at shared vertices.
*/
for (i=0; i<numFaces; i++)
{
int normIdx = i*3;
- int faceIdxVertIdx = i*numEdgePerFaceIn; // index to first element of "row" in vertex indices
- for (j=0; j<numEdgePerFaceOut; j++)
+ int faceIdxVertIdx = i*numEdgePerFace; // index to first element of "row" in vertex indices
+ for (j=0; j<numEdgePerFace; j++)
{
- int outIdx = i*numEdgePerFaceOut*3+j*3;
- int vertIdx = vertIndices[faceIdxVertIdx+vertSamps[j]]*3;
+ int outIdx = i*numEdgePerFace*3+j*3;
+ int vertIdx = vertIndices[faceIdxVertIdx+j]*3;
vertOut[outIdx ] = vertices[vertIdx ];
vertOut[outIdx+1] = vertices[vertIdx+1];
normOut[outIdx ] = normals [normIdx ];
normOut[outIdx+1] = normals [normIdx+1];
normOut[outIdx+2] = normals [normIdx+2];
-
- if (edgeFlagsOut)
- edgeFlagsOut[i*numEdgePerFaceOut+j] = edgeFlags[j];
}
+
+ /* generate vertex indices for each face */
+ if (vertSamps)
+ for (j=0; j<numEdgeIdxPerFace; j++)
+ vertIdxOut[i*numEdgeIdxPerFace+j] = faceIdxVertIdx + vertSamps[j];
}
}
static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut)
{
- fghGenerateGeometryWithEdgeFlag(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL);
+ /* This function does the same as fghGenerateGeometryWithIndexArray, just skipping the index array generation... */
+ fghGenerateGeometryWithIndexArray(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL);
}
/* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */
/* -- stuff that can be cached -- */
-/* Cache of input to glDrawArrays */
+/* 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.
+ */
#define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\
static GLboolean name##Cached = FALSE;\
static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
static GLboolean name##Cached = FALSE;\
static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
static GLdouble name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\
- static GLboolean name##_edgeFlags[nameCaps##_VERT_PER_OBJ_TRI];\
+ static GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\
static void fgh##nameICaps##Generate()\
{\
- fghGenerateGeometryWithEdgeFlag(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
- name##_v, name##_vi, name##_n,\
- name##_verts, name##_norms, name##_edgeFlags);\
+ fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
+ name##_v, name##_vi, name##_n,\
+ name##_verts, name##_norms, name##_vertIdxs);\
}
-/*
- * 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.
- */
/* -- Cube -- */
#define CUBE_NUM_VERT 8
#define CUBE_NUM_FACES 6
#define CUBE_NUM_EDGE_PER_FACE 4
#define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES*CUBE_NUM_EDGE_PER_FACE)
+#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ*3)
#define CUBE_VERT_PER_OBJ_TRI (CUBE_VERT_PER_OBJ+CUBE_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */
-#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ_TRI*3)
/* Vertex Coordinates */
static GLdouble cube_v[CUBE_NUM_VERT*3] =
{
#define DODECAHEDRON_NUM_FACES 12
#define DODECAHEDRON_NUM_EDGE_PER_FACE 5
#define DODECAHEDRON_VERT_PER_OBJ (DODECAHEDRON_NUM_FACES*DODECAHEDRON_NUM_EDGE_PER_FACE)
+#define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ*3)
#define DODECAHEDRON_VERT_PER_OBJ_TRI (DODECAHEDRON_VERT_PER_OBJ+DODECAHEDRON_NUM_FACES*4) /* 4 extra edges per face when drawing pentagons as triangles */
-#define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ_TRI*3)
/* Vertex Coordinates */
static GLdouble dodecahedron_v[DODECAHEDRON_NUM_VERT*3] =
{
#define ICOSAHEDRON_NUM_FACES 20
#define ICOSAHEDRON_NUM_EDGE_PER_FACE 3
#define ICOSAHEDRON_VERT_PER_OBJ (ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE)
+#define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ*3)
#define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ
-#define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ_TRI*3)
/* Vertex Coordinates */
static GLdouble icosahedron_v[ICOSAHEDRON_NUM_VERT*3] =
{
#define OCTAHEDRON_NUM_FACES 8
#define OCTAHEDRON_NUM_EDGE_PER_FACE 3
#define OCTAHEDRON_VERT_PER_OBJ (OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE)
+#define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ*3)
#define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ
-#define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ_TRI*3)
/* Vertex Coordinates */
static GLdouble octahedron_v[OCTAHEDRON_NUM_VERT*3] =
#define RHOMBICDODECAHEDRON_NUM_FACES 12
#define RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE 4
#define RHOMBICDODECAHEDRON_VERT_PER_OBJ (RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE)
+#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ*3)
#define RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */
-#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI*3)
/* Vertex Coordinates */
static GLdouble rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] =
#define TETRAHEDRON_NUM_FACES 4
#define TETRAHEDRON_NUM_EDGE_PER_FACE 3
#define TETRAHEDRON_VERT_PER_OBJ (TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE)
+#define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ*3)
#define TETRAHEDRON_VERT_PER_OBJ_TRI TETRAHEDRON_VERT_PER_OBJ
-#define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ_TRI*3)
/* Vertex Coordinates */
static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] =
/* -- Now the various shapes involving circles -- */
/*
- * Compute lookup table of cos and sin values forming a cirle
+ * Compute lookup table of cos and sin values forming a circle
+ * (or half circle if halfCircle==TRUE)
*
* Notes:
* It is the responsibility of the caller to free these tables
* The last entry is exactly the same as the first
* The sign of n can be flipped to get the reverse loop
*/
-static void fghCircleTable(double **sint,double **cost,const int n)
+static void fghCircleTable(GLdouble **sint, GLdouble **cost, const int n, const GLboolean halfCircle)
{
int i;
-
+
/* Table size, the sign of n flips the circle direction */
-
const int size = abs(n);
/* Determine the angle between samples */
-
- const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n );
+ const GLdouble angle = (halfCircle?1:2)*M_PI/(GLdouble)( ( n == 0 ) ? 1 : n );
/* Allocate memory for n samples, plus duplicate of first entry at the end */
-
- *sint = (double *) calloc(sizeof(double), size+1);
- *cost = (double *) calloc(sizeof(double), size+1);
+ *sint = malloc(sizeof(GLdouble) * (size+1));
+ *cost = malloc(sizeof(GLdouble) * (size+1));
/* Bail out if memory allocation fails, fgError never returns */
-
if (!(*sint) || !(*cost))
{
free(*sint);
}
/* Compute cos and sin around the circle */
-
(*sint)[0] = 0.0;
(*cost)[0] = 1.0;
(*cost)[i] = cos(angle*i);
}
- /* Last sample is duplicate of the first */
-
- (*sint)[size] = (*sint)[0];
- (*cost)[size] = (*cost)[0];
+
+ if (halfCircle)
+ {
+ (*sint)[size] = 0.0; /* sin PI */
+ (*cost)[size] = -1.0; /* cos PI */
+ }
+ else
+ {
+ /* Last sample is duplicate of the first (sin or cos of 2 PI) */
+ (*sint)[size] = (*sint)[0];
+ (*cost)[size] = (*cost)[0];
+ }
}
/* -- INTERNAL DRAWING functions --------------------------------------- */
-#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,edgeFlags)\
+#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\
static void fgh##nameICaps( GLboolean useWireMode )\
{\
if (!name##Cached)\
fgh##nameICaps##Generate();\
name##Cached = GL_TRUE;\
}\
- fghDrawGeometry(GL_TRIANGLES,name##_verts,name##_norms,edgeFlags,nameCaps##_VERT_PER_OBJ_TRI,useWireMode);\
+ \
+ if (useWireMode)\
+ {\
+ fghDrawGeometryWire (name##_verts,name##_norms,\
+ nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\
+ }\
+ else\
+ {\
+ fghDrawGeometrySolid(name##_verts,name##_norms,vertIdxs,\
+ nameCaps##_VERT_PER_OBJ_TRI, nameCaps##_NUM_EDGE_PER_FACE);\
+ }\
}
-#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL)
-#define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_edgeFlags)
+#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL)
+#define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_vertIdxs)
static void fghCube( GLdouble dSize, GLboolean useWireMode )
{
+ GLdouble *vertices;
+
if (!cubeCached)
{
fghCubeGenerate();
if (dSize!=1.)
{
+ /* Need to build new vertex list containing vertices for cube of different size */
int i;
- /* Need to build new vertex list containing vertices for cube of different size */
- GLdouble *vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLdouble));
+ vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLdouble));
+
+ /* Bail out if memory allocation fails, fgError never returns */
+ if (!vertices)
+ {
+ free(vertices);
+ fgError("Failed to allocate memory in fghCube");
+ }
+
for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++)
vertices[i] = dSize*cube_verts[i];
-
- fghDrawGeometry(GL_TRIANGLES,vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode);
}
else
- fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode);
+ vertices = cube_verts;
+
+ if (useWireMode)
+ fghDrawGeometryWire (vertices,cube_norms, CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE);
+ else
+ fghDrawGeometrySolid(vertices,cube_norms,cube_vertIdxs,CUBE_VERT_PER_OBJ_TRI, CUBE_NUM_EDGE_PER_FACE);
+
+ if (dSize!=1.)
+ /* cleanup allocated memory */
+ free(vertices);
}
DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON);
GLdouble * normals;
GLsizei numTetr = numLevels<0? 0 : ipow(4,numLevels); /* No sponge for numLevels below 0 */
GLsizei numVert = numTetr*TETRAHEDRON_VERT_PER_OBJ;
+ GLsizei numFace = numTetr*TETRAHEDRON_NUM_FACES;
if (numTetr)
{
/* Allocate memory */
vertices = malloc(numVert*3 * sizeof(GLdouble));
normals = malloc(numVert*3 * sizeof(GLdouble));
+ /* Bail out if memory allocation fails, fgError never returns */
+ if (!vertices || !normals)
+ {
+ free(vertices);
+ free(normals);
+ fgError("Failed to allocate memory in fghSierpinskiSponge");
+ }
/* Generate elements */
fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals );
/* Draw and cleanup */
- fghDrawGeometry(GL_TRIANGLES,vertices,normals,NULL,numVert,useWireMode);
+ if (useWireMode)
+ fghDrawGeometryWire (vertices,normals, numFace,TETRAHEDRON_NUM_EDGE_PER_FACE);
+ else
+ fghDrawGeometrySolid(vertices,normals,NULL,numVert, TETRAHEDRON_NUM_EDGE_PER_FACE);
+
free(vertices);
free(normals );
}
/* Adjust z and radius as stacks are drawn. */
- double z0,z1;
- double r0,r1;
+ GLdouble z0,z1;
+ GLdouble r0,r1;
/* Pre-computed circle */
- double *sint1,*cost1;
- double *sint2,*cost2;
+ GLdouble *sint1,*cost1;
+ GLdouble *sint2,*cost2;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );
- fghCircleTable(&sint1,&cost1,-slices);
- fghCircleTable(&sint2,&cost2,stacks*2);
+ fghCircleTable(&sint1,&cost1,-slices,FALSE);
+ fghCircleTable(&sint2,&cost2, stacks,TRUE);
/* The top stack is covered with a triangle fan */
/* Adjust z and radius as stacks and slices are drawn. */
- double r;
- double x,y,z;
+ GLdouble r;
+ GLdouble x,y,z;
/* Pre-computed circle */
- double *sint1,*cost1;
- double *sint2,*cost2;
+ GLdouble *sint1,*cost1;
+ GLdouble *sint2,*cost2;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
- fghCircleTable(&sint1,&cost1,-slices );
- fghCircleTable(&sint2,&cost2, stacks*2);
+ fghCircleTable(&sint1,&cost1,-slices,FALSE);
+ fghCircleTable(&sint2,&cost2, stacks,TRUE);
/* Draw a line loop for each stack */
x = cost1[i]*sint2[j];
y = sint1[i]*sint2[j];
z = cost2[j];
+ printf("j(%i):%1.3f\n",j,z);
glNormal3d(x,y,z);
glVertex3d(x*radius,y*radius,z*radius);
/* Step in z and radius as stacks are drawn. */
- double z0,z1;
- double r0,r1;
+ GLdouble z0,z1;
+ GLdouble r0,r1;
- const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
- const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
+ const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+ const GLdouble rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
/* Scaling factors for vertex normals */
- const double cosn = ( height / sqrt ( height * height + base * base ));
- const double sinn = ( base / sqrt ( height * height + base * base ));
+ const GLdouble cosn = ( height / sqrt ( height * height + base * base ));
+ const GLdouble sinn = ( base / sqrt ( height * height + base * base ));
/* Pre-computed circle */
- double *sint,*cost;
+ GLdouble *sint,*cost;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );
- fghCircleTable(&sint,&cost,-slices);
+ fghCircleTable(&sint,&cost,-slices,FALSE);
/* Cover the circular base with a triangle fan... */
/* Step in z and radius as stacks are drawn. */
- double z = 0.0;
- double r = base;
+ GLdouble z = 0.0;
+ GLdouble r = base;
- const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
- const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
+ const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+ const GLdouble rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
/* Scaling factors for vertex normals */
- const double cosn = ( height / sqrt ( height * height + base * base ));
- const double sinn = ( base / sqrt ( height * height + base * base ));
+ const GLdouble cosn = ( height / sqrt ( height * height + base * base ));
+ const GLdouble sinn = ( base / sqrt ( height * height + base * base ));
/* Pre-computed circle */
- double *sint,*cost;
+ GLdouble *sint,*cost;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" );
- fghCircleTable(&sint,&cost,-slices);
+ fghCircleTable(&sint,&cost,-slices,FALSE);
/* Draw the stacks... */
/* Step in z and radius as stacks are drawn. */
- double z0,z1;
- const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+ GLdouble z0,z1;
+ const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
/* Pre-computed circle */
- double *sint,*cost;
+ GLdouble *sint,*cost;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
- fghCircleTable(&sint,&cost,-slices);
+ fghCircleTable(&sint,&cost,-slices,FALSE);
/* Cover the base and top */
/* Step in z and radius as stacks are drawn. */
- double z = 0.0;
- const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+ GLdouble z = 0.0;
+ const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
/* Pre-computed circle */
- double *sint,*cost;
+ GLdouble *sint,*cost;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
- fghCircleTable(&sint,&cost,-slices);
+ fghCircleTable(&sint,&cost,-slices,FALSE);
/* Draw the stacks... */
*/
void FGAPIENTRY glutWireTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings )
{
- double iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
- double *vertex, *normal;
+ GLdouble iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
+ GLdouble *vertex, *normal;
int i, j;
- double spsi, cpsi, sphi, cphi ;
+ GLdouble spsi, cpsi, sphi, cphi ;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
if ( nRings < 1 ) nRings = 1;
/* Allocate the vertices array */
- vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );
- normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );
+ vertex = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings );
+ normal = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings );
glPushMatrix();
- dpsi = 2.0 * M_PI / (double)nRings ;
- dphi = -2.0 * M_PI / (double)nSides ;
+ dpsi = 2.0 * M_PI / (GLdouble)nRings ;
+ dphi = -2.0 * M_PI / (GLdouble)nSides ;
psi = 0.0;
for( j=0; j<nRings; j++ )
*/
void FGAPIENTRY glutSolidTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings )
{
- double iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
- double *vertex, *normal;
+ GLdouble iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
+ GLdouble *vertex, *normal;
int i, j;
- double spsi, cpsi, sphi, cphi ;
+ GLdouble spsi, cpsi, sphi, cphi ;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );
nRings ++ ;
/* Allocate the vertices array */
- vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );
- normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );
+ vertex = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings );
+ normal = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings );
glPushMatrix();
- dpsi = 2.0 * M_PI / (double)(nRings - 1) ;
- dphi = -2.0 * M_PI / (double)(nSides - 1) ;
+ dpsi = 2.0 * M_PI / (GLdouble)(nRings - 1) ;
+ dphi = -2.0 * M_PI / (GLdouble)(nSides - 1) ;
psi = 0.0;
for( j=0; j<nRings; j++ )