From: <dc...@us...> - 2012-03-16 00:40:22
|
Revision: 1143 http://freeglut.svn.sourceforge.net/freeglut/?rev=1143&view=rev Author: dcnieho Date: 2012-03-16 00:40:15 +0000 (Fri, 16 Mar 2012) Log Message: ----------- initial start at rewrite of fg_geometry functions, using glDrawArrays. Tetrahedon done as example (seems to work well, but further comments pending) Done restructuring of the file as well Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-15 20:51:24 UTC (rev 1142) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 00:40:15 UTC (rev 1143) @@ -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,106 @@ */ -/* -- INTERFACE FUNCTIONS -------------------------------------------------- */ - /* - * Draws a wireframed cube. Code contributed by Andreas Umbach <ma...@da...> + * 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(); + } } -/* - * Draws a solid cube. Code contributed by Andreas Umbach <ma...@da...> - */ -void FGAPIENTRY glutSolidCube( GLdouble dSize ) + +/* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */ +/* -- first the cachable ones -- */ + +/* 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. +*/ + +/* -- TetraHedron -- */ +#define TETR_NUM_FACES 4 +#define TETR_NUM_VERT_PER_FACE 3 + +/* Vertex Coordinates */ +static GLdouble tet_r[TETR_NUM_FACES][TETR_NUM_VERT_PER_FACE] = { - double size = dSize * 0.5; + { 1.0, 0.0, 0.0 }, + { -0.333333333333, 0.942809041582, 0.0 }, + { -0.333333333333, -0.471404520791, 0.816496580928 }, + { -0.333333333333, -0.471404520791, -0.816496580928 } +}; - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" ); +/* Vertex indices */ +static GLubyte tet_i[TETR_NUM_FACES][TETR_NUM_VERT_PER_FACE] = +{ + { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 } +}; +/* Normal indices */ +static GLubyte tet_n[TETR_NUM_FACES] = +{ + 0, 1, 2, 3 +}; -# 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 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]; - /* 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 fghTetrahedronCache() +{ + 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++) + { + for (q=0; q<TETR_NUM_VERT_PER_FACE; q++) + { + 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]; -# undef V -# undef N + 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]; + } + } } +/* -- Now the various shapes involving circles -- */ /* * Compute lookup table of cos and sin values forming a cirle * @@ -120,7 +170,6 @@ * 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,7 +213,72 @@ (*cost)[size] = (*cost)[0]; } + +/* -- INTERNAL DRAWING functions to avoid code duplication ------------- */ + +static void fghTetrahedron( GLboolean useWireMode ) +{ + if (!tetrCached) + fghTetrahedronCache(); + + fghDrawGeometry(GL_TRIANGLES,tetr_verts,tetr_norms,TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE,useWireMode); +} + + +/* -- INTERFACE FUNCTIONS ---------------------------------------------- */ + /* + * Draws a wireframed cube. Code contributed by Andreas Umbach <ma...@da...> + */ +void FGAPIENTRY glutWireCube( GLdouble dSize ) +{ + 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(); + +# undef V +# undef N +} + +/* + * Draws a solid cube. Code contributed by Andreas Umbach <ma...@da...> + */ +void FGAPIENTRY glutSolidCube( GLdouble dSize ) +{ + double size = dSize * 0.5; + + 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 ); + + /* 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(); + +# undef V +# undef N +} + + +/* * Draws a solid sphere */ void FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks) @@ -905,61 +1019,9 @@ #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 }, @@ -1143,7 +1205,7 @@ if ( num_levels == 0 ) { - for ( i = 0 ; i < NUM_TETR_FACES ; i++ ) + 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] ) ; @@ -1163,7 +1225,7 @@ 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++ ) + 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] ; @@ -1183,7 +1245,7 @@ { glBegin ( GL_TRIANGLES ) ; - for ( i = 0 ; i < NUM_TETR_FACES ; i++ ) + 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++ ) @@ -1202,7 +1264,7 @@ 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++ ) + 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] ; @@ -1212,4 +1274,23 @@ } } + + +/* -- 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 ); +} + + /*** END OF FILE ***/ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 02:02:05
|
Revision: 1144 http://freeglut.svn.sourceforge.net/freeglut/?rev=1144&view=rev Author: dcnieho Date: 2012-03-16 02:01:59 +0000 (Fri, 16 Mar 2012) Log Message: ----------- also did Sierpinski sponge Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 00:40:15 UTC (rev 1143) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 02:01:59 UTC (rev 1144) @@ -94,7 +94,10 @@ /* -- 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); +} /* Magic Numbers: r0 = ( 1, 0, 0 ) * r1 = ( -1/3, 2 sqrt(2) / 3, 0 ) @@ -106,9 +109,11 @@ * Normals: The unit normals are simply the negative of the coordinates of the point not on the surface. */ -/* -- TetraHedron -- */ +/* -- Tetrahedron -- */ #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] = @@ -132,34 +137,70 @@ /* 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; + 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 (p=0; p<TETR_NUM_FACES; p++) + for (i=0; i<TETR_NUM_FACES; i++) { - for (q=0; q<TETR_NUM_VERT_PER_FACE; q++) + for (j=0; j<TETR_NUM_VERT_PER_FACE; j++) { - 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]; + int idx = i*TETR_NUM_VERT_PER_FACE*3+j*3; + tetr_verts[idx ] = tet_r[tet_i[i][j]][0]; + tetr_verts[idx+1] = tet_r[tet_i[i][j]][1]; + tetr_verts[idx+2] = tet_r[tet_i[i][j]][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]; + tetr_norms[idx ] = -tet_r[tet_n[i]][0]; + tetr_norms[idx+1] = -tet_r[tet_n[i]][1]; + tetr_norms[idx+2] = -tet_r[tet_n[i]][2]; } } } +/* -- 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++ ) + { + for ( j = 0; j < TETR_NUM_VERT_PER_FACE; j++ ) + { + int idx = i*TETR_NUM_VERT_PER_FACE*3+j*3; + vertices[idx ] = offset[0] + scale * tet_r[tet_i[i][j]][0]; + vertices[idx+1] = offset[1] + scale * tet_r[tet_i[i][j]][1]; + vertices[idx+2] = offset[2] + scale * tet_r[tet_i[i][j]][2]; + + normals[idx ] = -tet_r[tet_n[i]][0]; + normals[idx+1] = -tet_r[tet_n[i]][1]; + normals[idx+2] = -tet_r[tet_n[i]][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++ ) + { + 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 @@ -219,12 +260,35 @@ static void fghTetrahedron( GLboolean useWireMode ) { if (!tetrCached) - fghTetrahedronCache(); + fghTetrahedronGenerate(); - fghDrawGeometry(GL_TRIANGLES,tetr_verts,tetr_norms,TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE,useWireMode); + 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 ---------------------------------------------- */ /* @@ -1196,101 +1260,32 @@ 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 ) ; - } - } -} - -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 < 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 ) ; - } - } -} - - - /* -- 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 ***/ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 03:14:30
|
Revision: 1145 http://freeglut.svn.sourceforge.net/freeglut/?rev=1145&view=rev Author: dcnieho Date: 2012-03-16 03:14:23 +0000 (Fri, 16 Mar 2012) Log Message: ----------- Cube also moved to glDrawElements Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 02:01:59 UTC (rev 1144) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 03:14:23 UTC (rev 1145) @@ -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 @@ -99,6 +98,73 @@ 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] = +{ + { 1.0, 0.0, 0.0}, + { 0.0, 1.0, 0.0}, + { 0.0, 0.0, 1.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<CUBE_NUM_FACES; i++) + { + for (j=0; j<CUBE_NUM_VERT_PER_FACE; j++) + { + int idx = i*CUBE_NUM_VERT_PER_FACE*3+j*3; + cube_verts[idx ] = cube_v[cube_vi[i][j]][0]; + cube_verts[idx+1] = cube_v[cube_vi[i][j]][1]; + cube_verts[idx+2] = cube_v[cube_vi[i][j]][2]; + + cube_norms[idx ] = cube_n[i][0]; + cube_norms[idx+1] = cube_n[i][1]; + cube_norms[idx+2] = cube_n[i][2]; + } + } +} + +/* -- Tetrahedron -- */ /* Magic Numbers: r0 = ( 1, 0, 0 ) * r1 = ( -1/3, 2 sqrt(2) / 3, 0 ) * r2 = ( -1/3, - sqrt(2) / 3, sqrt(6) / 3 ) @@ -107,33 +173,35 @@ * 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 tet_r[TETR_NUM_VERT][TETR_NUM_VERT_PER_FACE] = { { 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 tet_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 } +}; /* Vertex indices */ static GLubyte tet_i[TETR_NUM_FACES][TETR_NUM_VERT_PER_FACE] = { { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 } }; -/* Normal indices */ -static GLubyte tet_n[TETR_NUM_FACES] = -{ - 0, 1, 2, 3 -}; /* Cache of input to glDrawArrays */ static GLboolean tetrCached = FALSE; @@ -144,11 +212,11 @@ { 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). - */ + * 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<TETR_NUM_FACES; i++) { for (j=0; j<TETR_NUM_VERT_PER_FACE; j++) @@ -158,9 +226,9 @@ tetr_verts[idx+1] = tet_r[tet_i[i][j]][1]; tetr_verts[idx+2] = tet_r[tet_i[i][j]][2]; - tetr_norms[idx ] = -tet_r[tet_n[i]][0]; - tetr_norms[idx+1] = -tet_r[tet_n[i]][1]; - tetr_norms[idx+2] = -tet_r[tet_n[i]][2]; + tetr_norms[idx ] = tet_n[i][0]; + tetr_norms[idx+1] = tet_n[i][1]; + tetr_norms[idx+2] = tet_n[i][2]; } } } @@ -180,9 +248,9 @@ vertices[idx+1] = offset[1] + scale * tet_r[tet_i[i][j]][1]; vertices[idx+2] = offset[2] + scale * tet_r[tet_i[i][j]][2]; - normals[idx ] = -tet_r[tet_n[i]][0]; - normals[idx+1] = -tet_r[tet_n[i]][1]; - normals[idx+2] = -tet_r[tet_n[i]][2]; + normals [idx ] = -tet_r[i][0]; + normals [idx+1] = -tet_r[i][1]; + normals [idx+2] = -tet_r[i][2]; } } } @@ -257,6 +325,20 @@ /* -- INTERNAL DRAWING functions to avoid code duplication ------------- */ +static void fghCube( GLdouble dSize, GLboolean useWireMode ) +{ + if (!cubeCached) + fghCubeGenerate(); + + 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) @@ -291,58 +373,8 @@ /* -- INTERFACE FUNCTIONS ---------------------------------------------- */ -/* - * Draws a wireframed cube. Code contributed by Andreas Umbach <ma...@da...> - */ -void FGAPIENTRY glutWireCube( GLdouble dSize ) -{ - 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(); - -# undef V -# undef N -} - /* - * Draws a solid cube. Code contributed by Andreas Umbach <ma...@da...> - */ -void FGAPIENTRY glutSolidCube( GLdouble dSize ) -{ - double size = dSize * 0.5; - - 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 ); - - /* 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(); - -# undef V -# undef N -} - - -/* * Draws a solid sphere */ void FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks) @@ -1263,8 +1295,20 @@ /* -- 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 ); +} - void FGAPIENTRY glutWireTetrahedron( void ) { FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" ); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 03:17:43
|
Revision: 1146 http://freeglut.svn.sourceforge.net/freeglut/?rev=1146&view=rev Author: dcnieho Date: 2012-03-16 03:17:37 +0000 (Fri, 16 Mar 2012) Log Message: ----------- I have these nice variables indicating whether the geometry cache for a certain object was already filled, but i never set them to true... Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 03:14:23 UTC (rev 1145) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 03:17:37 UTC (rev 1146) @@ -328,7 +328,10 @@ static void fghCube( GLdouble dSize, GLboolean useWireMode ) { if (!cubeCached) + { fghCubeGenerate(); + cubeCached = TRUE; + } if (dSize!=1.) { @@ -342,7 +345,10 @@ static void fghTetrahedron( GLboolean useWireMode ) { if (!tetrCached) + { fghTetrahedronGenerate(); + tetrCached = TRUE; + } fghDrawGeometry(GL_TRIANGLES,tetr_verts,tetr_norms,TETR_VERT_PER_TETR,useWireMode); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 04:22:41
|
Revision: 1147 http://freeglut.svn.sourceforge.net/freeglut/?rev=1147&view=rev Author: dcnieho Date: 2012-03-16 04:22:34 +0000 (Fri, 16 Mar 2012) Log Message: ----------- array size second dim is simply 3... Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 03:17:37 UTC (rev 1146) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 04:22:34 UTC (rev 1147) @@ -181,7 +181,7 @@ #define TETR_VERT_ELEM_PER_TETR TETR_VERT_PER_TETR*3 /* Vertex Coordinates */ -static GLdouble tet_r[TETR_NUM_VERT][TETR_NUM_VERT_PER_FACE] = +static GLdouble tet_r[TETR_NUM_VERT][3] = { { 1.0, 0.0, 0.0 }, { -0.333333333333, 0.942809041582, 0.0 }, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 04:23:55
|
Revision: 1148 http://freeglut.svn.sourceforge.net/freeglut/?rev=1148&view=rev Author: dcnieho Date: 2012-03-16 04:23:48 +0000 (Fri, 16 Mar 2012) Log Message: ----------- got one fo the cube's normals wrong Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 04:22:34 UTC (rev 1147) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 04:23:48 UTC (rev 1148) @@ -126,9 +126,9 @@ /* 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}, - { 0.0, 0.0, 1.0}, {-1.0, 0.0, 0.0}, { 0.0,-1.0, 0.0}, { 0.0, 0.0,-1.0} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 04:49:23
|
Revision: 1149 http://freeglut.svn.sourceforge.net/freeglut/?rev=1149&view=rev Author: dcnieho Date: 2012-03-16 04:49:17 +0000 (Fri, 16 Mar 2012) Log Message: ----------- now using one function to generate geometry from the lists of vertices, normals and vertex indices Geometry lists now stored in 1D arrays Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 04:23:48 UTC (rev 1148) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 04:49:17 UTC (rev 1149) @@ -91,7 +91,36 @@ } } +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) { @@ -112,32 +141,37 @@ #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] = +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} + .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] = +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} + 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] = +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} + 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 */ @@ -146,22 +180,8 @@ static double cube_norms[CUBE_VERT_ELEM_PER_TETR]; static void fghCubeGenerate() -{ - int i,j; - for (i=0; i<CUBE_NUM_FACES; i++) - { - for (j=0; j<CUBE_NUM_VERT_PER_FACE; j++) - { - int idx = i*CUBE_NUM_VERT_PER_FACE*3+j*3; - cube_verts[idx ] = cube_v[cube_vi[i][j]][0]; - cube_verts[idx+1] = cube_v[cube_vi[i][j]][1]; - cube_verts[idx+2] = cube_v[cube_vi[i][j]][2]; - - cube_norms[idx ] = cube_n[i][0]; - cube_norms[idx+1] = cube_n[i][1]; - cube_norms[idx+2] = cube_n[i][2]; - } - } +{ + fghGenerateGeometry(CUBE_NUM_FACES, CUBE_NUM_VERT_PER_FACE, cube_v, cube_vi, cube_n, cube_verts, cube_norms); } /* -- Tetrahedron -- */ @@ -181,26 +201,29 @@ #define TETR_VERT_ELEM_PER_TETR TETR_VERT_PER_TETR*3 /* Vertex Coordinates */ -static GLdouble tet_r[TETR_NUM_VERT][3] = +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 }; /* Normal Vectors */ -static GLdouble tet_n[CUBE_NUM_FACES][3] = +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 } + - 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] = +static GLubyte tetr_vi[TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE] = { - { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 } + 1, 3, 2, + 0, 2, 3, + 0, 3, 1, + 0, 1, 2 }; /* Cache of input to glDrawArrays */ @@ -210,27 +233,7 @@ static void fghTetrahedronGenerate() { - 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<TETR_NUM_FACES; i++) - { - for (j=0; j<TETR_NUM_VERT_PER_FACE; j++) - { - int idx = i*TETR_NUM_VERT_PER_FACE*3+j*3; - tetr_verts[idx ] = tet_r[tet_i[i][j]][0]; - tetr_verts[idx+1] = tet_r[tet_i[i][j]][1]; - tetr_verts[idx+2] = tet_r[tet_i[i][j]][2]; - - tetr_norms[idx ] = tet_n[i][0]; - tetr_norms[idx+1] = tet_n[i][1]; - tetr_norms[idx+2] = tet_n[i][2]; - } - } + fghGenerateGeometry(TETR_NUM_FACES, TETR_NUM_VERT_PER_FACE, tetr_v, tetr_vi, tetr_n, tetr_verts, tetr_norms); } /* -- Sierpinski Sponge -- */ @@ -239,18 +242,22 @@ int i, j; if ( numLevels == 0 ) { - for ( i = 0 ; i < TETR_NUM_FACES ; i++ ) + for (i=0; i<TETR_NUM_FACES; i++) { - for ( j = 0; j < TETR_NUM_VERT_PER_FACE; j++ ) + int normIdx = i*3; + int faceIdxVertIdx = i*TETR_NUM_VERT_PER_FACE; + for (j=0; j<TETR_NUM_VERT_PER_FACE; j++) { - int idx = i*TETR_NUM_VERT_PER_FACE*3+j*3; - vertices[idx ] = offset[0] + scale * tet_r[tet_i[i][j]][0]; - vertices[idx+1] = offset[1] + scale * tet_r[tet_i[i][j]][1]; - vertices[idx+2] = offset[2] + scale * tet_r[tet_i[i][j]][2]; + int outIdx = i*TETR_NUM_VERT_PER_FACE*3+j*3; + int vertIdx = tetr_vi[faceIdxVertIdx+j]*3; - normals [idx ] = -tet_r[i][0]; - normals [idx+1] = -tet_r[i][1]; - normals [idx+2] = -tet_r[i][2]; + 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]; } } } @@ -261,9 +268,10 @@ 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]; + 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 ); } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 05:06:37
|
Revision: 1150 http://freeglut.svn.sourceforge.net/freeglut/?rev=1150&view=rev Author: dcnieho Date: 2012-03-16 05:06:31 +0000 (Fri, 16 Mar 2012) Log Message: ----------- dSize parameter of Cube now works correctly again Fixed some inconsistent Macro naming and variable types Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 04:49:17 UTC (rev 1149) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 05:06:31 UTC (rev 1150) @@ -138,8 +138,8 @@ #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 +#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] = { @@ -176,8 +176,8 @@ /* 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 double cube_verts[CUBE_VERT_ELEM_PER_CUBE]; +static double cube_norms[CUBE_VERT_ELEM_PER_CUBE]; static void fghCubeGenerate() { @@ -343,11 +343,17 @@ if (dSize!=1.) { - /* Need to build new */ - fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_TETR,useWireMode); + 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_TETR,useWireMode); + fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_CUBE,useWireMode); } static void fghTetrahedron( GLboolean useWireMode ) @@ -363,10 +369,10 @@ 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; + 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) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 07:24:40
|
Revision: 1153 http://freeglut.svn.sourceforge.net/freeglut/?rev=1153&view=rev Author: dcnieho Date: 2012-03-16 07:24:34 +0000 (Fri, 16 Mar 2012) Log Message: ----------- octahedron also done another pass at making all variable types consistent added some direct mode drawing code for debugging Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 06:05:33 UTC (rev 1152) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 07:24:34 UTC (rev 1153) @@ -67,7 +67,7 @@ * useWireMode controls the drawing of solids (false) or wire frame * versions (TRUE) of the geometry you pass */ -static void fghDrawGeometry(GLenum vertexMode, double* vertices, double* normals, GLsizei numVertices, GLboolean useWireMode) +static void fghDrawGeometry(GLenum vertexMode, GLdouble* vertices, GLdouble* normals, GLsizei numVertices, GLboolean useWireMode) { if (useWireMode) { @@ -75,15 +75,31 @@ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); } - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); + if (1) + { + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); - glDrawArrays(vertexMode,0,numVertices); + glVertexPointer(3, GL_DOUBLE, 0, vertices); + glNormalPointer(GL_DOUBLE, 0, normals); + glDrawArrays(vertexMode, 0, numVertices); - glDisableClientState(GL_VERTEX_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); + 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(); + } if (useWireMode) { @@ -164,7 +180,7 @@ }; /* Vertex indices */ -static GLubyte cube_vi[CUBE_NUM_FACES*CUBE_NUM_VERT_PER_FACE] = +static GLubyte cube_vi[CUBE_VERT_PER_CUBE] = { 0,1,2,3, 0,3,4,5, @@ -176,14 +192,69 @@ /* 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 GLdouble cube_verts[CUBE_VERT_ELEM_PER_CUBE]; +static GLdouble 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); } +/* -- Octahedron -- */ +#define OCTAHEDRON_NUM_VERT 6 +#define OCTAHEDRON_NUM_FACES 8 +#define OCTAHEDRON_NUM_VERT_PER_FACE 3 +#define OCTAHEDRON_VERT_PER_OCTA OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_VERT_PER_FACE +#define OCTAHEDRON_VERT_ELEM_PER_OCTA OCTAHEDRON_VERT_PER_OCTA*3 + +/* 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., + +}; +/* 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_OCTA] = +{ + 0, 1, 2, + 0, 5, 1, + 0, 2, 4, + 0, 4, 5, + 3, 2, 1, + 3, 1, 5, + 3, 4, 2, + 3, 5, 4 +}; + +/* Cache of input to glDrawArrays */ +static GLboolean octahedronCached = FALSE; +static GLdouble octahedron_verts[OCTAHEDRON_VERT_ELEM_PER_OCTA]; +static GLdouble octahedron_norms[OCTAHEDRON_VERT_ELEM_PER_OCTA]; + +static void fghOctahedronGenerate() +{ + fghGenerateGeometry(OCTAHEDRON_NUM_FACES, OCTAHEDRON_NUM_VERT_PER_FACE, octahedron_v, octahedron_vi, octahedron_n, octahedron_verts, octahedron_norms); +} + /* -- Tetrahedron -- */ /* Magic Numbers: r0 = ( 1, 0, 0 ) * r1 = ( -1/3, 2 sqrt(2) / 3, 0 ) @@ -218,7 +289,7 @@ }; /* Vertex indices */ -static GLubyte tetr_vi[TETR_NUM_FACES*TETR_NUM_VERT_PER_FACE] = +static GLubyte tetr_vi[TETR_VERT_PER_TETR] = { 1, 3, 2, 0, 2, 3, @@ -228,8 +299,8 @@ /* 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 GLdouble tetr_verts[TETR_VERT_ELEM_PER_TETR]; +static GLdouble tetr_norms[TETR_VERT_ELEM_PER_TETR]; static void fghTetrahedronGenerate() { @@ -237,7 +308,7 @@ } /* -- Sierpinski Sponge -- */ -static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLdouble scale, double* vertices, double* normals ) +static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLdouble scale, GLdouble* vertices, GLdouble* normals ) { int i, j; if ( numLevels == 0 ) @@ -346,7 +417,7 @@ 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)); + GLdouble *vertices = malloc(CUBE_VERT_ELEM_PER_CUBE * sizeof(GLdouble)); for (i=0; i<CUBE_VERT_ELEM_PER_CUBE; i++) vertices[i] = dSize*cube_verts[i]; @@ -356,6 +427,17 @@ fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_CUBE,useWireMode); } +static void fghOctahedron( GLboolean useWireMode ) +{ + if (!octahedronCached) + { + fghOctahedronGenerate(); + octahedronCached = TRUE; + } + + fghDrawGeometry(GL_TRIANGLES,octahedron_verts,octahedron_norms,OCTAHEDRON_VERT_PER_OCTA,useWireMode); +} + static void fghTetrahedron( GLboolean useWireMode ) { if (!tetrCached) @@ -377,8 +459,8 @@ if (numTetr) { /* Allocate memory */ - vertices = malloc(numVert*3 * sizeof(double)); - normals = malloc(numVert*3 * sizeof(double)); + vertices = malloc(numVert*3 * sizeof(GLdouble)); + normals = malloc(numVert*3 * sizeof(GLdouble)); /* Generate elements */ fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals ); @@ -1096,48 +1178,6 @@ /* * */ -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 -} - -/* - * - */ static double icos_r[12][3] = { { 1.0, 0.0, 0.0 }, { 0.447213595500, 0.894427191000, 0.0 }, @@ -1329,15 +1369,15 @@ fghCube( dSize, FALSE ); } -void FGAPIENTRY glutWireTetrahedron( void ) +void FGAPIENTRY glutWireOctahedron( void ) { - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" ); - fghTetrahedron( TRUE ); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireOctahedron" ); + fghOctahedron( TRUE ); } -void FGAPIENTRY glutSolidTetrahedron( void ) +void FGAPIENTRY glutSolidOctahedron( void ) { - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" ); - fghTetrahedron( FALSE ); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidOctahedron" ); + fghOctahedron( FALSE ); } void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale ) @@ -1351,5 +1391,16 @@ fghSierpinskiSponge ( num_levels, offset, scale, FALSE ); } +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 ***/ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 07:55:23
|
Revision: 1154 http://freeglut.svn.sourceforge.net/freeglut/?rev=1154&view=rev Author: dcnieho Date: 2012-03-16 07:55:12 +0000 (Fri, 16 Mar 2012) Log Message: ----------- made some macros to reduce code duplication made naming completely consistent now Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 07:24:34 UTC (rev 1153) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 07:55:12 UTC (rev 1154) @@ -144,6 +144,17 @@ } /* -- 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);\ + } /* * In general, we build arrays with all vertices or normals. * We cant compress this and use glDrawElements as all combinations of @@ -154,8 +165,8 @@ #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 +#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] = { @@ -180,7 +191,7 @@ }; /* Vertex indices */ -static GLubyte cube_vi[CUBE_VERT_PER_CUBE] = +static GLubyte cube_vi[CUBE_VERT_PER_OBJ] = { 0,1,2,3, 0,3,4,5, @@ -189,23 +200,14 @@ 7,4,3,2, 4,7,6,5 }; +DECLARE_SHAPE_CACHE(cube,Cube,CUBE); -/* Cache of input to glDrawArrays */ -static GLboolean cubeCached = FALSE; -static GLdouble cube_verts[CUBE_VERT_ELEM_PER_CUBE]; -static GLdouble 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); -} - /* -- Octahedron -- */ #define OCTAHEDRON_NUM_VERT 6 #define OCTAHEDRON_NUM_FACES 8 #define OCTAHEDRON_NUM_VERT_PER_FACE 3 -#define OCTAHEDRON_VERT_PER_OCTA OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_VERT_PER_FACE -#define OCTAHEDRON_VERT_ELEM_PER_OCTA OCTAHEDRON_VERT_PER_OCTA*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 /* Vertex Coordinates */ static GLdouble octahedron_v[OCTAHEDRON_NUM_VERT*3] = @@ -233,7 +235,7 @@ }; /* Vertex indices */ -static GLubyte octahedron_vi[OCTAHEDRON_VERT_PER_OCTA] = +static GLubyte octahedron_vi[OCTAHEDRON_VERT_PER_OBJ] = { 0, 1, 2, 0, 5, 1, @@ -244,17 +246,8 @@ 3, 4, 2, 3, 5, 4 }; +DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON); -/* Cache of input to glDrawArrays */ -static GLboolean octahedronCached = FALSE; -static GLdouble octahedron_verts[OCTAHEDRON_VERT_ELEM_PER_OCTA]; -static GLdouble octahedron_norms[OCTAHEDRON_VERT_ELEM_PER_OCTA]; - -static void fghOctahedronGenerate() -{ - fghGenerateGeometry(OCTAHEDRON_NUM_FACES, OCTAHEDRON_NUM_VERT_PER_FACE, octahedron_v, octahedron_vi, octahedron_n, octahedron_verts, octahedron_norms); -} - /* -- Tetrahedron -- */ /* Magic Numbers: r0 = ( 1, 0, 0 ) * r1 = ( -1/3, 2 sqrt(2) / 3, 0 ) @@ -265,14 +258,14 @@ * * 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 +#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 tetr_v[TETR_NUM_VERT*3] = +static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] = { 1.0, 0.0, 0.0, -0.333333333333, 0.942809041582, 0.0, @@ -280,7 +273,7 @@ -0.333333333333, -0.471404520791, -0.816496580928 }; /* Normal Vectors */ -static GLdouble tetr_n[CUBE_NUM_FACES*3] = +static GLdouble tetrahedron_n[TETRAHEDRON_NUM_FACES*3] = { - 1.0, 0.0, 0.0, 0.333333333333, -0.942809041582, 0.0, @@ -289,60 +282,51 @@ }; /* Vertex indices */ -static GLubyte tetr_vi[TETR_VERT_PER_TETR] = +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); -/* Cache of input to glDrawArrays */ -static GLboolean tetrCached = FALSE; -static GLdouble tetr_verts[TETR_VERT_ELEM_PER_TETR]; -static GLdouble 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, GLdouble* vertices, GLdouble* normals ) { int i, j; if ( numLevels == 0 ) { - for (i=0; i<TETR_NUM_FACES; i++) + for (i=0; i<TETRAHEDRON_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 faceIdxVertIdx = i*TETRAHEDRON_NUM_VERT_PER_FACE; + for (j=0; j<TETRAHEDRON_NUM_VERT_PER_FACE; j++) { - int outIdx = i*TETR_NUM_VERT_PER_FACE*3+j*3; - int vertIdx = tetr_vi[faceIdxVertIdx+j]*3; + int outIdx = i*TETRAHEDRON_NUM_VERT_PER_FACE*3+j*3; + int vertIdx = tetrahedron_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]; + 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 ] = tetr_n[normIdx ]; - normals [outIdx+1] = tetr_n[normIdx+1]; - normals [outIdx+2] = tetr_n[normIdx+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)*TETR_VERT_ELEM_PER_TETR; + unsigned int stride = ipow(4,--numLevels)*TETRAHEDRON_VERT_ELEM_PER_OBJ; scale /= 2.0 ; - for ( i = 0 ; i < TETR_NUM_FACES ; i++ ) + for ( i = 0 ; i < TETRAHEDRON_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]; + 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 ); } } @@ -403,6 +387,16 @@ /* -- 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 ) { @@ -417,44 +411,24 @@ int i; /* Need to build new vertex list containing vertices for cube of different size */ - GLdouble *vertices = malloc(CUBE_VERT_ELEM_PER_CUBE * sizeof(GLdouble)); - for (i=0; i<CUBE_VERT_ELEM_PER_CUBE; i++) + 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_CUBE,useWireMode); + fghDrawGeometry(GL_QUADS,vertices ,cube_norms,CUBE_VERT_PER_OBJ,useWireMode); } else - fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_CUBE,useWireMode); + 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 fghOctahedron( GLboolean useWireMode ) -{ - if (!octahedronCached) - { - fghOctahedronGenerate(); - octahedronCached = TRUE; - } - - fghDrawGeometry(GL_TRIANGLES,octahedron_verts,octahedron_norms,OCTAHEDRON_VERT_PER_OCTA,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; + GLsizei numVert = numTetr*TETRAHEDRON_VERT_PER_OBJ; if (numTetr) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 08:36:59
|
Revision: 1155 http://freeglut.svn.sourceforge.net/freeglut/?rev=1155&view=rev Author: dcnieho Date: 2012-03-16 08:36:48 +0000 (Fri, 16 Mar 2012) Log Message: ----------- icosahedron also done wrote for easy declaring of interface functions Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 07:55:12 UTC (rev 1154) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 08:36:48 UTC (rev 1155) @@ -202,6 +202,83 @@ }; DECLARE_SHAPE_CACHE(cube,Cube,CUBE); +/* Icosahedron */ +#define ICOSAHEDRON_NUM_VERT 12 +#define ICOSAHEDRON_NUM_FACES 20 +#define ICOSAHEDRON_NUM_VERT_PER_FACE 3 +#define ICOSAHEDRON_VERT_PER_OBJ ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_VERT_PER_FACE +#define ICOSAHEDRON_VERT_ELEM_PER_OBJ ICOSAHEDRON_VERT_PER_OBJ*3 +/* Vertex Coordinates */ +static GLdouble icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = +{ + 1.0, 0.0, 0.0 , + 0.447213595500, 0.894427191000, 0.0 , + 0.447213595500, 0.276393202252, 0.850650808354, + 0.447213595500, -0.723606797748, 0.525731112119, + 0.447213595500, -0.723606797748, -0.525731112119, + 0.447213595500, 0.276393202252, -0.850650808354, + -0.447213595500, -0.894427191000, 0.0 , + -0.447213595500, -0.276393202252, 0.850650808354, + -0.447213595500, 0.723606797748, 0.525731112119, + -0.447213595500, 0.723606797748, -0.525731112119, + -0.447213595500, -0.276393202252, -0.850650808354, + -1.0, 0.0, 0.0 +}; +/* Normal Vectors: + * icosahedron_n[i][0] = ( icosahedron_v[icosahedron_vi[i][1]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) * ( icosahedron_v[icosahedron_vi[i][2]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) - ( icosahedron_v[icosahedron_vi[i][1]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) * ( icosahedron_v[icosahedron_vi[i][2]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) ; + * icosahedron_n[i][1] = ( icosahedron_v[icosahedron_vi[i][1]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) * ( icosahedron_v[icosahedron_vi[i][2]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) - ( icosahedron_v[icosahedron_vi[i][1]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) * ( icosahedron_v[icosahedron_vi[i][2]][2] - icosahedron_v[icosahedron_vi[i][0]][2] ) ; + * icosahedron_n[i][2] = ( icosahedron_v[icosahedron_vi[i][1]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) * ( icosahedron_v[icosahedron_vi[i][2]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) - ( icosahedron_v[icosahedron_vi[i][1]][1] - icosahedron_v[icosahedron_vi[i][0]][1] ) * ( icosahedron_v[icosahedron_vi[i][2]][0] - icosahedron_v[icosahedron_vi[i][0]][0] ) ; +*/ +static GLdouble icosahedron_n[ICOSAHEDRON_NUM_FACES*3] = +{ + 0.760845213037948, 0.470228201835026, 0.341640786498800, + 0.760845213036861, -0.179611190632978, 0.552786404500000, + 0.760845213033849, -0.581234022404097, 0, + 0.760845213036861, -0.179611190632978, -0.552786404500000, + 0.760845213037948, 0.470228201835026, -0.341640786498800, + 0.179611190628666, 0.760845213037948, 0.552786404498399, + 0.179611190634277, -0.290617011204044, 0.894427191000000, + 0.179611190633958, -0.940456403667806, 0, + 0.179611190634278, -0.290617011204044, -0.894427191000000, + 0.179611190628666, 0.760845213037948, -0.552786404498399, + -0.179611190633958, 0.940456403667806, 0, + -0.179611190634277, 0.290617011204044, 0.894427191000000, + -0.179611190628666, -0.760845213037948, 0.552786404498399, + -0.179611190628666, -0.760845213037948, -0.552786404498399, + -0.179611190634277, 0.290617011204044, -0.894427191000000, + -0.760845213036861, 0.179611190632978, -0.552786404500000, + -0.760845213033849, 0.581234022404097, 0, + -0.760845213036861, 0.179611190632978, 0.552786404500000, + -0.760845213037948, -0.470228201835026, 0.341640786498800, + -0.760845213037948, -0.470228201835026, -0.341640786498800, +}; + +/* Vertex indices */ +static GLubyte icosahedron_vi[ICOSAHEDRON_VERT_PER_OBJ] = +{ + 0, 1, 2 , + 0, 2, 3 , + 0, 3, 4 , + 0, 4, 5 , + 0, 5, 1 , + 1, 8, 2 , + 2, 7, 3 , + 3, 6, 4 , + 4, 10, 5 , + 5, 9, 1 , + 1, 9, 8 , + 2, 8, 7 , + 3, 7, 6 , + 4, 6, 10 , + 5, 10, 9 , + 11, 9, 10 , + 11, 8, 9 , + 11, 7, 8 , + 11, 6, 7 , + 11, 10, 6 +}; +DECLARE_SHAPE_CACHE(icosahedron,Icosahedron,ICOSAHEDRON); + /* -- Octahedron -- */ #define OCTAHEDRON_NUM_VERT 6 #define OCTAHEDRON_NUM_FACES 8 @@ -420,6 +497,7 @@ else fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_OBJ,useWireMode); } +DECLARE_INTERNAL_DRAW(icosahedron,Icosahedron,ICOSAHEDRON); DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON); DECLARE_INTERNAL_DRAW(tetrahedron,Tetrahedron,TETRAHEDRON); @@ -1152,93 +1230,6 @@ /* * */ -static double icos_r[12][3] = { - { 1.0, 0.0, 0.0 }, - { 0.447213595500, 0.894427191000, 0.0 }, - { 0.447213595500, 0.276393202252, 0.850650808354 }, - { 0.447213595500, -0.723606797748, 0.525731112119 }, - { 0.447213595500, -0.723606797748, -0.525731112119 }, - { 0.447213595500, 0.276393202252, -0.850650808354 }, - { -0.447213595500, -0.894427191000, 0.0 }, - { -0.447213595500, -0.276393202252, 0.850650808354 }, - { -0.447213595500, 0.723606797748, 0.525731112119 }, - { -0.447213595500, 0.723606797748, -0.525731112119 }, - { -0.447213595500, -0.276393202252, -0.850650808354 }, - { -1.0, 0.0, 0.0 } -}; - -static int icos_v [20][3] = { - { 0, 1, 2 }, - { 0, 2, 3 }, - { 0, 3, 4 }, - { 0, 4, 5 }, - { 0, 5, 1 }, - { 1, 8, 2 }, - { 2, 7, 3 }, - { 3, 6, 4 }, - { 4, 10, 5 }, - { 5, 9, 1 }, - { 1, 9, 8 }, - { 2, 8, 7 }, - { 3, 7, 6 }, - { 4, 6, 10 }, - { 5, 10, 9 }, - { 11, 9, 10 }, - { 11, 8, 9 }, - { 11, 7, 8 }, - { 11, 6, 7 }, - { 11, 10, 6 } -}; - -void FGAPIENTRY glutWireIcosahedron( void ) -{ - int i ; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireIcosahedron" ); - - for ( i = 0; i < 20; i++ ) - { - double normal[3] ; - normal[0] = ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) - ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) ; - normal[1] = ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) - ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) ; - normal[2] = ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) - ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3dv ( normal ) ; - glVertex3dv ( icos_r[icos_v[i][0]] ) ; - glVertex3dv ( icos_r[icos_v[i][1]] ) ; - glVertex3dv ( icos_r[icos_v[i][2]] ) ; - glEnd () ; - } -} - -/* - * - */ -void FGAPIENTRY glutSolidIcosahedron( void ) -{ - int i ; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidIcosahedron" ); - - glBegin ( GL_TRIANGLES ) ; - for ( i = 0; i < 20; i++ ) - { - double normal[3] ; - normal[0] = ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) - ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) ; - normal[1] = ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) - ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) ; - normal[2] = ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) - ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) ; - glNormal3dv ( normal ) ; - glVertex3dv ( icos_r[icos_v[i][0]] ) ; - glVertex3dv ( icos_r[icos_v[i][1]] ) ; - glVertex3dv ( icos_r[icos_v[i][2]] ) ; - } - - glEnd () ; -} - -/* - * - */ static double rdod_r[14][3] = { { 0.0, 0.0, 1.0 }, { 0.707106781187, 0.000000000000, 0.5 }, @@ -1329,9 +1320,19 @@ /* -- INTERFACE FUNCTIONS -------------------------------------------------- */ -/* - * Draws a wireframed cube. - */ +/* Macro to generate interface functions */ +#define DECLARE_SHAPE_INTERFACE(nameICaps)\ + void FGAPIENTRY glutWire##nameICaps( void )\ + {\ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWire"#nameICaps );\ + fgh##nameICaps( TRUE );\ + }\ + void FGAPIENTRY glutSolid##nameICaps( void )\ + {\ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolid"#nameICaps );\ + fgh##nameICaps( FALSE );\ + } + void FGAPIENTRY glutWireCube( GLdouble dSize ) { FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" ); @@ -1343,16 +1344,8 @@ fghCube( dSize, FALSE ); } -void FGAPIENTRY glutWireOctahedron( void ) -{ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireOctahedron" ); - fghOctahedron( TRUE ); -} -void FGAPIENTRY glutSolidOctahedron( void ) -{ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidOctahedron" ); - fghOctahedron( FALSE ); -} +DECLARE_SHAPE_INTERFACE(Icosahedron); +DECLARE_SHAPE_INTERFACE(Octahedron); void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale ) { @@ -1365,16 +1358,7 @@ fghSierpinskiSponge ( num_levels, offset, scale, FALSE ); } -void FGAPIENTRY glutWireTetrahedron( void ) -{ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" ); - fghTetrahedron( TRUE ); -} -void FGAPIENTRY glutSolidTetrahedron( void ) -{ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" ); - fghTetrahedron( FALSE ); -} +DECLARE_SHAPE_INTERFACE(Tetrahedron); /*** END OF FILE ***/ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 08:46:20
|
Revision: 1156 http://freeglut.svn.sourceforge.net/freeglut/?rev=1156&view=rev Author: dcnieho Date: 2012-03-16 08:46:13 +0000 (Fri, 16 Mar 2012) Log Message: ----------- RhombicDodecahedron moved to glVertexPointer Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 08:36:48 UTC (rev 1155) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 08:46:13 UTC (rev 1156) @@ -325,6 +325,66 @@ }; DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON); +/* -- RhombicDodecahedron -- */ +#define RHOMBICDODECAHEDRON_NUM_VERT 14 +#define RHOMBICDODECAHEDRON_NUM_FACES 12 +#define RHOMBICDODECAHEDRON_NUM_VERT_PER_FACE 4 +#define RHOMBICDODECAHEDRON_VERT_PER_OBJ RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_VERT_PER_FACE +#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ RHOMBICDODECAHEDRON_VERT_PER_OBJ*3 + +/* Vertex Coordinates */ +static GLdouble rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] = +{ + 0.0, 0.0, 1.0, + 0.707106781187, 0.0 , 0.5, + 0.0 , 0.707106781187, 0.5, + -0.707106781187, 0.0 , 0.5, + 0.0 , -0.707106781187, 0.5, + 0.707106781187, 0.707106781187, 0.0, + -0.707106781187, 0.707106781187, 0.0, + -0.707106781187, -0.707106781187, 0.0, + 0.707106781187, -0.707106781187, 0.0, + 0.707106781187, 0.0 , -0.5, + 0.0 , 0.707106781187, -0.5, + -0.707106781187, 0.0 , -0.5, + 0.0 , -0.707106781187, -0.5, + 0.0, 0.0, -1.0 +}; +/* Normal Vectors */ +static GLdouble rhombicdodecahedron_n[RHOMBICDODECAHEDRON_NUM_FACES*3] = +{ + 0.353553390594, 0.353553390594, 0.5, + -0.353553390594, 0.353553390594, 0.5, + -0.353553390594, -0.353553390594, 0.5, + 0.353553390594, -0.353553390594, 0.5, + 0.0 , 1.0 , 0.0, + -1.0 , 0.0 , 0.0, + 0.0 , -1.0 , 0.0, + 1.0 , 0.0 , 0.0, + 0.353553390594, 0.353553390594, -0.5, + -0.353553390594, 0.353553390594, -0.5, + -0.353553390594, -0.353553390594, -0.5, + 0.353553390594, -0.353553390594, -0.5 +}; + +/* Vertex indices */ +static GLubyte rhombicdodecahedron_vi[RHOMBICDODECAHEDRON_VERT_PER_OBJ] = +{ + 0, 1, 5, 2, + 0, 2, 6, 3, + 0, 3, 7, 4, + 0, 4, 8, 1, + 5, 10, 6, 2, + 6, 11, 7, 3, + 7, 12, 8, 4, + 8, 9, 5, 1, + 5, 9, 13, 10, + 6, 10, 13, 11, + 7, 11, 13, 12, + 8, 12, 13, 9 +}; +DECLARE_SHAPE_CACHE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); + /* -- Tetrahedron -- */ /* Magic Numbers: r0 = ( 1, 0, 0 ) * r1 = ( -1/3, 2 sqrt(2) / 3, 0 ) @@ -464,7 +524,7 @@ /* -- INTERNAL DRAWING functions to avoid code duplication ------------- */ -#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps)\ +#define DECLARE_INTERNAL_DRAW(vertexMode,name,nameICaps,nameCaps)\ static void fgh##nameICaps( GLboolean useWireMode )\ {\ if (!name##Cached)\ @@ -472,7 +532,7 @@ fgh##nameICaps##Generate();\ name##Cached = TRUE;\ }\ - fghDrawGeometry(GL_TRIANGLES,name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ,useWireMode);\ + fghDrawGeometry(vertexMode,name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ,useWireMode);\ } static void fghCube( GLdouble dSize, GLboolean useWireMode ) @@ -497,10 +557,12 @@ else fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_OBJ,useWireMode); } -DECLARE_INTERNAL_DRAW(icosahedron,Icosahedron,ICOSAHEDRON); -DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON); -DECLARE_INTERNAL_DRAW(tetrahedron,Tetrahedron,TETRAHEDRON); +DECLARE_INTERNAL_DRAW(GL_TRIANGLES,icosahedron,Icosahedron,ICOSAHEDRON); +DECLARE_INTERNAL_DRAW(GL_TRIANGLES,octahedron,Octahedron,OCTAHEDRON); +DECLARE_INTERNAL_DRAW(GL_QUADS,rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); +DECLARE_INTERNAL_DRAW(GL_TRIANGLES,tetrahedron,Tetrahedron,TETRAHEDRON); + static void fghSierpinskiSponge ( int numLevels, GLdouble offset[3], GLdouble scale, GLboolean useWireMode ) { GLdouble *vertices; @@ -1227,98 +1289,8 @@ glEnd () ; } -/* - * - */ -static double rdod_r[14][3] = { - { 0.0, 0.0, 1.0 }, - { 0.707106781187, 0.000000000000, 0.5 }, - { 0.000000000000, 0.707106781187, 0.5 }, - { -0.707106781187, 0.000000000000, 0.5 }, - { 0.000000000000, -0.707106781187, 0.5 }, - { 0.707106781187, 0.707106781187, 0.0 }, - { -0.707106781187, 0.707106781187, 0.0 }, - { -0.707106781187, -0.707106781187, 0.0 }, - { 0.707106781187, -0.707106781187, 0.0 }, - { 0.707106781187, 0.000000000000, -0.5 }, - { 0.000000000000, 0.707106781187, -0.5 }, - { -0.707106781187, 0.000000000000, -0.5 }, - { 0.000000000000, -0.707106781187, -0.5 }, - { 0.0, 0.0, -1.0 } -} ; -static int rdod_v [12][4] = { - { 0, 1, 5, 2 }, - { 0, 2, 6, 3 }, - { 0, 3, 7, 4 }, - { 0, 4, 8, 1 }, - { 5, 10, 6, 2 }, - { 6, 11, 7, 3 }, - { 7, 12, 8, 4 }, - { 8, 9, 5, 1 }, - { 5, 9, 13, 10 }, - { 6, 10, 13, 11 }, - { 7, 11, 13, 12 }, - { 8, 12, 13, 9 } -}; -static double rdod_n[12][3] = { - { 0.353553390594, 0.353553390594, 0.5 }, - { -0.353553390594, 0.353553390594, 0.5 }, - { -0.353553390594, -0.353553390594, 0.5 }, - { 0.353553390594, -0.353553390594, 0.5 }, - { 0.000000000000, 1.000000000000, 0.0 }, - { -1.000000000000, 0.000000000000, 0.0 }, - { 0.000000000000, -1.000000000000, 0.0 }, - { 1.000000000000, 0.000000000000, 0.0 }, - { 0.353553390594, 0.353553390594, -0.5 }, - { -0.353553390594, 0.353553390594, -0.5 }, - { -0.353553390594, -0.353553390594, -0.5 }, - { 0.353553390594, -0.353553390594, -0.5 } -}; - -void FGAPIENTRY glutWireRhombicDodecahedron( void ) -{ - int i ; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireRhombicDodecahedron" ); - - for ( i = 0; i < 12; i++ ) - { - glBegin ( GL_LINE_LOOP ) ; - glNormal3dv ( rdod_n[i] ) ; - glVertex3dv ( rdod_r[rdod_v[i][0]] ) ; - glVertex3dv ( rdod_r[rdod_v[i][1]] ) ; - glVertex3dv ( rdod_r[rdod_v[i][2]] ) ; - glVertex3dv ( rdod_r[rdod_v[i][3]] ) ; - glEnd () ; - } -} - -/* - * - */ -void FGAPIENTRY glutSolidRhombicDodecahedron( void ) -{ - int i ; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidRhombicDodecahedron" ); - - glBegin ( GL_QUADS ) ; - for ( i = 0; i < 12; i++ ) - { - glNormal3dv ( rdod_n[i] ) ; - glVertex3dv ( rdod_r[rdod_v[i][0]] ) ; - glVertex3dv ( rdod_r[rdod_v[i][1]] ) ; - glVertex3dv ( rdod_r[rdod_v[i][2]] ) ; - glVertex3dv ( rdod_r[rdod_v[i][3]] ) ; - } - - glEnd () ; -} - - - /* -- INTERFACE FUNCTIONS -------------------------------------------------- */ /* Macro to generate interface functions */ #define DECLARE_SHAPE_INTERFACE(nameICaps)\ @@ -1346,6 +1318,7 @@ DECLARE_SHAPE_INTERFACE(Icosahedron); DECLARE_SHAPE_INTERFACE(Octahedron); +DECLARE_SHAPE_INTERFACE(RhombicDodecahedron); void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale ) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-16 11:06:32
|
Revision: 1157 http://freeglut.svn.sourceforge.net/freeglut/?rev=1157&view=rev Author: dcnieho Date: 2012-03-16 11:06:23 +0000 (Fri, 16 Mar 2012) Log Message: ----------- cube now done with triangles, internal edges on each face hidden with edge flag Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 08:46:13 UTC (rev 1156) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-16 11:06:23 UTC (rev 1157) @@ -29,6 +29,9 @@ #include "fg_internal.h" /* + * + * Need more types of polyhedra? See CPolyhedron in MRPT + * * TODO BEFORE THE STABLE RELEASE: * * See fghTetrahedron @@ -67,7 +70,7 @@ * useWireMode controls the drawing of solids (false) or wire frame * versions (TRUE) of the geometry you pass */ -static void fghDrawGeometry(GLenum vertexMode, GLdouble* vertices, GLdouble* normals, GLsizei numVertices, GLboolean useWireMode) +static void fghDrawGeometry(GLenum vertexMode, GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLboolean useWireMode) { if (useWireMode) { @@ -79,13 +82,19 @@ { glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); + if (edgeFlags) + glEnableClientState(GL_EDGE_FLAG_ARRAY); glVertexPointer(3, GL_DOUBLE, 0, vertices); glNormalPointer(GL_DOUBLE, 0, normals); + if (edgeFlags) + glEdgeFlagPointer(0,edgeFlags); glDrawArrays(vertexMode, 0, numVertices); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); + if (edgeFlags) + glDisableClientState(GL_EDGE_FLAG_ARRAY); } else { @@ -93,6 +102,7 @@ glBegin(vertexMode); for(i=0; i<numVertices; i++) { + glEdgeFlag(edgeFlags[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); @@ -107,7 +117,7 @@ } } -static void fghGenerateGeometry(int numFaces, int numVertPerFace, GLdouble *vertices, GLubyte* vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut) +static void fghGenerateGeometryWithEdgeFlag(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLboolean *edgeFlags, GLdouble *vertOut, GLdouble *normOut, GLboolean *edgeFlagsOut) { int i,j; /* @@ -119,10 +129,10 @@ for (i=0; i<numFaces; i++) { int normIdx = i*3; - int faceIdxVertIdx = i*numVertPerFace; - for (j=0; j<numVertPerFace; j++) + int faceIdxVertIdx = i*numEdgePerFace; // index to first element of "row" in vertex indices + for (j=0; j<numEdgePerFace; j++) { - int outIdx = i*numVertPerFace*3+j*3; + int outIdx = i*numEdgePerFace*3+j*3; int vertIdx = vertIndices[faceIdxVertIdx+j]*3; vertOut[outIdx ] = vertices[vertIdx ]; @@ -132,11 +142,19 @@ normOut[outIdx ] = normals [normIdx ]; normOut[outIdx+1] = normals [normIdx+1]; normOut[outIdx+2] = normals [normIdx+2]; + + if (edgeFlagsOut) + edgeFlagsOut[faceIdxVertIdx+j] = edgeFlags[j]; } } } +static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut) +{ + fghGenerateGeometryWithEdgeFlag(numFaces, numEdgePerFace, vertices, vertIndices, normals, NULL, vertOut, normOut, NULL); +} + /* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */ static unsigned int ipow (int x, unsigned int y) { @@ -151,10 +169,21 @@ static GLdouble name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ static void fgh##nameICaps##Generate()\ {\ - fghGenerateGeometry(nameCaps##_NUM_FACES, nameCaps##_NUM_VERT_PER_FACE,\ + fghGenerateGeometry(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ name##_v, name##_vi, name##_n,\ name##_verts, name##_norms);\ } +#define DECLARE_SHAPE_CACHE_WITH_EDGE_FLAG(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 GLboolean name##_edgeFlags[nameCaps##_VERT_PER_OBJ];\ + static void fgh##nameICaps##Generate()\ + {\ + fghGenerateGeometryWithEdgeFlag(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ + name##_v, name##_vi, name##_n, name##_ef,\ + name##_verts, name##_norms, name##_edgeFlags);\ + } /* * In general, we build arrays with all vertices or normals. * We cant compress this and use glDrawElements as all combinations of @@ -164,9 +193,9 @@ /* -- 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 +#define CUBE_NUM_EDGE_PER_FACE 4+2 /* 1.5 is overhead factor when drawing quads as triangles */ +#define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES)*(CUBE_NUM_EDGE_PER_FACE) +#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ)*3 /* Vertex Coordinates */ static GLdouble cube_v[CUBE_NUM_VERT*3] = { @@ -193,20 +222,25 @@ /* Vertex indices */ static GLubyte cube_vi[CUBE_VERT_PER_OBJ] = { - 0,1,2,3, - 0,3,4,5, - 0,5,6,1, - 1,6,7,2, - 7,4,3,2, - 4,7,6,5 + 0,1,2,0,2,3, + 0,3,4,0,4,5, + 0,5,6,0,6,1, + 1,6,7,1,7,2, + 7,4,3,7,3,2, + 4,7,6,4,6,5 }; -DECLARE_SHAPE_CACHE(cube,Cube,CUBE); +/* edge flags */ +static GLboolean cube_ef[CUBE_NUM_EDGE_PER_FACE] = +{ + 1,1,0,0,1,1 +}; +DECLARE_SHAPE_CACHE_WITH_EDGE_FLAG(cube,Cube,CUBE); /* Icosahedron */ #define ICOSAHEDRON_NUM_VERT 12 #define ICOSAHEDRON_NUM_FACES 20 -#define ICOSAHEDRON_NUM_VERT_PER_FACE 3 -#define ICOSAHEDRON_VERT_PER_OBJ ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_VERT_PER_FACE +#define ICOSAHEDRON_NUM_EDGE_PER_FACE 3 +#define ICOSAHEDRON_VERT_PER_OBJ ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE #define ICOSAHEDRON_VERT_ELEM_PER_OBJ ICOSAHEDRON_VERT_PER_OBJ*3 /* Vertex Coordinates */ static GLdouble icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = @@ -282,8 +316,8 @@ /* -- 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_NUM_EDGE_PER_FACE 3 +#define OCTAHEDRON_VERT_PER_OBJ OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE #define OCTAHEDRON_VERT_ELEM_PER_OBJ OCTAHEDRON_VERT_PER_OBJ*3 /* Vertex Coordinates */ @@ -328,8 +362,8 @@ /* -- RhombicDodecahedron -- */ #define RHOMBICDODECAHEDRON_NUM_VERT 14 #define RHOMBICDODECAHEDRON_NUM_FACES 12 -#define RHOMBICDODECAHEDRON_NUM_VERT_PER_FACE 4 -#define RHOMBICDODECAHEDRON_VERT_PER_OBJ RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_VERT_PER_FACE +#define RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE 4 +#define RHOMBICDODECAHEDRON_VERT_PER_OBJ RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE #define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ RHOMBICDODECAHEDRON_VERT_PER_OBJ*3 /* Vertex Coordinates */ @@ -397,8 +431,8 @@ */ #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_NUM_EDGE_PER_FACE 3 +#define TETRAHEDRON_VERT_PER_OBJ TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE #define TETRAHEDRON_VERT_ELEM_PER_OBJ TETRAHEDRON_VERT_PER_OBJ*3 /* Vertex Coordinates */ @@ -437,10 +471,10 @@ 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 faceIdxVertIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE; + for (j=0; j<TETRAHEDRON_NUM_EDGE_PER_FACE; j++) { - int outIdx = i*TETRAHEDRON_NUM_VERT_PER_FACE*3+j*3; + int outIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE*3+j*3; int vertIdx = tetrahedron_vi[faceIdxVertIdx+j]*3; vertices[outIdx ] = offset[0] + scale * tetrahedron_v[vertIdx ]; @@ -530,9 +564,9 @@ if (!name##Cached)\ {\ fgh##nameICaps##Generate();\ - name##Cached = TRUE;\ + name##Cached = GL_TRUE;\ }\ - fghDrawGeometry(vertexMode,name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ,useWireMode);\ + fghDrawGeometry(vertexMode,name##_verts,name##_norms,NULL,nameCaps##_VERT_PER_OBJ,useWireMode);\ } static void fghCube( GLdouble dSize, GLboolean useWireMode ) @@ -540,7 +574,7 @@ if (!cubeCached) { fghCubeGenerate(); - cubeCached = TRUE; + cubeCached = GL_TRUE; } if (dSize!=1.) @@ -552,10 +586,10 @@ 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); + fghDrawGeometry(GL_TRIANGLES,vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ,useWireMode); } else - fghDrawGeometry(GL_QUADS,cube_verts,cube_norms,CUBE_VERT_PER_OBJ,useWireMode); + fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ,useWireMode); } DECLARE_INTERNAL_DRAW(GL_TRIANGLES,icosahedron,Icosahedron,ICOSAHEDRON); @@ -580,7 +614,7 @@ fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals ); /* Draw and cleanup */ - fghDrawGeometry(GL_TRIANGLES,vertices,normals,numVert,useWireMode); + fghDrawGeometry(GL_TRIANGLES,vertices,normals,NULL,numVert,useWireMode); free(vertices); free(normals ); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 00:32:15
|
Revision: 1163 http://freeglut.svn.sourceforge.net/freeglut/?rev=1163&view=rev Author: dcnieho Date: 2012-03-17 00:32:08 +0000 (Sat, 17 Mar 2012) Log Message: ----------- implemented scheme for automatic square and pentagon decomposition and edgeflag generation Works for cube, RhombicDodecahedron temporarily broken (probably due to incorrect vertex order for decomposition method) Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 00:21:40 UTC (rev 1162) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 00:32:08 UTC (rev 1163) @@ -117,9 +117,40 @@ } } -static void fghGenerateGeometryWithEdgeFlag(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLboolean *edgeFlags, GLdouble *vertOut, GLdouble *normOut, GLboolean *edgeFlagsOut) +/* triangle decomposition and associated edgeFlags + * be careful to keep winding of all triangles counter-clockwise, + * assuming that input has correct winding... + */ +static GLubyte vertSamp3[3] = {0,1,2}; +static GLubyte vertSamp4[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */ +static GLubyte vertSamp5[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */ +static GLboolean edgeFlag3[3] = {1,1,1}; /* triangles remain triangles, all edges are external */ +static GLboolean edgeFlag4[6] = {1,1,0, 0,1,1}; +static GLboolean edgeFlag5[9] = {1,1,0, 0,0,1, 0,1,1}; + +static void fghGenerateGeometryWithEdgeFlag(int numFaces, int numEdgePerFaceIn, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLboolean *edgeFlagsOut) { - int i,j; + int i,j,numEdgePerFaceOut; + GLubyte *vertSamps = NULL; + GLboolean *edgeFlags = NULL; + switch (numEdgePerFaceIn) + { + case 3: + vertSamps = vertSamp3; + edgeFlags = edgeFlag3; + numEdgePerFaceOut = 3; /* 3 output vertices for each face */ + break; + case 4: + vertSamps = vertSamp4; + edgeFlags = edgeFlag4; + numEdgePerFaceOut = 6; /* 6 output vertices for each face */ + break; + case 5: + vertSamps = vertSamp5; + edgeFlags = edgeFlag5; + numEdgePerFaceOut = 9; /* 9 output vertices for each face */ + break; + } /* * Build array with vertices from vertex coordinates and vertex indices * Do same for normals. @@ -129,11 +160,12 @@ for (i=0; i<numFaces; i++) { int normIdx = i*3; - int faceIdxVertIdx = i*numEdgePerFace; // index to first element of "row" in vertex indices - for (j=0; j<numEdgePerFace; j++) + int faceIdxVertIdx = i*numEdgePerFaceIn; // index to first element of "row" in vertex indices + for (j=0; j<numEdgePerFaceOut; j++) { - int outIdx = i*numEdgePerFace*3+j*3; - int vertIdx = vertIndices[faceIdxVertIdx+j]*3; + int outIdx = i*numEdgePerFaceOut*3+j*3; + int vertIdx = vertIndices[faceIdxVertIdx+vertSamps[j]]*3; + printf("%i,",outIdx); vertOut[outIdx ] = vertices[vertIdx ]; vertOut[outIdx+1] = vertices[vertIdx+1]; @@ -144,14 +176,16 @@ normOut[outIdx+2] = normals [normIdx+2]; if (edgeFlagsOut) - edgeFlagsOut[faceIdxVertIdx+j] = edgeFlags[j]; + edgeFlagsOut[i*numEdgePerFaceOut+j] = edgeFlags[j]; } + printf("\n"); } + printf("\n"); } static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut) { - fghGenerateGeometryWithEdgeFlag(numFaces, numEdgePerFace, vertices, vertIndices, normals, NULL, vertOut, normOut, NULL); + fghGenerateGeometryWithEdgeFlag(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL); } @@ -173,15 +207,15 @@ name##_v, name##_vi, name##_n,\ name##_verts, name##_norms);\ } -#define DECLARE_SHAPE_CACHE_WITH_EDGE_FLAG(name,nameICaps,nameCaps)\ +#define DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(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 GLboolean name##_edgeFlags[nameCaps##_VERT_PER_OBJ];\ + static GLboolean name##_edgeFlags[nameCaps##_VERT_PER_OBJ_TRI];\ static void fgh##nameICaps##Generate()\ {\ fghGenerateGeometryWithEdgeFlag(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ - name##_v, name##_vi, name##_n, name##_ef,\ + name##_v, name##_vi, name##_n,\ name##_verts, name##_norms, name##_edgeFlags);\ } /* @@ -193,9 +227,10 @@ /* -- Cube -- */ #define CUBE_NUM_VERT 8 #define CUBE_NUM_FACES 6 -#define CUBE_NUM_EDGE_PER_FACE 4+2 /* 1.5 is overhead factor when drawing quads as triangles */ -#define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES)*(CUBE_NUM_EDGE_PER_FACE) -#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ)*3 +#define CUBE_NUM_EDGE_PER_FACE 4 +#define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES*CUBE_NUM_EDGE_PER_FACE) +#define CUBE_VERT_PER_OBJ_TRI (CUBE_VERT_PER_OBJ+CUBE_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ +#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble cube_v[CUBE_NUM_VERT*3] = { @@ -222,26 +257,22 @@ /* Vertex indices */ static GLubyte cube_vi[CUBE_VERT_PER_OBJ] = { - 0,1,2,0,2,3, - 0,3,4,0,4,5, - 0,5,6,0,6,1, - 1,6,7,1,7,2, - 7,4,3,7,3,2, - 4,7,6,4,6,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 }; -/* edge flags */ -static GLboolean cube_ef[CUBE_NUM_EDGE_PER_FACE] = -{ - 1,1,0,0,1,1 -}; -DECLARE_SHAPE_CACHE_WITH_EDGE_FLAG(cube,Cube,CUBE); +DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE); /* Icosahedron */ #define ICOSAHEDRON_NUM_VERT 12 #define ICOSAHEDRON_NUM_FACES 20 #define ICOSAHEDRON_NUM_EDGE_PER_FACE 3 -#define ICOSAHEDRON_VERT_PER_OBJ ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE -#define ICOSAHEDRON_VERT_ELEM_PER_OBJ ICOSAHEDRON_VERT_PER_OBJ*3 +#define ICOSAHEDRON_VERT_PER_OBJ (ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE) +#define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ +#define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = { @@ -317,8 +348,9 @@ #define OCTAHEDRON_NUM_VERT 6 #define OCTAHEDRON_NUM_FACES 8 #define OCTAHEDRON_NUM_EDGE_PER_FACE 3 -#define OCTAHEDRON_VERT_PER_OBJ OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE -#define OCTAHEDRON_VERT_ELEM_PER_OBJ OCTAHEDRON_VERT_PER_OBJ*3 +#define OCTAHEDRON_VERT_PER_OBJ (OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE) +#define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ +#define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble octahedron_v[OCTAHEDRON_NUM_VERT*3] = @@ -363,8 +395,9 @@ #define RHOMBICDODECAHEDRON_NUM_VERT 14 #define RHOMBICDODECAHEDRON_NUM_FACES 12 #define RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE 4 -#define RHOMBICDODECAHEDRON_VERT_PER_OBJ RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE -#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ RHOMBICDODECAHEDRON_VERT_PER_OBJ*3 +#define RHOMBICDODECAHEDRON_VERT_PER_OBJ (RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE) +#define RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ +#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] = @@ -417,7 +450,7 @@ 7, 11, 13, 12, 8, 12, 13, 9 }; -DECLARE_SHAPE_CACHE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); +DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); /* -- Tetrahedron -- */ /* Magic Numbers: r0 = ( 1, 0, 0 ) @@ -432,8 +465,9 @@ #define TETRAHEDRON_NUM_VERT 4 #define TETRAHEDRON_NUM_FACES 4 #define TETRAHEDRON_NUM_EDGE_PER_FACE 3 -#define TETRAHEDRON_VERT_PER_OBJ TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE -#define TETRAHEDRON_VERT_ELEM_PER_OBJ TETRAHEDRON_VERT_PER_OBJ*3 +#define TETRAHEDRON_VERT_PER_OBJ (TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE) +#define TETRAHEDRON_VERT_PER_OBJ_TRI TETRAHEDRON_VERT_PER_OBJ +#define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] = @@ -566,7 +600,7 @@ fgh##nameICaps##Generate();\ name##Cached = GL_TRUE;\ }\ - fghDrawGeometry(vertexMode,name##_verts,name##_norms,NULL,nameCaps##_VERT_PER_OBJ,useWireMode);\ + fghDrawGeometry(vertexMode,name##_verts,name##_norms,NULL,nameCaps##_VERT_PER_OBJ_TRI,useWireMode);\ } static void fghCube( GLdouble dSize, GLboolean useWireMode ) @@ -586,10 +620,10 @@ for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++) vertices[i] = dSize*cube_verts[i]; - fghDrawGeometry(GL_TRIANGLES,vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ,useWireMode); + fghDrawGeometry(GL_TRIANGLES,vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); } else - fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ,useWireMode); + fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); } DECLARE_INTERNAL_DRAW(GL_TRIANGLES,icosahedron,Icosahedron,ICOSAHEDRON); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 01:35:17
|
Revision: 1164 http://freeglut.svn.sourceforge.net/freeglut/?rev=1164&view=rev Author: dcnieho Date: 2012-03-17 01:35:11 +0000 (Sat, 17 Mar 2012) Log Message: ----------- was still trying to draw RhombicDodecahedron as GL_QUAD, of course it doesn't work Made internal draw macro for case with edge flags Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 00:32:08 UTC (rev 1163) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 01:35:11 UTC (rev 1164) @@ -591,8 +591,8 @@ } -/* -- INTERNAL DRAWING functions to avoid code duplication ------------- */ -#define DECLARE_INTERNAL_DRAW(vertexMode,name,nameICaps,nameCaps)\ +/* -- INTERNAL DRAWING functions --------------------------------------- */ +#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,edgeFlags)\ static void fgh##nameICaps( GLboolean useWireMode )\ {\ if (!name##Cached)\ @@ -600,8 +600,10 @@ fgh##nameICaps##Generate();\ name##Cached = GL_TRUE;\ }\ - fghDrawGeometry(vertexMode,name##_verts,name##_norms,NULL,nameCaps##_VERT_PER_OBJ_TRI,useWireMode);\ + fghDrawGeometry(GL_TRIANGLES,name##_verts,name##_norms,edgeFlags,nameCaps##_VERT_PER_OBJ_TRI,useWireMode);\ } +#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL) +#define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_edgeFlags) static void fghCube( GLdouble dSize, GLboolean useWireMode ) { @@ -626,10 +628,10 @@ fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); } -DECLARE_INTERNAL_DRAW(GL_TRIANGLES,icosahedron,Icosahedron,ICOSAHEDRON); -DECLARE_INTERNAL_DRAW(GL_TRIANGLES,octahedron,Octahedron,OCTAHEDRON); -DECLARE_INTERNAL_DRAW(GL_QUADS,rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); -DECLARE_INTERNAL_DRAW(GL_TRIANGLES,tetrahedron,Tetrahedron,TETRAHEDRON); +DECLARE_INTERNAL_DRAW(icosahedron,Icosahedron,ICOSAHEDRON); +DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON); +DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); +DECLARE_INTERNAL_DRAW(tetrahedron,Tetrahedron,TETRAHEDRON); static void fghSierpinskiSponge ( int numLevels, GLdouble offset[3], GLdouble scale, GLboolean useWireMode ) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 01:36:14
|
Revision: 1165 http://freeglut.svn.sourceforge.net/freeglut/?rev=1165&view=rev Author: dcnieho Date: 2012-03-17 01:36:08 +0000 (Sat, 17 Mar 2012) Log Message: ----------- removing some debug code Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 01:35:11 UTC (rev 1164) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 01:36:08 UTC (rev 1165) @@ -165,7 +165,6 @@ { int outIdx = i*numEdgePerFaceOut*3+j*3; int vertIdx = vertIndices[faceIdxVertIdx+vertSamps[j]]*3; - printf("%i,",outIdx); vertOut[outIdx ] = vertices[vertIdx ]; vertOut[outIdx+1] = vertices[vertIdx+1]; @@ -178,9 +177,7 @@ if (edgeFlagsOut) edgeFlagsOut[i*numEdgePerFaceOut+j] = edgeFlags[j]; } - printf("\n"); } - printf("\n"); } static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 02:06:28
|
Revision: 1166 http://freeglut.svn.sourceforge.net/freeglut/?rev=1166&view=rev Author: dcnieho Date: 2012-03-17 02:06:21 +0000 (Sat, 17 Mar 2012) Log Message: ----------- Done dodecahedron. Nice, this just worked! Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 01:36:08 UTC (rev 1165) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:06:21 UTC (rev 1166) @@ -263,7 +263,84 @@ }; DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE); -/* Icosahedron */ +/* -- Dodecahedron -- */ +/* Magic Numbers: It is possible to create a dodecahedron by attaching two + * pentagons to each face of of a cube. The coordinates of the points are: + * (+-x,0, z); (+-1, 1, 1); (0, z, x ) + * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or + * x = 0.61803398875 and z = 1.61803398875. + */ +#define DODECAHEDRON_NUM_VERT 20 +#define DODECAHEDRON_NUM_FACES 12 +#define DODECAHEDRON_NUM_EDGE_PER_FACE 5 +#define DODECAHEDRON_VERT_PER_OBJ (DODECAHEDRON_NUM_FACES*DODECAHEDRON_NUM_EDGE_PER_FACE) +#define DODECAHEDRON_VERT_PER_OBJ_TRI (DODECAHEDRON_VERT_PER_OBJ+DODECAHEDRON_NUM_FACES*4) /* 4 extra edges per face when drawing pentagons as triangles */ +#define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ_TRI*3) +/* Vertex Coordinates */ +static GLdouble dodecahedron_v[DODECAHEDRON_NUM_VERT*3] = +{ + 0.0 , 1.61803398875, 0.61803398875, + -1.0 , 1.0 , 1.0 , + -0.61803398875, 0.0 , 1.61803398875, + 0.61803398875, 0.0 , 1.61803398875, + 1.0 , 1.0 , 1.0 , + 0.0 , 1.61803398875, -0.61803398875, + 1.0 , 1.0 , -1.0 , + 0.61803398875, 0.0 , -1.61803398875, + -0.61803398875, 0.0 , -1.61803398875, + -1.0 , 1.0 , -1.0 , + 0.0 , -1.61803398875, 0.61803398875, + 1.0 , -1.0 , 1.0 , + -1.0 , -1.0 , 1.0 , + 0.0 , -1.61803398875, -0.61803398875, + -1.0 , -1.0 , -1.0 , + 1.0 , -1.0 , -1.0 , + 1.61803398875, -0.61803398875, 0.0 , + 1.61803398875, 0.61803398875, 0.0 , + -1.61803398875, 0.61803398875, 0.0 , + -1.61803398875, -0.61803398875, 0.0 +}; +/* Normal Vectors */ +static GLdouble dodecahedron_n[DODECAHEDRON_NUM_FACES*3] = +{ + 0.0 , 0.525731112119, 0.850650808354, + 0.0 , 0.525731112119, -0.850650808354, + 0.0 , -0.525731112119, 0.850650808354, + 0.0 , -0.525731112119, -0.850650808354, + + 0.850650808354, 0.0 , 0.525731112119, + -0.850650808354, 0.0 , 0.525731112119, + 0.850650808354, 0.0 , -0.525731112119, + -0.850650808354, 0.0 , -0.525731112119, + + 0.525731112119, 0.850650808354, 0.0 , + 0.525731112119, -0.850650808354, 0.0 , + -0.525731112119, 0.850650808354, 0.0 , + -0.525731112119, -0.850650808354, 0.0 , +}; + +/* Vertex indices */ +static GLubyte dodecahedron_vi[DODECAHEDRON_VERT_PER_OBJ] = +{ + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 10, 11, 3, 2, 12, + 13, 14, 8, 7, 15, + + 3, 11, 16, 17, 4, + 2, 1, 18, 19, 12, + 7, 6, 17, 16, 15, + 8, 14, 19, 18, 9, + + 17, 6, 5, 0, 4, + 16, 11, 10, 13, 15, + 18, 1, 0, 5, 9, + 19, 14, 13, 10, 12 +}; +DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON); + + +/* -- Icosahedron -- */ #define ICOSAHEDRON_NUM_VERT 12 #define ICOSAHEDRON_NUM_FACES 20 #define ICOSAHEDRON_NUM_EDGE_PER_FACE 3 @@ -625,6 +702,7 @@ fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); } +DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON); DECLARE_INTERNAL_DRAW(icosahedron,Icosahedron,ICOSAHEDRON); DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON); DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); @@ -1250,114 +1328,8 @@ glPopMatrix(); } -/* - * - */ -void FGAPIENTRY glutWireDodecahedron( void ) -{ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireDodecahedron" ); - /* Magic Numbers: It is possible to create a dodecahedron by attaching two pentagons to each face of - * of a cube. The coordinates of the points are: - * (+-x,0, z); (+-1, 1, 1); (0, z, x ) - * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or - * x = 0.61803398875 and z = 1.61803398875. - */ - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.0, 0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.0, 0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.0, -0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.0, -0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( -0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( -0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ; - glEnd () ; - - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( 0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( -0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_LINE_LOOP ) ; - glNormal3d ( -0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ; - glEnd () ; -} - -/* - * - */ -void FGAPIENTRY glutSolidDodecahedron( void ) -{ - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidDodecahedron" ); - - /* Magic Numbers: It is possible to create a dodecahedron by attaching two pentagons to each face of - * of a cube. The coordinates of the points are: - * (+-x,0, z); (+-1, 1, 1); (0, z, x ) - * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or - * x = 0.61803398875 and z = 1.61803398875. - */ - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.0, 0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.0, 0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.0, -0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.0, -0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ; - glEnd () ; - - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( -0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( -0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ; - glEnd () ; - - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( 0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( -0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ; - glEnd () ; - glBegin ( GL_POLYGON ) ; - glNormal3d ( -0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ; - glEnd () ; -} - - - /* -- INTERFACE FUNCTIONS -------------------------------------------------- */ /* Macro to generate interface functions */ #define DECLARE_SHAPE_INTERFACE(nameICaps)\ @@ -1383,6 +1355,7 @@ fghCube( dSize, FALSE ); } +DECLARE_SHAPE_INTERFACE(Dodecahedron); DECLARE_SHAPE_INTERFACE(Icosahedron); DECLARE_SHAPE_INTERFACE(Octahedron); DECLARE_SHAPE_INTERFACE(RhombicDodecahedron); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 02:11:55
|
Revision: 1167 http://freeglut.svn.sourceforge.net/freeglut/?rev=1167&view=rev Author: dcnieho Date: 2012-03-17 02:11:49 +0000 (Sat, 17 Mar 2012) Log Message: ----------- Need to also set glDisable(GL_CULL_FACE) when drawing wireframe to match what was produced before Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:06:21 UTC (rev 1166) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:11:49 UTC (rev 1167) @@ -76,6 +76,7 @@ { glPushAttrib(GL_POLYGON_BIT); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + glDisable(GL_CULL_FACE); } if (1) @@ -187,11 +188,6 @@ /* -- 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)\ @@ -571,6 +567,11 @@ DECLARE_SHAPE_CACHE(tetrahedron,Tetrahedron,TETRAHEDRON); /* -- Sierpinski Sponge -- */ +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); +} + static void fghSierpinskiSpongeGenerate ( int numLevels, GLdouble offset[3], GLdouble scale, GLdouble* vertices, GLdouble* normals ) { int i, j; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 02:21:25
|
Revision: 1168 http://freeglut.svn.sourceforge.net/freeglut/?rev=1168&view=rev Author: dcnieho Date: 2012-03-17 02:21:19 +0000 (Sat, 17 Mar 2012) Log Message: ----------- check for every malloc call if memory was allocated successfully Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:11:49 UTC (rev 1167) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:21:19 UTC (rev 1168) @@ -694,6 +694,12 @@ /* Need to build new vertex list containing vertices for cube of different size */ GLdouble *vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLdouble)); + /* Bail out if memory allocation fails, fgError never returns */ + if (!(*vertices)) + { + free(*vertices); + fgError("Failed to allocate memory in fghCube"); + } for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++) vertices[i] = dSize*cube_verts[i]; @@ -721,6 +727,13 @@ /* Allocate memory */ vertices = malloc(numVert*3 * sizeof(GLdouble)); normals = malloc(numVert*3 * sizeof(GLdouble)); + /* Bail out if memory allocation fails, fgError never returns */ + if (!(*vertices) || !(*normals)) + { + free(*vertices); + free(*normals); + fgError("Failed to allocate memory in fghSierpinskiSponge"); + } /* Generate elements */ fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals ); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 02:23:10
|
Revision: 1169 http://freeglut.svn.sourceforge.net/freeglut/?rev=1169&view=rev Author: dcnieho Date: 2012-03-17 02:23:03 +0000 (Sat, 17 Mar 2012) Log Message: ----------- oops, that was a bit sloppy. Also added a missing free Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:21:19 UTC (rev 1168) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:23:03 UTC (rev 1169) @@ -695,15 +695,18 @@ /* Need to build new vertex list containing vertices for cube of different size */ GLdouble *vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLdouble)); /* Bail out if memory allocation fails, fgError never returns */ - if (!(*vertices)) + if (!vertices) { - free(*vertices); + free(vertices); fgError("Failed to allocate memory in fghCube"); } for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++) vertices[i] = dSize*cube_verts[i]; fghDrawGeometry(GL_TRIANGLES,vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); + + /* cleanup allocated memory */ + free(vertices); } else fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); @@ -728,10 +731,10 @@ vertices = malloc(numVert*3 * sizeof(GLdouble)); normals = malloc(numVert*3 * sizeof(GLdouble)); /* Bail out if memory allocation fails, fgError never returns */ - if (!(*vertices) || !(*normals)) + if (!vertices || !normals) { - free(*vertices); - free(*normals); + free(vertices); + free(normals); fgError("Failed to allocate memory in fghSierpinskiSponge"); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 03:58:32
|
Revision: 1170 http://freeglut.svn.sourceforge.net/freeglut/?rev=1170&view=rev Author: dcnieho Date: 2012-03-17 03:58:26 +0000 (Sat, 17 Mar 2012) Log Message: ----------- little bit of cleanup added code for GLES1 (though only tested on OpenGL 2, non-ES context) Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 02:23:03 UTC (rev 1169) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 03:58:26 UTC (rev 1170) @@ -29,38 +29,7 @@ #include "fg_internal.h" /* - * * Need more types of polyhedra? See CPolyhedron in MRPT - * - * TODO BEFORE THE STABLE RELEASE: - * - * See fghTetrahedron - * - * Following functions have been contributed by Andreas Umbach. - * - * glutWireCube() -- looks OK - * glutSolidCube() -- OK - * - * Those functions have been implemented by John Fay. - * - * glutWireTorus() -- looks OK - * glutSolidTorus() -- looks OK - * glutWireDodecahedron() -- looks OK - * glutSolidDodecahedron() -- looks OK - * glutWireOctahedron() -- looks OK - * glutSolidOctahedron() -- looks OK - * glutWireTetrahedron() -- looks OK - * glutSolidTetrahedron() -- looks OK - * glutWireIcosahedron() -- looks OK - * glutSolidIcosahedron() -- looks OK - * - * The Following functions have been updated by Nigel Stewart, based - * on FreeGLUT 2.0.0 implementations: - * - * glutWireSphere() -- looks OK - * glutSolidSphere() -- looks OK - * glutWireCone() -- looks OK - * glutSolidCone() -- looks OK */ @@ -70,57 +39,118 @@ * useWireMode controls the drawing of solids (false) or wire frame * versions (TRUE) of the geometry you pass */ -static void fghDrawGeometry(GLenum vertexMode, GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLboolean useWireMode) +static void fghDrawGeometry(GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLsizei numFaces, GLsizei numEdgePerFace, GLboolean useWireMode) { +# ifdef FREEGLUT_GLES + /* Solid drawing is the same for OpenGL 1.x and OpenGL ES 1.x, just + * no edge flags for ES. + * WireFrame drawing will have to be done per face though, using + * GL_LINE_LOOP and issuing one draw call per face. For triangles, + * we use glDrawArrays directly on the vertex data for each face, + * while for shapes that are composed of quads or pentagons, we use + * glDrawElements with index vector {0,1,2,5} or {0,1,2,8,5}, + * respectively. + * We use the first parameter in glDrawArrays or glDrawElements to + * go from face to face. + */ if (useWireMode) { + /* setup reading the right elements from vertex array */ + GLubyte vertIdx4[4] = {0,1,2,5}; + GLubyte vertIdx5[5] = {0,1,2,8,5}; + GLubyte *indices = NULL; + int vertStride, i, j; + + switch (numEdgePerFace) + { + case 3: + vertStride = 3; /* there are 3 vertices for each face in the array */ + break; + case 4: + indices = vertIdx4; + vertStride = 6; /* there are 6 vertices for each face in the array */ + break; + case 5: + indices = vertIdx5; + vertStride = 9; /* there are 9 vertices for each face in the array */ + break; + } + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); + + glVertexPointer(3, GL_DOUBLE, 0, vertices); + glNormalPointer(GL_DOUBLE, 0, normals); + + if (numEdgePerFace==3) + for (i=0; i<numFaces; i++) + glDrawArrays(GL_LINE_LOOP, i*vertStride, numEdgePerFace); + else + { + GLubyte *vertIndices = malloc(numEdgePerFace*sizeof(GLubyte)); + for (i=0; i<numFaces; i++) + { + for (j=0; j< numEdgePerFace; j++) + vertIndices[j] = indices[j]+i*vertStride; + + glDrawElements(GL_LINE_LOOP, numEdgePerFace, GL_UNSIGNED_BYTE, vertIndices); + } + free(vertIndices); + } + + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_NORMAL_ARRAY); + return; /* done */ + } +# endif + + if (useWireMode) + { glPushAttrib(GL_POLYGON_BIT); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glDisable(GL_CULL_FACE); } - if (1) - { - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); +# ifndef FREEGLUT_GLES if (edgeFlags) glEnableClientState(GL_EDGE_FLAG_ARRAY); +# endif - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); + glVertexPointer(3, GL_DOUBLE, 0, vertices); + glNormalPointer(GL_DOUBLE, 0, normals); +# ifndef FREEGLUT_GLES if (edgeFlags) glEdgeFlagPointer(0,edgeFlags); - glDrawArrays(vertexMode, 0, numVertices); +# endif + glDrawArrays(GL_TRIANGLES, 0, numVertices); - glDisableClientState(GL_VERTEX_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_NORMAL_ARRAY); +# ifndef FREEGLUT_GLES if (edgeFlags) glDisableClientState(GL_EDGE_FLAG_ARRAY); - } - else - { - int i; - glBegin(vertexMode); - for(i=0; i<numVertices; i++) - { - glEdgeFlag(edgeFlags[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(); - } +# endif if (useWireMode) { glPopAttrib(); } + + /* Notes on OpenGL 3 and OpenGL ES2, drawing code for programmable pipeline: + * As above, we'll have to draw face-by-face for wireframes. On + * OpenGL 3 we can probably use glMultiDrawArrays do do this efficiently. + * other complications are VBOs and such... + */ } -/* triangle decomposition and associated edgeFlags - * be careful to keep winding of all triangles counter-clockwise, +/* Triangle decomposition and associated edgeFlags generation + * Be careful to keep winding of all triangles counter-clockwise, * assuming that input has correct winding... + * Could probably do something smarter using glDrawElements and generating + * an index vector here for all shapes that are not triangles, but this + * suffices for now. We're not talking many vertices in our objects anyway. */ static GLubyte vertSamp3[3] = {0,1,2}; static GLubyte vertSamp4[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */ @@ -675,7 +705,9 @@ fgh##nameICaps##Generate();\ name##Cached = GL_TRUE;\ }\ - fghDrawGeometry(GL_TRIANGLES,name##_verts,name##_norms,edgeFlags,nameCaps##_VERT_PER_OBJ_TRI,useWireMode);\ + fghDrawGeometry(name##_verts,name##_norms,edgeFlags,\ + nameCaps##_VERT_PER_OBJ_TRI,nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE,\ + useWireMode);\ } #define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL) #define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_edgeFlags) @@ -703,13 +735,13 @@ for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++) vertices[i] = dSize*cube_verts[i]; - fghDrawGeometry(GL_TRIANGLES,vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); + fghDrawGeometry(vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE,useWireMode); /* cleanup allocated memory */ free(vertices); } else - fghDrawGeometry(GL_TRIANGLES,cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,useWireMode); + fghDrawGeometry(cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE,useWireMode); } DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON); @@ -724,6 +756,7 @@ GLdouble * normals; GLsizei numTetr = numLevels<0? 0 : ipow(4,numLevels); /* No sponge for numLevels below 0 */ GLsizei numVert = numTetr*TETRAHEDRON_VERT_PER_OBJ; + GLsizei numFace = numTetr*TETRAHEDRON_NUM_FACES; if (numTetr) { @@ -742,7 +775,7 @@ fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals ); /* Draw and cleanup */ - fghDrawGeometry(GL_TRIANGLES,vertices,normals,NULL,numVert,useWireMode); + fghDrawGeometry(vertices,normals,NULL,numVert,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE,useWireMode); free(vertices); free(normals ); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 04:00:19
|
Revision: 1171 http://freeglut.svn.sourceforge.net/freeglut/?rev=1171&view=rev Author: dcnieho Date: 2012-03-17 04:00:13 +0000 (Sat, 17 Mar 2012) Log Message: ----------- that definition is FREEGLUT_GLES1, not FREEGLUT_GLES Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 03:58:26 UTC (rev 1170) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 04:00:13 UTC (rev 1171) @@ -41,7 +41,7 @@ */ static void fghDrawGeometry(GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLsizei numFaces, GLsizei numEdgePerFace, GLboolean useWireMode) { -# ifdef FREEGLUT_GLES +# ifdef FREEGLUT_GLES1 /* Solid drawing is the same for OpenGL 1.x and OpenGL ES 1.x, just * no edge flags for ES. * WireFrame drawing will have to be done per face though, using @@ -113,14 +113,14 @@ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); -# ifndef FREEGLUT_GLES +# ifndef FREEGLUT_GLES1 if (edgeFlags) glEnableClientState(GL_EDGE_FLAG_ARRAY); # endif glVertexPointer(3, GL_DOUBLE, 0, vertices); glNormalPointer(GL_DOUBLE, 0, normals); -# ifndef FREEGLUT_GLES +# ifndef FREEGLUT_GLES1 if (edgeFlags) glEdgeFlagPointer(0,edgeFlags); # endif @@ -128,7 +128,7 @@ glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); -# ifndef FREEGLUT_GLES +# ifndef FREEGLUT_GLES1 if (edgeFlags) glDisableClientState(GL_EDGE_FLAG_ARRAY); # endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-17 16:11:13
|
Revision: 1184 http://freeglut.svn.sourceforge.net/freeglut/?rev=1184&view=rev Author: dcnieho Date: 2012-03-17 16:11:06 +0000 (Sat, 17 Mar 2012) Log Message: ----------- got rid of edgeflags as I now draw all wire frames face-by-face using line loops. Split wire and solid drawing in two separate functions Now doing polygon to triangle decomposition using vertex indices that are passed to glDrawElements, saves on memory, executes more efficient, and makes wireframe drawing a piece of cake. This should be GLES1 compatible too, hope so! Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 15:36:25 UTC (rev 1183) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-17 16:11:06 UTC (rev 1184) @@ -33,169 +33,88 @@ */ -/* 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 +/* General functions for drawing geometry + * Solids are drawn by glDrawArrays if composed of triangles, or by + * glDrawElements if consisting of squares or pentagons that were + * decomposed into triangles (some vertices are repeated in that case). + * WireFrame drawing will have to be done per face, using GL_LINE_LOOP and + * issuing one draw call per face. Always use glDrawArrays as no triangle + * decomposition needed. We use the "first" parameter in glDrawArrays to go + * from face to face. */ -static void fghDrawGeometry(GLdouble *vertices, GLdouble *normals, GLboolean *edgeFlags, GLsizei numVertices, GLsizei numFaces, GLsizei numEdgePerFace, GLboolean useWireMode) +static void fghDrawGeometryWire(GLdouble *vertices, GLdouble *normals, GLsizei numFaces, GLsizei numEdgePerFace) { -# ifdef FREEGLUT_GLES1 - /* Solid drawing is the same for OpenGL 1.x and OpenGL ES 1.x, just - * no edge flags for ES. - * WireFrame drawing will have to be done per face though, using - * GL_LINE_LOOP and issuing one draw call per face. For triangles, - * we use glDrawArrays directly on the vertex data for each face, - * while for shapes that are composed of quads or pentagons, we use - * glDrawElements with index vector {0,1,2,5} or {0,1,2,8,5}, - * respectively. - * We use the first parameter in glDrawArrays or glDrawElements to - * go from face to face. - */ - if (useWireMode) - { - /* setup reading the right elements from vertex array */ - GLubyte vertIdx4[4] = {0,1,2,5}; - GLubyte vertIdx5[5] = {0,1,2,8,5}; - GLubyte *indices = NULL; - int vertStride, i, j; - - switch (numEdgePerFace) - { - case 3: - vertStride = 3; /* there are 3 vertices for each face in the array */ - break; - case 4: - indices = vertIdx4; - vertStride = 6; /* there are 6 vertices for each face in the array */ - break; - case 5: - indices = vertIdx5; - vertStride = 9; /* there are 9 vertices for each face in the array */ - break; - } + int i; + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); + glVertexPointer(3, GL_DOUBLE, 0, vertices); + glNormalPointer(GL_DOUBLE, 0, normals); - glVertexPointer(3, GL_DOUBLE, 0, vertices); - glNormalPointer(GL_DOUBLE, 0, normals); + /* Draw per face (TODO: could use glMultiDrawArrays if available) */ + for (i=0; i<numFaces; i++) + glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace); - if (numEdgePerFace==3) - for (i=0; i<numFaces; i++) - glDrawArrays(GL_LINE_LOOP, i*vertStride, numEdgePerFace); - else - { - GLubyte *vertIndices = malloc(numEdgePerFace*sizeof(GLubyte)); - for (i=0; i<numFaces; i++) - { - for (j=0; j< numEdgePerFace; j++) - vertIndices[j] = indices[j]+i*vertStride; - - glDrawElements(GL_LINE_LOOP, numEdgePerFace, GL_UNSIGNED_BYTE, vertIndices); - } - free(vertIndices); - } - - glDisableClientState(GL_VERTEX_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - return; /* done */ - } -# endif - - if (useWireMode) - { - glPushAttrib(GL_POLYGON_BIT); - glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); - glDisable(GL_CULL_FACE); - } - + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_NORMAL_ARRAY); +} +static void fghDrawGeometrySolid(GLdouble *vertices, GLdouble *normals, GLubyte *vertIdxs, GLsizei numVertices, GLsizei numEdgePerFace) +{ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); -# ifndef FREEGLUT_GLES1 - if (edgeFlags) - glEnableClientState(GL_EDGE_FLAG_ARRAY); -# endif glVertexPointer(3, GL_DOUBLE, 0, vertices); glNormalPointer(GL_DOUBLE, 0, normals); -# ifndef FREEGLUT_GLES1 - if (edgeFlags) - glEdgeFlagPointer(0,edgeFlags); -# endif - glDrawArrays(GL_TRIANGLES, 0, numVertices); + if (numEdgePerFace==3) + glDrawArrays(GL_TRIANGLES, 0, numVertices); + else + glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_BYTE, vertIdxs); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); -# ifndef FREEGLUT_GLES1 - if (edgeFlags) - glDisableClientState(GL_EDGE_FLAG_ARRAY); -# endif - - if (useWireMode) - { - glPopAttrib(); - } - - /* Notes on OpenGL 3 and OpenGL ES2, drawing code for programmable pipeline: - * As above, we'll have to draw face-by-face for wireframes. On - * OpenGL 3 we can probably use glMultiDrawArrays do do this efficiently. - * other complications are VBOs and such... - */ } -/* Triangle decomposition and associated edgeFlags generation +/* Shape decomposition to triangles + * We'll use glDrawElements to draw all shapes that are not triangles, so + * generate an index vector here, using the below sampling scheme. * Be careful to keep winding of all triangles counter-clockwise, * assuming that input has correct winding... - * Could probably do something smarter using glDrawElements and generating - * an index vector here for all shapes that are not triangles, but this - * suffices for now. We're not talking many vertices in our objects anyway. */ -static GLubyte vertSamp3[3] = {0,1,2}; -static GLubyte vertSamp4[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */ -static GLubyte vertSamp5[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */ -static GLboolean edgeFlag3[3] = {1,1,1}; /* triangles remain triangles, all edges are external */ -static GLboolean edgeFlag4[6] = {1,1,0, 0,1,1}; -static GLboolean edgeFlag5[9] = {1,1,0, 0,0,1, 0,1,1}; +static GLubyte vert4Decomp[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */ +static GLubyte vert5Decomp[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */ -static void fghGenerateGeometryWithEdgeFlag(int numFaces, int numEdgePerFaceIn, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLboolean *edgeFlagsOut) +static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut, GLubyte *vertIdxOut) { - int i,j,numEdgePerFaceOut; + int i,j,numEdgeIdxPerFace; GLubyte *vertSamps = NULL; - GLboolean *edgeFlags = NULL; - switch (numEdgePerFaceIn) + switch (numEdgePerFace) { case 3: - vertSamps = vertSamp3; - edgeFlags = edgeFlag3; - numEdgePerFaceOut = 3; /* 3 output vertices for each face */ + /* nothing to do here, we'll drawn with glDrawArrays */ break; case 4: - vertSamps = vertSamp4; - edgeFlags = edgeFlag4; - numEdgePerFaceOut = 6; /* 6 output vertices for each face */ + vertSamps = vert4Decomp; + numEdgeIdxPerFace = 6; /* 6 output vertices for each face */ break; case 5: - vertSamps = vertSamp5; - edgeFlags = edgeFlag5; - numEdgePerFaceOut = 9; /* 9 output vertices for each face */ + vertSamps = vert5Decomp; + numEdgeIdxPerFace = 9; /* 9 output vertices for each face */ break; } /* - * Build array with vertices from vertex coordinates and vertex indices + * Build array with vertices using 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). + * Need to do this because of different normals at shared vertices. */ for (i=0; i<numFaces; i++) { int normIdx = i*3; - int faceIdxVertIdx = i*numEdgePerFaceIn; // index to first element of "row" in vertex indices - for (j=0; j<numEdgePerFaceOut; j++) + int faceIdxVertIdx = i*numEdgePerFace; // index to first element of "row" in vertex indices + for (j=0; j<numEdgePerFace; j++) { - int outIdx = i*numEdgePerFaceOut*3+j*3; - int vertIdx = vertIndices[faceIdxVertIdx+vertSamps[j]]*3; + int outIdx = i*numEdgePerFace*3+j*3; + int vertIdx = vertIndices[faceIdxVertIdx+j]*3; vertOut[outIdx ] = vertices[vertIdx ]; vertOut[outIdx+1] = vertices[vertIdx+1]; @@ -204,22 +123,29 @@ normOut[outIdx ] = normals [normIdx ]; normOut[outIdx+1] = normals [normIdx+1]; normOut[outIdx+2] = normals [normIdx+2]; - - if (edgeFlagsOut) - edgeFlagsOut[i*numEdgePerFaceOut+j] = edgeFlags[j]; } + + /* generate vertex indices for each face */ + if (vertSamps) + for (j=0; j<numEdgeIdxPerFace; j++) + vertIdxOut[i*numEdgeIdxPerFace+j] = faceIdxVertIdx + vertSamps[j]; } } static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLdouble *vertices, GLubyte *vertIndices, GLdouble *normals, GLdouble *vertOut, GLdouble *normOut) { - fghGenerateGeometryWithEdgeFlag(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL); + /* This function does the same as fghGenerateGeometryWithIndexArray, just skipping the index array generation... */ + fghGenerateGeometryWithIndexArray(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL); } /* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */ /* -- stuff that can be cached -- */ -/* Cache of input to glDrawArrays */ +/* Cache of input to glDrawArrays or glDrawElements + * 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. + */ #define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\ static GLboolean name##Cached = FALSE;\ static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ @@ -234,26 +160,21 @@ static GLboolean name##Cached = FALSE;\ static GLdouble name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\ static GLdouble name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\ - static GLboolean name##_edgeFlags[nameCaps##_VERT_PER_OBJ_TRI];\ + static GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\ static void fgh##nameICaps##Generate()\ {\ - fghGenerateGeometryWithEdgeFlag(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ - name##_v, name##_vi, name##_n,\ - name##_verts, name##_norms, name##_edgeFlags);\ + fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ + name##_v, name##_vi, name##_n,\ + name##_verts, name##_norms, name##_vertIdxs);\ } -/* - * 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_EDGE_PER_FACE 4 #define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES*CUBE_NUM_EDGE_PER_FACE) +#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ*3) #define CUBE_VERT_PER_OBJ_TRI (CUBE_VERT_PER_OBJ+CUBE_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ -#define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble cube_v[CUBE_NUM_VERT*3] = { @@ -300,8 +221,8 @@ #define DODECAHEDRON_NUM_FACES 12 #define DODECAHEDRON_NUM_EDGE_PER_FACE 5 #define DODECAHEDRON_VERT_PER_OBJ (DODECAHEDRON_NUM_FACES*DODECAHEDRON_NUM_EDGE_PER_FACE) +#define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ*3) #define DODECAHEDRON_VERT_PER_OBJ_TRI (DODECAHEDRON_VERT_PER_OBJ+DODECAHEDRON_NUM_FACES*4) /* 4 extra edges per face when drawing pentagons as triangles */ -#define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble dodecahedron_v[DODECAHEDRON_NUM_VERT*3] = { @@ -371,8 +292,8 @@ #define ICOSAHEDRON_NUM_FACES 20 #define ICOSAHEDRON_NUM_EDGE_PER_FACE 3 #define ICOSAHEDRON_VERT_PER_OBJ (ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE) +#define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ*3) #define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ -#define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble icosahedron_v[ICOSAHEDRON_NUM_VERT*3] = { @@ -449,8 +370,8 @@ #define OCTAHEDRON_NUM_FACES 8 #define OCTAHEDRON_NUM_EDGE_PER_FACE 3 #define OCTAHEDRON_VERT_PER_OBJ (OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE) +#define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ*3) #define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ -#define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble octahedron_v[OCTAHEDRON_NUM_VERT*3] = @@ -496,8 +417,8 @@ #define RHOMBICDODECAHEDRON_NUM_FACES 12 #define RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE 4 #define RHOMBICDODECAHEDRON_VERT_PER_OBJ (RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE) +#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ*3) #define RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ -#define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] = @@ -566,8 +487,8 @@ #define TETRAHEDRON_NUM_FACES 4 #define TETRAHEDRON_NUM_EDGE_PER_FACE 3 #define TETRAHEDRON_VERT_PER_OBJ (TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE) +#define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ*3) #define TETRAHEDRON_VERT_PER_OBJ_TRI TETRAHEDRON_VERT_PER_OBJ -#define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ_TRI*3) /* Vertex Coordinates */ static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] = @@ -644,7 +565,7 @@ /* -- Now the various shapes involving circles -- */ /* - * Compute lookup table of cos and sin values forming a cirle + * Compute lookup table of cos and sin values forming a circle * * Notes: * It is the responsibility of the caller to free these tables @@ -697,7 +618,7 @@ /* -- INTERNAL DRAWING functions --------------------------------------- */ -#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,edgeFlags)\ +#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\ static void fgh##nameICaps( GLboolean useWireMode )\ {\ if (!name##Cached)\ @@ -705,15 +626,25 @@ fgh##nameICaps##Generate();\ name##Cached = GL_TRUE;\ }\ - fghDrawGeometry(name##_verts,name##_norms,edgeFlags,\ - nameCaps##_VERT_PER_OBJ_TRI,nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE,\ - useWireMode);\ + \ + if (useWireMode)\ + {\ + fghDrawGeometryWire (name##_verts,name##_norms,\ + nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\ + }\ + else\ + {\ + fghDrawGeometrySolid(name##_verts,name##_norms,vertIdxs,\ + nameCaps##_VERT_PER_OBJ_TRI, nameCaps##_NUM_EDGE_PER_FACE);\ + }\ } -#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL) -#define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_edgeFlags) +#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL) +#define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_vertIdxs) static void fghCube( GLdouble dSize, GLboolean useWireMode ) { + GLdouble *vertices; + if (!cubeCached) { fghCubeGenerate(); @@ -722,26 +653,32 @@ if (dSize!=1.) { + /* Need to build new vertex list containing vertices for cube of different size */ 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)); + vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLdouble)); + /* Bail out if memory allocation fails, fgError never returns */ if (!vertices) { free(vertices); fgError("Failed to allocate memory in fghCube"); } + for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++) vertices[i] = dSize*cube_verts[i]; + } + else + vertices = cube_verts; - fghDrawGeometry(vertices ,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE,useWireMode); + if (useWireMode) + fghDrawGeometryWire (vertices ,cube_norms, CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE); + else + fghDrawGeometrySolid(vertices ,cube_norms,cube_vertIdxs,CUBE_VERT_PER_OBJ_TRI, CUBE_NUM_EDGE_PER_FACE); + if (dSize!=1.) /* cleanup allocated memory */ free(vertices); - } - else - fghDrawGeometry(cube_verts,cube_norms,cube_edgeFlags,CUBE_VERT_PER_OBJ_TRI,CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE,useWireMode); } DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON); @@ -775,7 +712,11 @@ fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals ); /* Draw and cleanup */ - fghDrawGeometry(vertices,normals,NULL,numVert,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE,useWireMode); + if (useWireMode) + fghDrawGeometryWire (vertices,normals, numFace,TETRAHEDRON_NUM_EDGE_PER_FACE); + else + fghDrawGeometrySolid(vertices,normals,NULL,numVert, TETRAHEDRON_NUM_EDGE_PER_FACE); + free(vertices); free(normals ); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dc...@us...> - 2012-03-18 10:03:01
|
Revision: 1192 http://freeglut.svn.sourceforge.net/freeglut/?rev=1192&view=rev Author: dcnieho Date: 2012-03-18 10:02:54 +0000 (Sun, 18 Mar 2012) Log Message: ----------- All doubles now GLdoubles (important for GLES later) Other general cleanup in prep for porting geometry code involving circles. no longer computing a larger circle table when only need half of it Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-18 09:59:50 UTC (rev 1191) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-18 10:02:54 UTC (rev 1192) @@ -566,6 +566,7 @@ /* -- Now the various shapes involving circles -- */ /* * Compute lookup table of cos and sin values forming a circle + * (or half circle if halfCircle==TRUE) * * Notes: * It is the responsibility of the caller to free these tables @@ -573,25 +574,21 @@ * 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) +static void fghCircleTable(GLdouble **sint, GLdouble **cost, const int n, const GLboolean halfCircle) { int i; - + /* Table size, the sign of n flips the circle direction */ - const int size = abs(n); /* Determine the angle between samples */ + const GLdouble angle = (halfCircle?1:2)*M_PI/(GLdouble)( ( n == 0 ) ? 1 : n ); - const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n ); - /* Allocate memory for n samples, plus duplicate of first entry at the end */ + *sint = malloc(sizeof(GLdouble) * (size+1)); + *cost = malloc(sizeof(GLdouble) * (size+1)); - *sint = (double *) calloc(sizeof(double), size+1); - *cost = (double *) calloc(sizeof(double), size+1); - /* Bail out if memory allocation fails, fgError never returns */ - if (!(*sint) || !(*cost)) { free(*sint); @@ -600,7 +597,6 @@ } /* Compute cos and sin around the circle */ - (*sint)[0] = 0.0; (*cost)[0] = 1.0; @@ -610,10 +606,18 @@ (*cost)[i] = cos(angle*i); } - /* Last sample is duplicate of the first */ - - (*sint)[size] = (*sint)[0]; - (*cost)[size] = (*cost)[0]; + + if (halfCircle) + { + (*sint)[size] = 0.0; /* sin PI */ + (*cost)[size] = -1.0; /* cos PI */ + } + else + { + /* Last sample is duplicate of the first (sin or cos of 2 PI) */ + (*sint)[size] = (*sint)[0]; + (*cost)[size] = (*cost)[0]; + } } @@ -672,9 +676,9 @@ vertices = cube_verts; if (useWireMode) - fghDrawGeometryWire (vertices ,cube_norms, CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE); + fghDrawGeometryWire (vertices,cube_norms, CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE); else - fghDrawGeometrySolid(vertices ,cube_norms,cube_vertIdxs,CUBE_VERT_PER_OBJ_TRI, CUBE_NUM_EDGE_PER_FACE); + fghDrawGeometrySolid(vertices,cube_norms,cube_vertIdxs,CUBE_VERT_PER_OBJ_TRI, CUBE_NUM_EDGE_PER_FACE); if (dSize!=1.) /* cleanup allocated memory */ @@ -735,18 +739,18 @@ /* Adjust z and radius as stacks are drawn. */ - double z0,z1; - double r0,r1; + GLdouble z0,z1; + GLdouble r0,r1; /* Pre-computed circle */ - double *sint1,*cost1; - double *sint2,*cost2; + GLdouble *sint1,*cost1; + GLdouble *sint2,*cost2; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" ); - fghCircleTable(&sint1,&cost1,-slices); - fghCircleTable(&sint2,&cost2,stacks*2); + fghCircleTable(&sint1,&cost1,-slices,FALSE); + fghCircleTable(&sint2,&cost2, stacks,TRUE); /* The top stack is covered with a triangle fan */ @@ -823,18 +827,18 @@ /* Adjust z and radius as stacks and slices are drawn. */ - double r; - double x,y,z; + GLdouble r; + GLdouble x,y,z; /* Pre-computed circle */ - double *sint1,*cost1; - double *sint2,*cost2; + GLdouble *sint1,*cost1; + GLdouble *sint2,*cost2; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" ); - fghCircleTable(&sint1,&cost1,-slices ); - fghCircleTable(&sint2,&cost2, stacks*2); + fghCircleTable(&sint1,&cost1,-slices,FALSE); + fghCircleTable(&sint2,&cost2, stacks,TRUE); /* Draw a line loop for each stack */ @@ -868,6 +872,7 @@ x = cost1[i]*sint2[j]; y = sint1[i]*sint2[j]; z = cost2[j]; + printf("j(%i):%1.3f\n",j,z); glNormal3d(x,y,z); glVertex3d(x*radius,y*radius,z*radius); @@ -893,24 +898,24 @@ /* Step in z and radius as stacks are drawn. */ - double z0,z1; - double r0,r1; + GLdouble z0,z1; + GLdouble r0,r1; - const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); - const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); + const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); + const GLdouble rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); /* Scaling factors for vertex normals */ - const double cosn = ( height / sqrt ( height * height + base * base )); - const double sinn = ( base / sqrt ( height * height + base * base )); + const GLdouble cosn = ( height / sqrt ( height * height + base * base )); + const GLdouble sinn = ( base / sqrt ( height * height + base * base )); /* Pre-computed circle */ - double *sint,*cost; + GLdouble *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Cover the circular base with a triangle fan... */ @@ -980,24 +985,24 @@ /* Step in z and radius as stacks are drawn. */ - double z = 0.0; - double r = base; + GLdouble z = 0.0; + GLdouble r = base; - const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); - const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); + const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); + const GLdouble rStep = base / ( ( stacks > 0 ) ? stacks : 1 ); /* Scaling factors for vertex normals */ - const double cosn = ( height / sqrt ( height * height + base * base )); - const double sinn = ( base / sqrt ( height * height + base * base )); + const GLdouble cosn = ( height / sqrt ( height * height + base * base )); + const GLdouble sinn = ( base / sqrt ( height * height + base * base )); /* Pre-computed circle */ - double *sint,*cost; + GLdouble *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Draw the stacks... */ @@ -1048,16 +1053,16 @@ /* Step in z and radius as stacks are drawn. */ - double z0,z1; - const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); + GLdouble z0,z1; + const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); /* Pre-computed circle */ - double *sint,*cost; + GLdouble *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Cover the base and top */ @@ -1112,16 +1117,16 @@ /* Step in z and radius as stacks are drawn. */ - double z = 0.0; - const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); + GLdouble z = 0.0; + const GLdouble zStep = height / ( ( stacks > 0 ) ? stacks : 1 ); /* Pre-computed circle */ - double *sint,*cost; + GLdouble *sint,*cost; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" ); - fghCircleTable(&sint,&cost,-slices); + fghCircleTable(&sint,&cost,-slices,FALSE); /* Draw the stacks... */ @@ -1167,10 +1172,10 @@ */ void FGAPIENTRY glutWireTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings ) { - double iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi; - double *vertex, *normal; + GLdouble iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi; + GLdouble *vertex, *normal; int i, j; - double spsi, cpsi, sphi, cphi ; + GLdouble spsi, cpsi, sphi, cphi ; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" ); @@ -1178,13 +1183,13 @@ if ( nRings < 1 ) nRings = 1; /* Allocate the vertices array */ - vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings ); - normal = (double *)calloc( sizeof(double), 3 * nSides * nRings ); + vertex = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings ); + normal = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings ); glPushMatrix(); - dpsi = 2.0 * M_PI / (double)nRings ; - dphi = -2.0 * M_PI / (double)nSides ; + dpsi = 2.0 * M_PI / (GLdouble)nRings ; + dphi = -2.0 * M_PI / (GLdouble)nSides ; psi = 0.0; for( j=0; j<nRings; j++ ) @@ -1248,10 +1253,10 @@ */ void FGAPIENTRY glutSolidTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings ) { - double iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi; - double *vertex, *normal; + GLdouble iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi; + GLdouble *vertex, *normal; int i, j; - double spsi, cpsi, sphi, cphi ; + GLdouble spsi, cpsi, sphi, cphi ; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" ); @@ -1263,13 +1268,13 @@ nRings ++ ; /* Allocate the vertices array */ - vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings ); - normal = (double *)calloc( sizeof(double), 3 * nSides * nRings ); + vertex = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings ); + normal = (GLdouble *)calloc( sizeof(GLdouble), 3 * nSides * nRings ); glPushMatrix(); - dpsi = 2.0 * M_PI / (double)(nRings - 1) ; - dphi = -2.0 * M_PI / (double)(nSides - 1) ; + dpsi = 2.0 * M_PI / (GLdouble)(nRings - 1) ; + dphi = -2.0 * M_PI / (GLdouble)(nSides - 1) ; psi = 0.0; for( j=0; j<nRings; j++ ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <be...@us...> - 2012-03-18 12:25:35
|
Revision: 1195 http://freeglut.svn.sourceforge.net/freeglut/?rev=1195&view=rev Author: beuc Date: 2012-03-18 12:25:29 +0000 (Sun, 18 Mar 2012) Log Message: ----------- Remove left-over printf Modified Paths: -------------- trunk/freeglut/freeglut/src/fg_geometry.c Modified: trunk/freeglut/freeglut/src/fg_geometry.c =================================================================== --- trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-18 10:25:19 UTC (rev 1194) +++ trunk/freeglut/freeglut/src/fg_geometry.c 2012-03-18 12:25:29 UTC (rev 1195) @@ -872,7 +872,6 @@ x = cost1[i]*sint2[j]; y = sint1[i]*sint2[j]; z = cost2[j]; - printf("j(%i):%1.3f\n",j,z); glNormal3d(x,y,z); glVertex3d(x*radius,y*radius,z*radius); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |