X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=4d5d40630887987068eec24484f175656b20e5bb;hb=759436698a49b7a734325735c57ffcdffa2f4379;hp=de1cbadae2e27c1d4e847042e8146c6c06fc7052;hpb=1b5ee849ba61b667aeba474a7e03406196478bee;p=freeglut

diff --git a/src/fg_geometry.c b/src/fg_geometry.c
index de1cbad..4d5d406 100644
--- a/src/fg_geometry.c
+++ b/src/fg_geometry.c
@@ -31,6 +31,8 @@
 /*
  * TODO BEFORE THE STABLE RELEASE:
  *
+ * See fghTetrahedron
+ *
  * Following functions have been contributed by Andreas Umbach.
  *
  *      glutWireCube()          -- looks OK
@@ -59,58 +61,278 @@
  */
 
 
-/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
-
-/*
- * Draws a wireframed cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
+/* 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
  */
-void FGAPIENTRY glutWireCube( GLdouble dSize )
+static void fghDrawGeometry(GLenum vertexMode, GLdouble* vertices, GLdouble* normals, GLsizei numVertices, GLboolean useWireMode)
 {
-    double size = dSize * 0.5;
+    if (useWireMode)
+    {
+        glPushAttrib(GL_POLYGON_BIT);
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    }
 
-    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
+    if (1)
+    {
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glEnableClientState(GL_NORMAL_ARRAY);
 
-#   define V(a,b,c) glVertex3d( a size, b size, c size );
-#   define N(a,b,c) glNormal3d( a, b, c );
+        glVertexPointer(3, GL_DOUBLE, 0, vertices);
+        glNormalPointer(GL_DOUBLE, 0, normals);
+        glDrawArrays(vertexMode, 0, numVertices);
 
-    /* PWO: I dared to convert the code to use macros... */
-    glBegin( GL_LINE_LOOP ); N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); glEnd();
-    glBegin( GL_LINE_LOOP ); N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); glEnd();
-    glBegin( GL_LINE_LOOP ); N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); glEnd();
-    glBegin( GL_LINE_LOOP ); N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); glEnd();
-    glBegin( GL_LINE_LOOP ); N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); glEnd();
-    glBegin( GL_LINE_LOOP ); N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); glEnd();
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glDisableClientState(GL_NORMAL_ARRAY);
+    }
+    else
+    {
+        int i;
+        glBegin(vertexMode);
+            for(i=0; i<numVertices; 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();
+    }
 
-#   undef V
-#   undef N
+    if (useWireMode)
+    {
+        glPopAttrib();
+    }
 }
 
