X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=a1d683df490d3a9f075af0b0c0503d0619ae64ae;hb=acdc3f42c8e4ffb6d9a9296ff8391e8338432a93;hp=3a19a3b021b223c7297766fd4c7eecd97f54fc8c;hpb=9634525a2e112501938d7cc5c48ce75f8b975a38;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index 3a19a3b..a1d683d 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 @@ -94,8 +93,78 @@ static void fghDrawGeometry(GLenum vertexMode, double* vertices, double* normals /* -- 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_TETR CUBE_NUM_FACES*CUBE_NUM_VERT_PER_FACE +#define CUBE_VERT_ELEM_PER_TETR CUBE_VERT_PER_TETR*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_TETR]; +static double cube_norms[CUBE_VERT_ELEM_PER_TETR]; + +static void fghCubeGenerate() +{ + int i,j; + for (i=0; i 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++ ) + { + 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]; + fghSierpinskiSpongeGenerate ( numLevels, local_offset, scale, vertices+i*stride, normals+i*stride ); } } } @@ -216,68 +325,61 @@ 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.) + { + /* Need to build new */ + fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_TETR,useWireMode); + } + else + fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_TETR,useWireMode); } - -/* -- INTERFACE FUNCTIONS ---------------------------------------------- */ - -/* - * Draws a wireframed cube. Code contributed by Andreas Umbach - */ -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 - */ -void FGAPIENTRY glutSolidCube( GLdouble dSize ) +static void fghSierpinskiSponge ( int numLevels, GLdouble offset[3], GLdouble scale, GLboolean useWireMode ) { - double size = dSize * 0.5; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" ); + double *vertices; + double * normals; + unsigned int numTetr = numLevels<0? 0 : ipow(4,numLevels); /* No sponge for numLevels below 0 */ + unsigned int numVert = numTetr*TETR_VERT_PER_TETR; -# 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 +1298,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 ***/