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

diff --git a/src/fg_geometry.c b/src/fg_geometry.c
index de1cbad..66659a4 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,223 @@
  */
 
 
-/* -- 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, double* vertices, double* 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" );
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_NORMAL_ARRAY);
+
+    glVertexPointer(3, GL_DOUBLE, 0, vertices);
+    glNormalPointer(GL_DOUBLE, 0, normals);
+    glDrawArrays(vertexMode,0,numVertices);
 
-#   define V(a,b,c) glVertex3d( a size, b size, c size );
-#   define N(a,b,c) glNormal3d( a, b, c );
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_NORMAL_ARRAY);
+
+    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];
+        }
+    }
+}
 
-    /* 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();
 
-#   undef V
-#   undef N
+/* -- 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 -- */
 /*
- * 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_CUBE      CUBE_NUM_FACES*CUBE_NUM_VERT_PER_FACE
+#define CUBE_VERT_ELEM_PER_CUBE CUBE_VERT_PER_CUBE*3
+/* Vertex Coordinates */
+static GLdouble cube_v[CUBE_NUM_VERT*3] =
 {
-    double size = dSize * 0.5;
+     .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
+};
 
-    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
+/* Vertex indices */
+static GLubyte cube_vi[CUBE_NUM_FACES*CUBE_NUM_VERT_PER_FACE] =
+{
+    0,1,2,3,
+    0,3,4,5,
+    0,5,6,1,
+    1,6,7,2,
+    7,4,3,2,
+    4,7,6,5
+};
 
-#   define V(a,b,c) glVertex3d( a size, b size, c size );
-#   define N(a,b,c) glNormal3d( a, b, c );
+/* Cache of input to glDrawArrays */
+static GLboolean cubeCached = FALSE;
+static double cube_verts[CUBE_VERT_ELEM_PER_CUBE];
+static double cube_norms[CUBE_VERT_ELEM_PER_CUBE];
 
-    /* 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();
+static void fghCubeGenerate()
+{
+    fghGenerateGeometry(CUBE_NUM_FACES, CUBE_NUM_VERT_PER_FACE, cube_v, cube_vi, cube_n, cube_verts, cube_norms);
+}
+
+/* -- 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 TETR_NUM_VERT           4
+#define TETR_NUM_FACES          4
+#define TETR_NUM_VERT_PER_FACE  3
+#define TETR_VERT_PER_TETR      TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE
+#define TETR_VERT_ELEM_PER_TETR TETR_VERT_PER_TETR*3
+
+/* Vertex Coordinates */
+static GLdouble tetr_v[TETR_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 tetr_n[CUBE_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
+};
 
-#   undef V
-#   undef N
+/* Vertex indices */
+static GLubyte tetr_vi[TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE] =
+{
+    1, 3, 2,
+    0, 2, 3,
+    0, 3, 1,
+    0, 1, 2
+};
+
+/* Cache of input to glDrawArrays */
+static GLboolean tetrCached = FALSE;
+static double tetr_verts[TETR_VERT_ELEM_PER_TETR];
+static double tetr_norms[TETR_VERT_ELEM_PER_TETR];
+
+static void fghTetrahedronGenerate()
+{
+    fghGenerateGeometry(TETR_NUM_FACES, TETR_NUM_VERT_PER_FACE, tetr_v, tetr_vi, tetr_n, tetr_verts, tetr_norms);
+}
+
+/* -- Sierpinski Sponge -- */
+static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLdouble scale, double* vertices, double* normals )
+{
+    int i, j;
+    if ( numLevels == 0 )
+    {
+        for (i=0; i<TETR_NUM_FACES; i++)
+        {
+            int normIdx         = i*3;
+            int faceIdxVertIdx  = i*TETR_NUM_VERT_PER_FACE;
+            for (j=0; j<TETR_NUM_VERT_PER_FACE; j++)
+            {
+                int outIdx  = i*TETR_NUM_VERT_PER_FACE*3+j*3;
+                int vertIdx = tetr_vi[faceIdxVertIdx+j]*3;
+
+                vertices[outIdx  ] = offset[0] + scale * tetr_v[vertIdx  ];
+                vertices[outIdx+1] = offset[1] + scale * tetr_v[vertIdx+1];
+                vertices[outIdx+2] = offset[2] + scale * tetr_v[vertIdx+2];
+
+                normals [outIdx  ] = tetr_n[normIdx  ];
+                normals [outIdx+1] = tetr_n[normIdx+1];
+                normals [outIdx+2] = tetr_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)*TETR_VERT_ELEM_PER_TETR;
+        scale /= 2.0 ;
+        for ( i = 0 ; i < TETR_NUM_FACES ; i++ )
+        {
+            int idx         = i*3;
+            local_offset[0] = offset[0] + scale * tetr_v[idx  ];
+            local_offset[1] = offset[1] + scale * tetr_v[idx+1];
+            local_offset[2] = offset[2] + scale * tetr_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 +287,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 +330,70 @@ static void fghCircleTable(double **sint,double **cost,const int n)
     (*cost)[size] = (*cost)[0];
 }
 
+
+/* -- INTERNAL DRAWING functions to avoid code duplication ------------- */
+
+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_CUBE * sizeof(double));
+        for (i=0; i<CUBE_VERT_ELEM_PER_CUBE; i++)
+            vertices[i] = dSize*cube_verts[i];
+
+        fghDrawGeometry(GL_QUADS,vertices  ,cube_norms,CUBE_VERT_PER_CUBE,useWireMode);
+    }
+    else
+        fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_CUBE,useWireMode);
+}
+
+static void fghTetrahedron( GLboolean useWireMode )
+{
+    if (!tetrCached)
+    {
+        fghTetrahedronGenerate();
+        tetrCached = TRUE;
+    }
+
+    fghDrawGeometry(GL_TRIANGLES,tetr_verts,tetr_norms,TETR_VERT_PER_TETR,useWireMode);
+}
+
+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*TETR_VERT_PER_TETR;
+
+    if (numTetr)
+    {
+        /* Allocate memory */
+        vertices = malloc(numVert*3 * sizeof(double));
+        normals  = malloc(numVert*3 * sizeof(double));
+
+        /* 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
  */
@@ -905,58 +1135,6 @@ void FGAPIENTRY glutSolidOctahedron( void )
 #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() ;
-}
-
 /*
  *
  */
@@ -1134,82 +1312,44 @@ 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 glutWireTetrahedron( void )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" );
+    fghTetrahedron( TRUE );
+}
+void FGAPIENTRY glutSolidTetrahedron( void )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" );
+    fghTetrahedron( 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 ) ;
-      }
-    }
-
-    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 ) ;
-    }
-  }
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
+    fghSierpinskiSponge ( num_levels, offset, scale, FALSE );
 }
 
+
 /*** END OF FILE ***/