+static void fghGenerateGeometry(int numFaces, int numVertPerFace, GLdouble *vertices, GLubyte* vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut)
+{
+    int i,j;
+    /*
+     * Build array with vertices from 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).
+     */
+    for (i=0; i<numFaces; i++)
+    {
+        int normIdx         = i*3;
+        int faceIdxVertIdx  = i*numVertPerFace;
+        for (j=0; j<numVertPerFace; j++)
+        {
+            int outIdx  = i*numVertPerFace*3+j*3;
+            int vertIdx = vertIndices[faceIdxVertIdx+j]*3;
+
+            vertOut[outIdx  ] = vertices[vertIdx  ];
+            vertOut[outIdx+1] = vertices[vertIdx+1];
+            vertOut[outIdx+2] = vertices[vertIdx+2];
+
+            normOut[outIdx  ] = normals [normIdx  ];
+            normOut[outIdx+1] = normals [normIdx+1];
+            normOut[outIdx+2] = normals [normIdx+2];
+        }
+    }
+}
+
+
+/* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */
+static unsigned int ipow (int x, unsigned int y)
+{
+    return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2);
+}
+
+/* -- stuff that can be cached -- */
+/* Cache of input to glDrawArrays */
+#define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\
+    static GLboolean name##Cached = FALSE;\
+    static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
+    static GLdouble name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\
+    static void fgh##nameICaps##Generate()\
+    {\
+        fghGenerateGeometry(nameCaps##_NUM_FACES, nameCaps##_NUM_VERT_PER_FACE,\
+                            name##_v, name##_vi, name##_n,\
+                            name##_verts, name##_norms);\
+    }
 /*
- * Draws a solid cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
+ * 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.
  */
-void FGAPIENTRY glutSolidCube( GLdouble dSize )
+
+/* -- Cube -- */
+#define CUBE_NUM_VERT           8
+#define CUBE_NUM_FACES          6
+#define CUBE_NUM_VERT_PER_FACE  4
+#define CUBE_VERT_PER_OBJ       CUBE_NUM_FACES*CUBE_NUM_VERT_PER_FACE
+#define CUBE_VERT_ELEM_PER_OBJ  CUBE_VERT_PER_OBJ*3
+/* Vertex Coordinates */
+static GLdouble cube_v[CUBE_NUM_VERT*3] =
+{
+     .5, .5, .5,
+    -.5, .5, .5,
+    -.5,-.5, .5,
+     .5,-.5, .5,
+     .5,-.5,-.5,
+     .5, .5,-.5,
+    -.5, .5,-.5,
+    -.5,-.5,-.5
+};
+/* Normal Vectors */
+static GLdouble cube_n[CUBE_NUM_FACES*3] =
+{
+     0.0, 0.0, 1.0,
+     1.0, 0.0, 0.0,
+     0.0, 1.0, 0.0,
+    -1.0, 0.0, 0.0,
+     0.0,-1.0, 0.0,
+     0.0, 0.0,-1.0
+};
+
+/* Vertex indices */
+static GLubyte cube_vi[CUBE_VERT_PER_OBJ] =
 {
-    double size = dSize * 0.5;
+    0,1,2,3,
+    0,3,4,5,
+    0,5,6,1,
+    1,6,7,2,
+    7,4,3,2,
+    4,7,6,5
+};
+DECLARE_SHAPE_CACHE(cube,Cube,CUBE);
 
-    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
+/* -- Octahedron -- */
+#define OCTAHEDRON_NUM_VERT           6
+#define OCTAHEDRON_NUM_FACES          8
+#define OCTAHEDRON_NUM_VERT_PER_FACE  3
+#define OCTAHEDRON_VERT_PER_OBJ       OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_VERT_PER_FACE
+#define OCTAHEDRON_VERT_ELEM_PER_OBJ  OCTAHEDRON_VERT_PER_OBJ*3
 
-#   define V(a,b,c) glVertex3d( a size, b size, c size );
-#   define N(a,b,c) glNormal3d( a, b, c );
+/* Vertex Coordinates */
+static GLdouble octahedron_v[OCTAHEDRON_NUM_VERT*3] =
+{
+     1.,  0.,  0.,
+     0.,  1.,  0.,
+     0.,  0.,  1.,
+    -1.,  0.,  0.,
+     0., -1.,  0.,
+     0.,  0., -1.,
 
-    /* PWO: Again, I dared to convert the code to use macros... */
-    glBegin( GL_QUADS );
-        N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+);
-        N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+);
-        N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+);
-        N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-);
-        N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+);
-        N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-);
-    glEnd();
+};
+/* Normal Vectors */
+static GLdouble octahedron_n[OCTAHEDRON_NUM_FACES*3] =
+{
+     0.577350269189, 0.577350269189, 0.577350269189,    /* sqrt(1/3) */
+     0.577350269189, 0.577350269189,-0.577350269189,
+     0.577350269189,-0.577350269189, 0.577350269189,
+     0.577350269189,-0.577350269189,-0.577350269189,
+    -0.577350269189, 0.577350269189, 0.577350269189,
+    -0.577350269189, 0.577350269189,-0.577350269189,
+    -0.577350269189,-0.577350269189, 0.577350269189,
+    -0.577350269189,-0.577350269189,-0.577350269189
+
+};
+
+/* Vertex indices */
+static GLubyte octahedron_vi[OCTAHEDRON_VERT_PER_OBJ] =
+{
+    0, 1, 2,
+    0, 5, 1,
+    0, 2, 4,
+    0, 4, 5,
+    3, 2, 1,
+    3, 1, 5,
+    3, 4, 2,
+    3, 5, 4
+};
+DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON);
 
