X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=a1d683df490d3a9f075af0b0c0503d0619ae64ae;hb=acdc3f42c8e4ffb6d9a9296ff8391e8338432a93;hp=de1cbadae2e27c1d4e847042e8146c6c06fc7052;hpb=1b5ee849ba61b667aeba474a7e03406196478bee;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index de1cbad..a1d683d 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,215 @@ */ -/* -- INTERFACE FUNCTIONS -------------------------------------------------- */ - -/* - * Draws a wireframed cube. Code contributed by Andreas Umbach +/* 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); -# 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); -# undef V -# undef N + if (useWireMode) + { + glPopAttrib(); + } } + +/* -- 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 + * 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_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] = { - 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_TETR]; +static double cube_norms[CUBE_VERT_ELEM_PER_TETR]; - /* 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() +{ + 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 ); + } + } +} + +/* -- Now the various shapes involving circles -- */ /* * Compute lookup table of cos and sin values forming a cirle * @@ -120,7 +279,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 +322,64 @@ 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.) + { + /* 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); +} + +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 ) +{ + 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; + + 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 +1121,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 +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 ) - { +/* -- 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 ***/