X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=2c6f344c2fdb245e3d5cf5d403f0ec606e2245d7;hb=da66462c2b7ce3185bc714cbabade787291c5c6f;hp=de1cbadae2e27c1d4e847042e8146c6c06fc7052;hpb=1b5ee849ba61b667aeba474a7e03406196478bee;p=freeglut diff --git a/src/fg_geometry.c b/src/fg_geometry.c index de1cbad..2c6f344 100644 --- a/src/fg_geometry.c +++ b/src/fg_geometry.c @@ -29,90 +29,543 @@ #include "fg_internal.h" /* - * TODO BEFORE THE STABLE RELEASE: - * - * 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 + * Need more types of polyhedra? See CPolyhedron in MRPT */ -/* -- INTERFACE FUNCTIONS -------------------------------------------------- */ +/* 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 fghDrawGeometryWire(GLdouble *vertices, GLdouble *normals, GLsizei numFaces, GLsizei numEdgePerFace) +{ + int i; + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); -/* - * Draws a wireframed cube. Code contributed by Andreas Umbach + glVertexPointer(3, GL_DOUBLE, 0, vertices); + glNormalPointer(GL_DOUBLE, 0, normals); + + /* Draw per face (TODO: could use glMultiDrawArrays if available) */ + for (i=0; i + +/* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */ +/* -- stuff that can be cached -- */ +/* 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. */ -void FGAPIENTRY glutSolidCube( GLdouble dSize ) +#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_EDGE_PER_FACE,\ + name##_v, name##_vi, name##_n,\ + name##_verts, name##_norms);\ + } +#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 GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\ + static void fgh##nameICaps##Generate()\ + {\ + fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\ + name##_v, name##_vi, name##_n,\ + name##_verts, name##_norms, name##_vertIdxs);\ + } + +/* -- 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 */ +/* 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] = { - double size = dSize * 0.5; + 0.0, 0.0, 1.0, + 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + -1.0, 0.0, 0.0, + 0.0,-1.0, 0.0, + 0.0, 0.0,-1.0 +}; - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" ); +/* Vertex indices */ +static GLubyte cube_vi[CUBE_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 +}; +DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE); + +/* -- 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_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 */ +/* 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 +#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 +/* 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, +}; -# define V(a,b,c) glVertex3d( a size, b size, c size ); -# define N(a,b,c) glNormal3d( a, b, c ); +/* 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 +#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 + +/* 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., - /* 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(); +}; +/* 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 + +}; -# undef V -# undef N +/* Vertex indices */ +static GLubyte octahedron_vi[OCTAHEDRON_VERT_PER_OBJ] = +{ + 0, 1, 2, + 0, 5, 1, + 0, 2, 4, + 0, 4, 5, + 3, 2, 1, + 3, 1, 5, + 3, 4, 2, + 3, 5, 4 +}; +DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON); + +/* -- RhombicDodecahedron -- */ +#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_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */ + +/* 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_DECOMPOSE_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON); + +/* -- Tetrahedron -- */ +/* Magic Numbers: r0 = ( 1, 0, 0 ) + * r1 = ( -1/3, 2 sqrt(2) / 3, 0 ) + * r2 = ( -1/3, - sqrt(2) / 3, sqrt(6) / 3 ) + * r3 = ( -1/3, - sqrt(2) / 3, -sqrt(6) / 3 ) + * |r0| = |r1| = |r2| = |r3| = 1 + * Distance between any two points is 2 sqrt(6) / 3 + * + * Normals: The unit normals are simply the negative of the coordinates of the point not on the surface. + */ +#define 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_TRI TETRAHEDRON_VERT_PER_OBJ + +/* Vertex Coordinates */ +static GLdouble tetrahedron_v[TETRAHEDRON_NUM_VERT*3] = +{ + 1.0, 0.0, 0.0, + -0.333333333333, 0.942809041582, 0.0, + -0.333333333333, -0.471404520791, 0.816496580928, + -0.333333333333, -0.471404520791, -0.816496580928 +}; +/* Normal Vectors */ +static GLdouble tetrahedron_n[TETRAHEDRON_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 tetrahedron_vi[TETRAHEDRON_VERT_PER_OBJ] = +{ + 1, 3, 2, + 0, 2, 3, + 0, 3, 1, + 0, 1, 2 +}; +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; + if ( numLevels == 0 ) + { + for (i=0; i 0 ) + { + GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ + unsigned int stride = ipow(4,--numLevels)*TETRAHEDRON_VERT_ELEM_PER_OBJ; + scale /= 2.0 ; + for ( i = 0 ; i < TETRAHEDRON_NUM_FACES ; i++ ) + { + int idx = i*3; + 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 ); + } + } } +/* -- 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 @@ -120,7 +573,6 @@ void FGAPIENTRY glutSolidCube( GLdouble dSize ) * The last entry is exactly the same as the first * The sign of n can be flipped to get the reverse loop */ - static void fghCircleTable(double **sint,double **cost,const int n) { int i; @@ -164,6 +616,116 @@ static void fghCircleTable(double **sint,double **cost,const int n) (*cost)[size] = (*cost)[0]; } + +/* -- INTERNAL DRAWING functions --------------------------------------- */ +#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\ + static void fgh##nameICaps( GLboolean useWireMode )\ + {\ + if (!name##Cached)\ + {\ + fgh##nameICaps##Generate();\ + name##Cached = GL_TRUE;\ + }\ + \ + 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##_vertIdxs) + +static void fghCube( GLdouble dSize, GLboolean useWireMode ) +{ + GLdouble *vertices; + + if (!cubeCached) + { + fghCubeGenerate(); + cubeCached = GL_TRUE; + } + + if (dSize!=1.) + { + /* Need to build new vertex list containing vertices for cube of different size */ + int i; + + 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 0 ) - { - GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ - num_levels -- ; - scale /= 2.0 ; - for ( i = 0 ; i < NUM_TETR_FACES ; i++ ) - { - local_offset[0] = offset[0] + scale * tet_r[i][0] ; - local_offset[1] = offset[1] + scale * tet_r[i][1] ; - local_offset[2] = offset[2] + scale * tet_r[i][2] ; - glutWireSierpinskiSponge ( num_levels, local_offset, scale ) ; - } - } + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" ); + fghSierpinskiSponge ( num_levels, offset, scale, TRUE ); } - void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale ) { - int i, j ; - - FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" ); - - if ( num_levels == 0 ) - { - glBegin ( GL_TRIANGLES ) ; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" ); + fghSierpinskiSponge ( num_levels, offset, scale, FALSE ); +} - for ( i = 0 ; i < NUM_TETR_FACES ; i++ ) - { - glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ; - for ( j = 0; j < 3; j++ ) - { - double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ; - double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ; - double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ; - glVertex3d ( x, y, z ) ; - } - } +DECLARE_SHAPE_INTERFACE(Tetrahedron); - glEnd () ; - } - else if ( num_levels > 0 ) - { - GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */ - num_levels -- ; - scale /= 2.0 ; - for ( i = 0 ; i < NUM_TETR_FACES ; i++ ) - { - local_offset[0] = offset[0] + scale * tet_r[i][0] ; - local_offset[1] = offset[1] + scale * tet_r[i][1] ; - local_offset[2] = offset[2] + scale * tet_r[i][2] ; - glutSolidSierpinskiSponge ( num_levels, local_offset, scale ) ; - } - } -} /*** END OF FILE ***/