-#   undef V
-#   undef N
+/* -- Tetrahedron -- */
+/* Magic Numbers:  r0 = ( 1, 0, 0 )
+ *                 r1 = ( -1/3, 2 sqrt(2) / 3, 0 )
+ *                 r2 = ( -1/3, - sqrt(2) / 3,  sqrt(6) / 3 )
+ *                 r3 = ( -1/3, - sqrt(2) / 3, -sqrt(6) / 3 )
+ * |r0| = |r1| = |r2| = |r3| = 1
+ * Distance between any two points is 2 sqrt(6) / 3
+ *
+ * Normals:  The unit normals are simply the negative of the coordinates of the point not on the surface.
+ */
+#define TETRAHEDRON_NUM_VERT            4
+#define TETRAHEDRON_NUM_FACES           4
+#define TETRAHEDRON_NUM_VERT_PER_FACE   3
+#define TETRAHEDRON_VERT_PER_OBJ        TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_VERT_PER_FACE
+#define TETRAHEDRON_VERT_ELEM_PER_OBJ   TETRAHEDRON_VERT_PER_OBJ*3
+
+/* Vertex Coordinates */
+static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] =
+{
+                1.0,             0.0,             0.0,
+    -0.333333333333,  0.942809041582,             0.0,
+    -0.333333333333, -0.471404520791,  0.816496580928,
+    -0.333333333333, -0.471404520791, -0.816496580928
+};
+/* Normal Vectors */
+static GLdouble tetrahedron_n[TETRAHEDRON_NUM_FACES*3] =
+{
+    -           1.0,             0.0,             0.0,
+     0.333333333333, -0.942809041582,             0.0,
+     0.333333333333,  0.471404520791, -0.816496580928,
+     0.333333333333,  0.471404520791,  0.816496580928
+};
+
+/* Vertex indices */
+static GLubyte tetrahedron_vi[TETRAHEDRON_VERT_PER_OBJ] =
+{
+    1, 3, 2,
+    0, 2, 3,
+    0, 3, 1,
+    0, 1, 2
+};
+DECLARE_SHAPE_CACHE(tetrahedron,Tetrahedron,TETRAHEDRON);
+
+/* -- Sierpinski Sponge -- */
+static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLdouble scale, GLdouble* vertices, GLdouble* normals )
+{
+    int i, j;
+    if ( numLevels == 0 )
+    {
+        for (i=0; i<TETRAHEDRON_NUM_FACES; i++)
+        {
+            int normIdx         = i*3;
+            int faceIdxVertIdx  = i*TETRAHEDRON_NUM_VERT_PER_FACE;
+            for (j=0; j<TETRAHEDRON_NUM_VERT_PER_FACE; j++)
+            {
+                int outIdx  = i*TETRAHEDRON_NUM_VERT_PER_FACE*3+j*3;
+                int vertIdx = tetrahedron_vi[faceIdxVertIdx+j]*3;
+
+                vertices[outIdx  ] = offset[0] + scale * tetrahedron_v[vertIdx  ];
+                vertices[outIdx+1] = offset[1] + scale * tetrahedron_v[vertIdx+1];
+                vertices[outIdx+2] = offset[2] + scale * tetrahedron_v[vertIdx+2];
+
+                normals [outIdx  ] = tetrahedron_n[normIdx  ];
+                normals [outIdx+1] = tetrahedron_n[normIdx+1];
+                normals [outIdx+2] = tetrahedron_n[normIdx+2];
+            }
+        }
+    }
+    else if ( numLevels > 0 )
+    {
+        GLdouble local_offset[3] ;  /* Use a local variable to avoid buildup of roundoff errors */
+        unsigned int stride = ipow(4,--numLevels)*TETRAHEDRON_VERT_ELEM_PER_OBJ;
+        scale /= 2.0 ;
+        for ( i = 0 ; i < TETRAHEDRON_NUM_FACES ; i++ )
+        {
+            int idx         = i*3;
+            local_offset[0] = offset[0] + scale * tetrahedron_v[idx  ];
+            local_offset[1] = offset[1] + scale * tetrahedron_v[idx+1];
+            local_offset[2] = offset[2] + scale * tetrahedron_v[idx+2];
+            fghSierpinskiSpongeGenerate ( numLevels, local_offset, scale, vertices+i*stride, normals+i*stride );
+        }
+    }
 }
 
