X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=66659a46f1b7725f46de1a6bb871a7043e735d34;hb=4bb957b58beb8c268b37549e8d6d4fa4b925f858;hp=3a19a3b021b223c7297766fd4c7eecd97f54fc8c;hpb=9634525a2e112501938d7cc5c48ce75f8b975a38;p=freeglut

diff --git a/src/fg_geometry.c b/src/fg_geometry.c
index 3a19a3b..66659a4 100644
--- a/src/fg_geometry.c
+++ b/src/fg_geometry.c
@@ -61,8 +61,7 @@
  */
 
 
-/*
- * General function for drawing geometry. As for all geometry we have no 
+/* 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
@@ -92,10 +91,100 @@ static void fghDrawGeometry(GLenum vertexMode, double* vertices, double* normals
     }
 }
 
+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 --------------------------------------- */
-/* -- first the cachable ones -- */
+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 -- */
+/*
+ * 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_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] =
+{
+     .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_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
+};
+
+/* 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];
+
+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 )
@@ -104,58 +193,86 @@ static void fghDrawGeometry(GLenum vertexMode, double* vertices, double* normals
  * 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.
-*/
-
-/* -- TetraHedron -- */
+ */
+#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 tet_r[TETR_NUM_FACES][TETR_NUM_VERT_PER_FACE] =
+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 }
+                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 tet_i[TETR_NUM_FACES][TETR_NUM_VERT_PER_FACE] =
+/* Normal Vectors */
+static GLdouble tetr_n[CUBE_NUM_FACES*3] =
 {
-    { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 }
+    -           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 indices */
-static GLubyte tet_n[TETR_NUM_FACES] =
+
+/* Vertex indices */
+static GLubyte tetr_vi[TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE] =
 {
-    0, 1, 2, 3
+    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_NUM_FACES * TETR_NUM_VERT_PER_FACE * 3];
-static double tetr_norms[TETR_NUM_FACES * TETR_NUM_VERT_PER_FACE * 3];
+static double tetr_verts[TETR_VERT_ELEM_PER_TETR];
+static double tetr_norms[TETR_VERT_ELEM_PER_TETR];
 
-static void fghTetrahedronCache()
+static void fghTetrahedronGenerate()
 {
-    int p,q;
-    /*
-    * 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 (p=0; p<TETR_NUM_FACES; p++)
+    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 )
     {
-        for (q=0; q<TETR_NUM_VERT_PER_FACE; q++)
+        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 = p*TETR_NUM_VERT_PER_FACE*3+q*3;
-            tetr_verts[idx  ] =  tet_r[tet_i[p][q]][0];
-            tetr_verts[idx+1] =  tet_r[tet_i[p][q]][1];
-            tetr_verts[idx+2] =  tet_r[tet_i[p][q]][2];
-
-            tetr_norms[idx  ] = -tet_r[tet_n[p]][0];
-            tetr_norms[idx+1] = -tet_r[tet_n[p]][1];
-            tetr_norms[idx+2] = -tet_r[tet_n[p]][2];
+            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 );
         }
     }
 }
@@ -216,68 +333,67 @@ static void fghCircleTable(double **sint,double **cost,const int n)
 
 /* -- INTERNAL DRAWING functions to avoid code duplication ------------- */
 
-static void fghTetrahedron( GLboolean useWireMode )
+static void fghCube( GLdouble dSize, GLboolean useWireMode )
 {
-    if (!tetrCached)
-        fghTetrahedronCache();
+    if (!cubeCached)
+    {
+        fghCubeGenerate();
+        cubeCached = TRUE;
+    }
 
-    fghDrawGeometry(GL_TRIANGLES,tetr_verts,tetr_norms,TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE,useWireMode);
-}
+    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];
 
-/* -- INTERFACE FUNCTIONS ---------------------------------------------- */
+        fghDrawGeometry(GL_QUADS,vertices  ,cube_norms,CUBE_VERT_PER_CUBE,useWireMode);
+    }
+    else
+        fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_CUBE,useWireMode);
+}
 
-/*
- * Draws a wireframed cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
- */
-void FGAPIENTRY glutWireCube( GLdouble dSize )
+static void fghTetrahedron( GLboolean useWireMode )
 {
-    double size = dSize * 0.5;
-
-    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
-
-#   define V(a,b,c) glVertex3d( a size, b size, c size );
-#   define N(a,b,c) glNormal3d( a, b, c );
-
-    /* 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();
+    if (!tetrCached)
+    {
+        fghTetrahedronGenerate();
+        tetrCached = TRUE;
+    }
 
-#   undef V
-#   undef N
+    fghDrawGeometry(GL_TRIANGLES,tetr_verts,tetr_norms,TETR_VERT_PER_TETR,useWireMode);
 }
 
-/*
- * Draws a solid cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
- */
-void FGAPIENTRY glutSolidCube( GLdouble dSize )
+static void fghSierpinskiSponge ( int numLevels, GLdouble offset[3], GLdouble scale, GLboolean useWireMode )
 {
-    double size = dSize * 0.5;
+    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;
 
-    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
-
-#   define V(a,b,c) glVertex3d( a size, b size, c size );
-#   define N(a,b,c) glNormal3d( a, b, c );
+    if (numTetr)
+    {
+        /* Allocate memory */
+        vertices = malloc(numVert*3 * sizeof(double));
+        normals  = malloc(numVert*3 * sizeof(double));
 
-    /* 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();
+        /* Generate elements */
+        fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals );
 
-#   undef V
-#   undef N
+        /* Draw and cleanup */
+        fghDrawGeometry(GL_TRIANGLES,vertices,normals,numVert,useWireMode);
+        free(vertices);
+        free(normals );
+    }
 }
 
 
+/* -- INTERFACE FUNCTIONS ---------------------------------------------- */
+
+
 /*
  * Draws a solid sphere
  */
@@ -1196,101 +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 )
-  {
 
-    for ( i = 0 ; i < TETR_NUM_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 < TETR_NUM_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 ) ;
-    }
-  }
+/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
+/*
+ * Draws a wireframed cube.
+ */
+void FGAPIENTRY glutWireCube( GLdouble dSize )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
+    fghCube( dSize, TRUE );
 }
-
-void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
+void FGAPIENTRY glutSolidCube( GLdouble dSize )
 {
-  int i, j ;
-
-  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
-
-  if ( num_levels == 0 )
-  {
-    glBegin ( GL_TRIANGLES ) ;
-
-    for ( i = 0 ; i < TETR_NUM_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 < TETR_NUM_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 ( "glutSolidCube" );
+    fghCube( dSize, FALSE );
 }
 
-
-
-/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
-
-
 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 )
+{
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
+    fghSierpinskiSponge ( num_levels, offset, scale, FALSE );
+}
+
 
 /*** END OF FILE ***/