+/* -- Now the various shapes involving circles -- */
 /*
  * Compute lookup table of cos and sin values forming a cirle
  *
@@ -120,7 +342,6 @@ void FGAPIENTRY glutSolidCube( GLdouble dSize )
  *    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)
 {
     int i;
@@ -164,6 +385,71 @@ static void fghCircleTable(double **sint,double **cost,const int n)
     (*cost)[size] = (*cost)[0];
 }
 
+
+/* -- INTERNAL DRAWING functions to avoid code duplication ------------- */
+#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps)\
+    static void fgh##nameICaps( GLboolean useWireMode )\
+    {\
+        if (!name##Cached)\
+        {\
+            fgh##nameICaps##Generate();\
+            name##Cached = TRUE;\
+        }\
+        fghDrawGeometry(GL_TRIANGLES,name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ,useWireMode);\
+    }
+
+static void fghCube( GLdouble dSize, GLboolean useWireMode )
+{
+    if (!cubeCached)
+    {
+        fghCubeGenerate();
+        cubeCached = TRUE;
+    }
+
+    if (dSize!=1.)
+    {
+        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));
+        for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++)
+            vertices[i] = dSize*cube_verts[i];
+
+        fghDrawGeometry(GL_QUADS,vertices  ,cube_norms,CUBE_VERT_PER_OBJ,useWireMode);
+    }
+    else
+        fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_OBJ,useWireMode);
+}
+DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON);
+DECLARE_INTERNAL_DRAW(tetrahedron,Tetrahedron,TETRAHEDRON);
+
+static void fghSierpinskiSponge ( int numLevels, GLdouble offset[3], GLdouble scale, GLboolean useWireMode )
+{
+    GLdouble *vertices;
+    GLdouble * normals;
+    GLsizei    numTetr = numLevels<0? 0 : ipow(4,numLevels); /* No sponge for numLevels below 0 */
+    GLsizei    numVert = numTetr*TETRAHEDRON_VERT_PER_OBJ;
+
+    if (numTetr)
+    {
+        /* Allocate memory */
+        vertices = malloc(numVert*3 * sizeof(GLdouble));
+        normals  = malloc(numVert*3 * sizeof(GLdouble));
+
+        /* Generate elements */
+        fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals );
+
+        /* Draw and cleanup */
+        fghDrawGeometry(GL_TRIANGLES,vertices,normals,numVert,useWireMode);
+        free(vertices);
+        free(normals );
+    }
+}
+
+
+/* -- INTERFACE FUNCTIONS ---------------------------------------------- */
+
+
 /*
  * Draws a solid sphere
  */
@@ -866,100 +1152,6 @@ void FGAPIENTRY glutSolidDodecahedron( void )
 /*
  *
  */
-void FGAPIENTRY glutWireOctahedron( void )
-{
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireOctahedron" );
-
-#define RADIUS    1.0f
-  glBegin( GL_LINE_LOOP );
-    glNormal3d( 0.577350269189, 0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
-    glNormal3d( 0.577350269189, 0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
-    glNormal3d( 0.577350269189,-0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
-    glNormal3d( 0.577350269189,-0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
-    glNormal3d(-0.577350269189, 0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
-    glNormal3d(-0.577350269189, 0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
-    glNormal3d(-0.577350269189,-0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
-    glNormal3d(-0.577350269189,-0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
-  glEnd();
-#undef RADIUS
-}
-
-/*
- *
- */
-void FGAPIENTRY glutSolidOctahedron( void )
-{
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidOctahedron" );
-
-#define RADIUS    1.0f
-  glBegin( GL_TRIANGLES );
-    glNormal3d( 0.577350269189, 0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
-    glNormal3d( 0.577350269189, 0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
-    glNormal3d( 0.577350269189,-0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
-    glNormal3d( 0.577350269189,-0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
-    glNormal3d(-0.577350269189, 0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
-    glNormal3d(-0.577350269189, 0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
-    glNormal3d(-0.577350269189,-0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
-    glNormal3d(-0.577350269189,-0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
-  glEnd();
-#undef RADIUS
-}
-
-/* Magic Numbers:  r0 = ( 1, 0, 0 )
- *                 r1 = ( -1/3, 2 sqrt(2) / 3, 0 )
- *                 r2 = ( -1/3, -sqrt(2) / 3, sqrt(6) / 3 )
- *                 r3 = ( -1/3, -sqrt(2) / 3, -sqrt(6) / 3 )
- * |r0| = |r1| = |r2| = |r3| = 1
- * Distance between any two points is 2 sqrt(6) / 3
- *
- * Normals:  The unit normals are simply the negative of the coordinates of the point not on the surface.
- */
-
-#define NUM_TETR_FACES     4
-
-static GLdouble tet_r[4][3] = { {             1.0,             0.0,             0.0 },
-                                { -0.333333333333,  0.942809041582,             0.0 },
-                                { -0.333333333333, -0.471404520791,  0.816496580928 },
-                                { -0.333333333333, -0.471404520791, -0.816496580928 } } ;
-
-static GLint tet_i[4][3] =  /* Vertex indices */
-{
-  { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 }
-} ;
-
-/*
- *
- */
-void FGAPIENTRY glutWireTetrahedron( void )
-{
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" );
-
-  glBegin( GL_LINE_LOOP ) ;
-    glNormal3d ( -tet_r[0][0], -tet_r[0][1], -tet_r[0][2] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[2] ) ;
-    glNormal3d ( -tet_r[1][0], -tet_r[1][1], -tet_r[1][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[2] ) ; glVertex3dv ( tet_r[3] ) ;
-    glNormal3d ( -tet_r[2][0], -tet_r[2][1], -tet_r[2][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[1] ) ;
-    glNormal3d ( -tet_r[3][0], -tet_r[3][1], -tet_r[3][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[2] ) ;
-  glEnd() ;
-}
-
-/*
- *
- */
-void FGAPIENTRY glutSolidTetrahedron( void )
-{
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" );
-
-  glBegin( GL_TRIANGLES ) ;
-    glNormal3d ( -tet_r[0][0], -tet_r[0][1], -tet_r[0][2] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[2] ) ;
-    glNormal3d ( -tet_r[1][0], -tet_r[1][1], -tet_r[1][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[2] ) ; glVertex3dv ( tet_r[3] ) ;
-    glNormal3d ( -tet_r[2][0], -tet_r[2][1], -tet_r[2][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[1] ) ;
-    glNormal3d ( -tet_r[3][0], -tet_r[3][1], -tet_r[3][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[2] ) ;
-  glEnd() ;
-}
-
-/*
- *
- */
 static double icos_r[12][3] = {
     {  1.0,             0.0,             0.0            },
     {  0.447213595500,  0.894427191000,  0.0            },
@@ -1134,82 +1326,55 @@ void FGAPIENTRY glutSolidRhombicDodecahedron( void )
   glEnd () ;
 }
 
-void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
-{
-  int i, j ;
 
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" );
 
-  if ( num_levels == 0 )
-  {
+/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
+/*
+ * Draws a wireframed cube.
+ */
+void FGAPIENTRY glutWireCube( GLdouble dSize )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
+    fghCube( dSize, TRUE );
+}
+void FGAPIENTRY glutSolidCube( GLdouble dSize )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
+    fghCube( dSize, FALSE );
+}
 
-    for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
-    {
-      glBegin ( GL_LINE_LOOP ) ;
-      glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ;
-      for ( j = 0; j < 3; j++ )
-      {
-        double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ;
-        double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ;
-        double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ;
-        glVertex3d ( x, y, z ) ;
-      }
-
-      glEnd () ;
-    }
-  }
-  else if ( num_levels > 0 )
-  {
-    GLdouble local_offset[3] ;  /* Use a local variable to avoid buildup of roundoff errors */
-    num_levels -- ;
-    scale /= 2.0 ;
-    for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
-    {
-      local_offset[0] = offset[0] + scale * tet_r[i][0] ;
-      local_offset[1] = offset[1] + scale * tet_r[i][1] ;
-      local_offset[2] = offset[2] + scale * tet_r[i][2] ;
-      glutWireSierpinskiSponge ( num_levels, local_offset, scale ) ;
-    }
-  }
+void FGAPIENTRY glutWireOctahedron( void )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireOctahedron" );
+    fghOctahedron( TRUE );
+}
+void FGAPIENTRY glutSolidOctahedron( void )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidOctahedron" );
+    fghOctahedron( FALSE );
 }
 
+void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" );
+    fghSierpinskiSponge ( num_levels, offset, scale, TRUE );
+}
 void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
 {
-  int i, j ;
-
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
-
-  if ( num_levels == 0 )
-  {
-    glBegin ( GL_TRIANGLES ) ;
-
-    for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
-    {
-      glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ;
-      for ( j = 0; j < 3; j++ )
-      {
-        double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ;
-        double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ;
-        double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ;
-        glVertex3d ( x, y, z ) ;
-      }
-    }
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
+    fghSierpinskiSponge ( num_levels, offset, scale, FALSE );
+}
 
-    glEnd () ;
-  }
-  else if ( num_levels > 0 )
-  {
-    GLdouble local_offset[3] ;  /* Use a local variable to avoid buildup of roundoff errors */
-    num_levels -- ;
-    scale /= 2.0 ;
-    for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
-    {
-      local_offset[0] = offset[0] + scale * tet_r[i][0] ;
-      local_offset[1] = offset[1] + scale * tet_r[i][1] ;
-      local_offset[2] = offset[2] + scale * tet_r[i][2] ;
-      glutSolidSierpinskiSponge ( num_levels, local_offset, scale ) ;
-    }
-  }
+void FGAPIENTRY glutWireTetrahedron( void )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" );
+    fghTetrahedron( TRUE );
+}
+void FGAPIENTRY glutSolidTetrahedron( void )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" );
+    fghTetrahedron( FALSE );
 }
 
+
 /*** END OF FILE ***/