4 * Freeglut geometry rendering methods.
6 * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7 * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8 * Creation date: Fri Dec 3 1999
10 * Permission is hereby granted, free of charge, to any person obtaining a
11 * copy of this software and associated documentation files (the "Software"),
12 * to deal in the Software without restriction, including without limitation
13 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 * and/or sell copies of the Software, and to permit persons to whom the
15 * Software is furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included
18 * in all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
24 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 #include <GL/freeglut.h>
29 #include "fg_internal.h"
32 * Need more types of polyhedra? See CPolyhedron in MRPT
36 #ifndef GL_ES_VERSION_2_0
37 /* General functions for drawing geometry
38 * Solids are drawn by glDrawArrays if composed of triangles, or by
39 * glDrawElements if consisting of squares or pentagons that were
40 * decomposed into triangles (some vertices are repeated in that case).
41 * WireFrame drawing will have to be done per face, using GL_LINE_LOOP and
42 * issuing one draw call per face. Always use glDrawArrays as no triangle
43 * decomposition needed. We use the "first" parameter in glDrawArrays to go
46 static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace)
50 glEnableClientState(GL_VERTEX_ARRAY);
51 glEnableClientState(GL_NORMAL_ARRAY);
53 glVertexPointer(3, GL_FLOAT, 0, vertices);
54 glNormalPointer(GL_FLOAT, 0, normals);
56 /* Draw per face (TODO: could use glMultiDrawArrays if available) */
57 for (i=0; i<numFaces; i++)
58 glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace);
60 glDisableClientState(GL_VERTEX_ARRAY);
61 glDisableClientState(GL_NORMAL_ARRAY);
64 * Draw the geometric shape with filled triangles
66 * - If the shape is naturally triangulated (numEdgePerFace==3), each
67 * vertex+normal pair is used only once, so no vertex indices.
69 * - If the shape was triangulated (DECOMPOSE_TO_TRIANGLE), some
70 * vertex+normal pairs are reused, so use vertex indices.
72 static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs,
73 GLsizei numVertices, GLsizei numVertIdxs, GLsizei numEdgePerFace)
75 glEnableClientState(GL_VERTEX_ARRAY);
76 glEnableClientState(GL_NORMAL_ARRAY);
78 glVertexPointer(3, GL_FLOAT, 0, vertices);
79 glNormalPointer(GL_FLOAT, 0, normals);
80 if (numEdgePerFace==3)
81 glDrawArrays(GL_TRIANGLES, 0, numVertices);
83 glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, vertIdxs);
85 glDisableClientState(GL_VERTEX_ARRAY);
86 glDisableClientState(GL_NORMAL_ARRAY);
89 /* Shape decomposition to triangles
90 * We'll use glDrawElements to draw all shapes that are not triangles, so
91 * generate an index vector here, using the below sampling scheme.
92 * Be careful to keep winding of all triangles counter-clockwise,
93 * assuming that input has correct winding...
95 static GLubyte vert4Decomp[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */
96 static GLubyte vert5Decomp[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */
98 static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLubyte *vertIdxOut)
100 int i,j,numEdgeIdxPerFace;
101 GLubyte *vertSamps = NULL;
102 switch (numEdgePerFace)
105 /* nothing to do here, we'll drawn with glDrawArrays */
108 vertSamps = vert4Decomp;
109 numEdgeIdxPerFace = 6; /* 6 output vertices for each face */
112 vertSamps = vert5Decomp;
113 numEdgeIdxPerFace = 9; /* 9 output vertices for each face */
117 * Build array with vertices using vertex coordinates and vertex indices
118 * Do same for normals.
119 * Need to do this because of different normals at shared vertices.
121 for (i=0; i<numFaces; i++)
124 int faceIdxVertIdx = i*numEdgePerFace; // index to first element of "row" in vertex indices
125 for (j=0; j<numEdgePerFace; j++)
127 int outIdx = i*numEdgePerFace*3+j*3;
128 int vertIdx = vertIndices[faceIdxVertIdx+j]*3;
130 vertOut[outIdx ] = vertices[vertIdx ];
131 vertOut[outIdx+1] = vertices[vertIdx+1];
132 vertOut[outIdx+2] = vertices[vertIdx+2];
134 normOut[outIdx ] = normals [normIdx ];
135 normOut[outIdx+1] = normals [normIdx+1];
136 normOut[outIdx+2] = normals [normIdx+2];
139 /* generate vertex indices for each face */
141 for (j=0; j<numEdgeIdxPerFace; j++)
142 vertIdxOut[i*numEdgeIdxPerFace+j] = faceIdxVertIdx + vertSamps[j];
146 static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut)
148 /* This function does the same as fghGenerateGeometryWithIndexArray, just skipping the index array generation... */
149 fghGenerateGeometryWithIndexArray(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL);
153 /* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */
154 /* -- stuff that can be cached -- */
155 /* Cache of input to glDrawArrays or glDrawElements
156 * In general, we build arrays with all vertices or normals.
157 * We cant compress this and use glDrawElements as all combinations of
158 * vertex and normals are unique.
160 #define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\
161 static GLboolean name##Cached = FALSE;\
162 static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
163 static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\
164 static void fgh##nameICaps##Generate()\
166 fghGenerateGeometry(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
167 name##_v, name##_vi, name##_n,\
168 name##_verts, name##_norms);\
170 #define DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(name,nameICaps,nameCaps)\
171 static GLboolean name##Cached = FALSE;\
172 static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
173 static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\
174 static GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\
175 static void fgh##nameICaps##Generate()\
177 fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
178 name##_v, name##_vi, name##_n,\
179 name##_verts, name##_norms, name##_vertIdxs);\
183 #define CUBE_NUM_VERT 8
184 #define CUBE_NUM_FACES 6
185 #define CUBE_NUM_EDGE_PER_FACE 4
186 #define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES*CUBE_NUM_EDGE_PER_FACE)
187 #define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ*3)
188 #define CUBE_VERT_PER_OBJ_TRI (CUBE_VERT_PER_OBJ+CUBE_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */
189 /* Vertex Coordinates */
190 static GLfloat cube_v[CUBE_NUM_VERT*3] =
202 static GLfloat cube_n[CUBE_NUM_FACES*3] =
212 /* Vertex indices, as quads, before triangulation */
213 static GLubyte cube_vi[CUBE_VERT_PER_OBJ] =
222 DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE);
224 /* -- Dodecahedron -- */
225 /* Magic Numbers: It is possible to create a dodecahedron by attaching two
226 * pentagons to each face of of a cube. The coordinates of the points are:
227 * (+-x,0, z); (+-1, 1, 1); (0, z, x )
228 * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or
229 * x = 0.61803398875 and z = 1.61803398875.
231 #define DODECAHEDRON_NUM_VERT 20
232 #define DODECAHEDRON_NUM_FACES 12
233 #define DODECAHEDRON_NUM_EDGE_PER_FACE 5
234 #define DODECAHEDRON_VERT_PER_OBJ (DODECAHEDRON_NUM_FACES*DODECAHEDRON_NUM_EDGE_PER_FACE)
235 #define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ*3)
236 #define DODECAHEDRON_VERT_PER_OBJ_TRI (DODECAHEDRON_VERT_PER_OBJ+DODECAHEDRON_NUM_FACES*4) /* 4 extra edges per face when drawing pentagons as triangles */
237 /* Vertex Coordinates */
238 static GLfloat dodecahedron_v[DODECAHEDRON_NUM_VERT*3] =
240 0.0f, 1.61803398875f, 0.61803398875f,
242 -0.61803398875f, 0.0f, 1.61803398875f,
243 0.61803398875f, 0.0f, 1.61803398875f,
245 0.0f, 1.61803398875f, -0.61803398875f,
247 0.61803398875f, 0.0f, -1.61803398875f,
248 -0.61803398875f, 0.0f, -1.61803398875f,
249 - 1.0f, 1.0f, - 1.0f,
250 0.0f, -1.61803398875f, 0.61803398875f,
252 - 1.0f, - 1.0f, 1.0f,
253 0.0f, -1.61803398875f, -0.61803398875f,
254 - 1.0f, - 1.0f, - 1.0f,
255 1.0f, - 1.0f, - 1.0f,
256 1.61803398875f, -0.61803398875f, 0.0f,
257 1.61803398875f, 0.61803398875f, 0.0f,
258 -1.61803398875f, 0.61803398875f, 0.0f,
259 -1.61803398875f, -0.61803398875f, 0.0f
262 static GLfloat dodecahedron_n[DODECAHEDRON_NUM_FACES*3] =
264 0.0f, 0.525731112119f, 0.850650808354f,
265 0.0f, 0.525731112119f, -0.850650808354f,
266 0.0f, -0.525731112119f, 0.850650808354f,
267 0.0f, -0.525731112119f, -0.850650808354f,
269 0.850650808354f, 0.0f, 0.525731112119f,
270 -0.850650808354f, 0.0f, 0.525731112119f,
271 0.850650808354f, 0.0f, -0.525731112119f,
272 -0.850650808354f, 0.0f, -0.525731112119f,
274 0.525731112119f, 0.850650808354f, 0.0f,
275 0.525731112119f, -0.850650808354f, 0.0f,
276 -0.525731112119f, 0.850650808354f, 0.0f,
277 -0.525731112119f, -0.850650808354f, 0.0f,
281 static GLubyte dodecahedron_vi[DODECAHEDRON_VERT_PER_OBJ] =
298 DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON);
301 /* -- Icosahedron -- */
302 #define ICOSAHEDRON_NUM_VERT 12
303 #define ICOSAHEDRON_NUM_FACES 20
304 #define ICOSAHEDRON_NUM_EDGE_PER_FACE 3
305 #define ICOSAHEDRON_VERT_PER_OBJ (ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE)
306 #define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ*3)
307 #define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ
308 /* Vertex Coordinates */
309 static GLfloat icosahedron_v[ICOSAHEDRON_NUM_VERT*3] =
312 0.447213595500f, 0.894427191000f, 0.0f,
313 0.447213595500f, 0.276393202252f, 0.850650808354f,
314 0.447213595500f, -0.723606797748f, 0.525731112119f,
315 0.447213595500f, -0.723606797748f, -0.525731112119f,
316 0.447213595500f, 0.276393202252f, -0.850650808354f,
317 -0.447213595500f, -0.894427191000f, 0.0f,
318 -0.447213595500f, -0.276393202252f, 0.850650808354f,
319 -0.447213595500f, 0.723606797748f, 0.525731112119f,
320 -0.447213595500f, 0.723606797748f, -0.525731112119f,
321 -0.447213595500f, -0.276393202252f, -0.850650808354f,
325 * 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] ) ;
326 * 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] ) ;
327 * 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] ) ;
329 static GLfloat icosahedron_n[ICOSAHEDRON_NUM_FACES*3] =
331 0.760845213037948f, 0.470228201835026f, 0.341640786498800f,
332 0.760845213036861f, -0.179611190632978f, 0.552786404500000f,
333 0.760845213033849f, -0.581234022404097f, 0.0f,
334 0.760845213036861f, -0.179611190632978f, -0.552786404500000f,
335 0.760845213037948f, 0.470228201835026f, -0.341640786498800f,
336 0.179611190628666f, 0.760845213037948f, 0.552786404498399f,
337 0.179611190634277f, -0.290617011204044f, 0.894427191000000f,
338 0.179611190633958f, -0.940456403667806f, 0.0f,
339 0.179611190634278f, -0.290617011204044f, -0.894427191000000f,
340 0.179611190628666f, 0.760845213037948f, -0.552786404498399f,
341 -0.179611190633958f, 0.940456403667806f, 0.0f,
342 -0.179611190634277f, 0.290617011204044f, 0.894427191000000f,
343 -0.179611190628666f, -0.760845213037948f, 0.552786404498399f,
344 -0.179611190628666f, -0.760845213037948f, -0.552786404498399f,
345 -0.179611190634277f, 0.290617011204044f, -0.894427191000000f,
346 -0.760845213036861f, 0.179611190632978f, -0.552786404500000f,
347 -0.760845213033849f, 0.581234022404097f, 0.0f,
348 -0.760845213036861f, 0.179611190632978f, 0.552786404500000f,
349 -0.760845213037948f, -0.470228201835026f, 0.341640786498800f,
350 -0.760845213037948f, -0.470228201835026f, -0.341640786498800f,
354 static GLubyte icosahedron_vi[ICOSAHEDRON_VERT_PER_OBJ] =
377 DECLARE_SHAPE_CACHE(icosahedron,Icosahedron,ICOSAHEDRON);
379 /* -- Octahedron -- */
380 #define OCTAHEDRON_NUM_VERT 6
381 #define OCTAHEDRON_NUM_FACES 8
382 #define OCTAHEDRON_NUM_EDGE_PER_FACE 3
383 #define OCTAHEDRON_VERT_PER_OBJ (OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE)
384 #define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ*3)
385 #define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ
387 /* Vertex Coordinates */
388 static GLfloat octahedron_v[OCTAHEDRON_NUM_VERT*3] =
399 static GLfloat octahedron_n[OCTAHEDRON_NUM_FACES*3] =
401 0.577350269189f, 0.577350269189f, 0.577350269189f, /* sqrt(1/3) */
402 0.577350269189f, 0.577350269189f,-0.577350269189f,
403 0.577350269189f,-0.577350269189f, 0.577350269189f,
404 0.577350269189f,-0.577350269189f,-0.577350269189f,
405 -0.577350269189f, 0.577350269189f, 0.577350269189f,
406 -0.577350269189f, 0.577350269189f,-0.577350269189f,
407 -0.577350269189f,-0.577350269189f, 0.577350269189f,
408 -0.577350269189f,-0.577350269189f,-0.577350269189f
413 static GLubyte octahedron_vi[OCTAHEDRON_VERT_PER_OBJ] =
424 DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON);
426 /* -- RhombicDodecahedron -- */
427 #define RHOMBICDODECAHEDRON_NUM_VERT 14
428 #define RHOMBICDODECAHEDRON_NUM_FACES 12
429 #define RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE 4
430 #define RHOMBICDODECAHEDRON_VERT_PER_OBJ (RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE)
431 #define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ*3)
432 #define RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */
434 /* Vertex Coordinates */
435 static GLfloat rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] =
438 0.707106781187f, 0.0f, 0.5f,
439 0.0f, 0.707106781187f, 0.5f,
440 -0.707106781187f, 0.0f, 0.5f,
441 0.0f, -0.707106781187f, 0.5f,
442 0.707106781187f, 0.707106781187f, 0.0f,
443 -0.707106781187f, 0.707106781187f, 0.0f,
444 -0.707106781187f, -0.707106781187f, 0.0f,
445 0.707106781187f, -0.707106781187f, 0.0f,
446 0.707106781187f, 0.0f, -0.5f,
447 0.0f, 0.707106781187f, -0.5f,
448 -0.707106781187f, 0.0f, -0.5f,
449 0.0f, -0.707106781187f, -0.5f,
453 static GLfloat rhombicdodecahedron_n[RHOMBICDODECAHEDRON_NUM_FACES*3] =
455 0.353553390594f, 0.353553390594f, 0.5f,
456 -0.353553390594f, 0.353553390594f, 0.5f,
457 -0.353553390594f, -0.353553390594f, 0.5f,
458 0.353553390594f, -0.353553390594f, 0.5f,
463 0.353553390594f, 0.353553390594f, -0.5f,
464 -0.353553390594f, 0.353553390594f, -0.5f,
465 -0.353553390594f, -0.353553390594f, -0.5f,
466 0.353553390594f, -0.353553390594f, -0.5f
470 static GLubyte rhombicdodecahedron_vi[RHOMBICDODECAHEDRON_VERT_PER_OBJ] =
485 DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON);
487 /* -- Tetrahedron -- */
488 /* Magic Numbers: r0 = ( 1, 0, 0 )
489 * r1 = ( -1/3, 2 sqrt(2) / 3, 0 )
490 * r2 = ( -1/3, - sqrt(2) / 3, sqrt(6) / 3 )
491 * r3 = ( -1/3, - sqrt(2) / 3, -sqrt(6) / 3 )
492 * |r0| = |r1| = |r2| = |r3| = 1
493 * Distance between any two points is 2 sqrt(6) / 3
495 * Normals: The unit normals are simply the negative of the coordinates of the point not on the surface.
497 #define TETRAHEDRON_NUM_VERT 4
498 #define TETRAHEDRON_NUM_FACES 4
499 #define TETRAHEDRON_NUM_EDGE_PER_FACE 3
500 #define TETRAHEDRON_VERT_PER_OBJ (TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE)
501 #define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ*3)
502 #define TETRAHEDRON_VERT_PER_OBJ_TRI TETRAHEDRON_VERT_PER_OBJ
504 /* Vertex Coordinates */
505 static GLfloat tetrahedron_v[TETRAHEDRON_NUM_VERT*3] =
508 -0.333333333333f, 0.942809041582f, 0.0f,
509 -0.333333333333f, -0.471404520791f, 0.816496580928f,
510 -0.333333333333f, -0.471404520791f, -0.816496580928f
513 static GLfloat tetrahedron_n[TETRAHEDRON_NUM_FACES*3] =
516 0.333333333333f, -0.942809041582f, 0.0f,
517 0.333333333333f, 0.471404520791f, -0.816496580928f,
518 0.333333333333f, 0.471404520791f, 0.816496580928f
522 static GLubyte tetrahedron_vi[TETRAHEDRON_VERT_PER_OBJ] =
529 DECLARE_SHAPE_CACHE(tetrahedron,Tetrahedron,TETRAHEDRON);
531 /* -- Sierpinski Sponge -- */
532 static unsigned int ipow (int x, unsigned int y)
534 return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2);
537 static void fghSierpinskiSpongeGenerate ( int numLevels, double offset[3], GLfloat scale, GLfloat* vertices, GLfloat* normals )
540 if ( numLevels == 0 )
542 for (i=0; i<TETRAHEDRON_NUM_FACES; i++)
545 int faceIdxVertIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE;
546 for (j=0; j<TETRAHEDRON_NUM_EDGE_PER_FACE; j++)
548 int outIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE*3+j*3;
549 int vertIdx = tetrahedron_vi[faceIdxVertIdx+j]*3;
551 vertices[outIdx ] = (GLfloat)offset[0] + scale * tetrahedron_v[vertIdx ];
552 vertices[outIdx+1] = (GLfloat)offset[1] + scale * tetrahedron_v[vertIdx+1];
553 vertices[outIdx+2] = (GLfloat)offset[2] + scale * tetrahedron_v[vertIdx+2];
555 normals [outIdx ] = tetrahedron_n[normIdx ];
556 normals [outIdx+1] = tetrahedron_n[normIdx+1];
557 normals [outIdx+2] = tetrahedron_n[normIdx+2];
561 else if ( numLevels > 0 )
563 double local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */
564 unsigned int stride = ipow(4,--numLevels)*TETRAHEDRON_VERT_ELEM_PER_OBJ;
566 for ( i = 0 ; i < TETRAHEDRON_NUM_FACES ; i++ )
569 local_offset[0] = offset[0] + scale * tetrahedron_v[idx ];
570 local_offset[1] = offset[1] + scale * tetrahedron_v[idx+1];
571 local_offset[2] = offset[2] + scale * tetrahedron_v[idx+2];
572 fghSierpinskiSpongeGenerate ( numLevels, local_offset, scale, vertices+i*stride, normals+i*stride );
577 /* -- Now the various shapes involving circles -- */
579 * Compute lookup table of cos and sin values forming a circle
580 * (or half circle if halfCircle==TRUE)
583 * It is the responsibility of the caller to free these tables
584 * The size of the table is (n+1) to form a connected loop
585 * The last entry is exactly the same as the first
586 * The sign of n can be flipped to get the reverse loop
588 static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GLboolean halfCircle)
592 /* Table size, the sign of n flips the circle direction */
593 const int size = abs(n);
595 /* Determine the angle between samples */
596 const GLfloat angle = (halfCircle?1:2)*(GLfloat)M_PI/(GLfloat)( ( n == 0 ) ? 1 : n );
598 /* Allocate memory for n samples, plus duplicate of first entry at the end */
599 *sint = malloc(sizeof(GLfloat) * (size+1));
600 *cost = malloc(sizeof(GLfloat) * (size+1));
602 /* Bail out if memory allocation fails, fgError never returns */
603 if (!(*sint) || !(*cost))
607 fgError("Failed to allocate memory in fghCircleTable");
610 /* Compute cos and sin around the circle */
614 for (i=1; i<size; i++)
616 (*sint)[i] = sinf(angle*i);
617 (*cost)[i] = cosf(angle*i);
623 (*sint)[size] = 0.0f; /* sin PI */
624 (*cost)[size] = -1.0f; /* cos PI */
628 /* Last sample is duplicate of the first (sin or cos of 2 PI) */
629 (*sint)[size] = (*sint)[0];
630 (*cost)[size] = (*cost)[0];
635 /* -- INTERNAL DRAWING functions --------------------------------------- */
636 #define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\
637 static void fgh##nameICaps( GLboolean useWireMode )\
641 fgh##nameICaps##Generate();\
642 name##Cached = GL_TRUE;\
647 fghDrawGeometryWire (name##_verts,name##_norms,\
648 nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\
652 fghDrawGeometrySolid(name##_verts,name##_norms,vertIdxs,\
653 nameCaps##_VERT_PER_OBJ, nameCaps##_VERT_PER_OBJ_TRI, nameCaps##_NUM_EDGE_PER_FACE); \
656 #define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL)
657 #define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_vertIdxs)
659 static void fghCube( GLfloat dSize, GLboolean useWireMode )
666 cubeCached = GL_TRUE;
671 /* Need to build new vertex list containing vertices for cube of different size */
674 vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLfloat));
676 /* Bail out if memory allocation fails, fgError never returns */
680 fgError("Failed to allocate memory in fghCube");
683 for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++)
684 vertices[i] = dSize*cube_verts[i];
687 vertices = cube_verts;
690 fghDrawGeometryWire (vertices, cube_norms,
691 CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE);
693 fghDrawGeometrySolid(vertices, cube_norms, cube_vertIdxs,
694 CUBE_VERT_PER_OBJ, CUBE_VERT_PER_OBJ_TRI, CUBE_NUM_EDGE_PER_FACE);
697 /* cleanup allocated memory */
701 DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON);
702 DECLARE_INTERNAL_DRAW(icosahedron,Icosahedron,ICOSAHEDRON);
703 DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON);
704 DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON);
705 DECLARE_INTERNAL_DRAW(tetrahedron,Tetrahedron,TETRAHEDRON);
707 static void fghSierpinskiSponge ( int numLevels, double offset[3], GLfloat scale, GLboolean useWireMode )
711 GLsizei numTetr = numLevels<0? 0 : ipow(4,numLevels); /* No sponge for numLevels below 0 */
712 GLsizei numVert = numTetr*TETRAHEDRON_VERT_PER_OBJ;
713 GLsizei numFace = numTetr*TETRAHEDRON_NUM_FACES;
717 /* Allocate memory */
718 vertices = malloc(numVert*3 * sizeof(GLfloat));
719 normals = malloc(numVert*3 * sizeof(GLfloat));
720 /* Bail out if memory allocation fails, fgError never returns */
721 if (!vertices || !normals)
725 fgError("Failed to allocate memory in fghSierpinskiSponge");
728 /* Generate elements */
729 fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals );
731 /* Draw and cleanup */
733 fghDrawGeometryWire (vertices,normals, numFace,TETRAHEDRON_NUM_EDGE_PER_FACE);
735 fghDrawGeometrySolid(vertices,normals,NULL,numVert,numVert, TETRAHEDRON_NUM_EDGE_PER_FACE);
741 #endif /* GL_ES_VERSION_2_0 */
744 /* -- INTERFACE FUNCTIONS ---------------------------------------------- */
747 #ifndef EGL_VERSION_1_0
749 * Draws a solid sphere
751 void FGAPIENTRY glutSolidSphere(double radius, GLint slices, GLint stacks)
755 /* Adjust z and radius as stacks are drawn. */
756 GLfloat radf = (GLfloat)radius;
760 /* Pre-computed circle */
762 GLfloat *sint1,*cost1;
763 GLfloat *sint2,*cost2;
765 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );
767 fghCircleTable(&sint1,&cost1,-slices,FALSE);
768 fghCircleTable(&sint2,&cost2, stacks,TRUE);
770 /* The top stack is covered with a triangle fan */
773 z1 = cost2[(stacks>0)?1:0];
775 r1 = sint2[(stacks>0)?1:0];
777 glBegin(GL_TRIANGLE_FAN);
780 glVertex3f(0,0,radf);
782 for (j=slices; j>=0; j--)
784 glNormal3f(cost1[j]*r1, sint1[j]*r1, z1 );
785 glVertex3f(cost1[j]*r1*radf, sint1[j]*r1*radf, z1*radf);
790 /* Cover each stack with a quad strip, except the top and bottom stacks */
792 for( i=1; i<stacks-1; i++ )
794 z0 = z1; z1 = cost2[i+1];
795 r0 = r1; r1 = sint2[i+1];
797 glBegin(GL_QUAD_STRIP);
799 for(j=0; j<=slices; j++)
801 glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 );
802 glVertex3d(cost1[j]*r1*radf, sint1[j]*r1*radf, z1*radf);
803 glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
804 glVertex3d(cost1[j]*r0*radf, sint1[j]*r0*radf, z0*radf);
810 /* The bottom stack is covered with a triangle fan */
815 glBegin(GL_TRIANGLE_FAN);
818 glVertex3d(0,0,-radius);
820 for (j=0; j<=slices; j++)
822 glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
823 glVertex3d(cost1[j]*r0*radf, sint1[j]*r0*radf, z0*radf);
828 /* Release sin and cos tables */
837 * Draws a wire sphere
839 void FGAPIENTRY glutWireSphere(double radius, GLint slices, GLint stacks)
843 /* Adjust z and radius as stacks and slices are drawn. */
844 GLfloat radf = (GLfloat)radius;
848 /* Pre-computed circle */
850 GLfloat *sint1,*cost1;
851 GLfloat *sint2,*cost2;
853 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
855 fghCircleTable(&sint1,&cost1,-slices,FALSE);
856 fghCircleTable(&sint2,&cost2, stacks,TRUE);
858 /* Draw a line loop for each stack */
860 for (i=1; i<stacks; i++)
865 glBegin(GL_LINE_LOOP);
867 for(j=0; j<=slices; j++)
873 glVertex3f(x*r*radf,y*r*radf,z*radf);
879 /* Draw a line loop for each slice */
881 for (i=0; i<slices; i++)
883 glBegin(GL_LINE_STRIP);
885 for(j=0; j<=stacks; j++)
887 x = cost1[i]*sint2[j];
888 y = sint1[i]*sint2[j];
892 glVertex3f(x*radf,y*radf,z*radf);
898 /* Release sin and cos tables */
909 void FGAPIENTRY glutSolidCone( double base, double height, GLint slices, GLint stacks )
913 /* Step in z and radius as stacks are drawn. */
918 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
919 const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 );
921 /* Scaling factors for vertex normals */
923 const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base ));
924 const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base ));
926 /* Pre-computed circle */
930 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );
932 fghCircleTable(&sint,&cost,-slices,FALSE);
934 /* Cover the circular base with a triangle fan... */
942 glBegin(GL_TRIANGLE_FAN);
945 glVertex3f(0,0, z0 );
947 for (j=0; j<=slices; j++)
948 glVertex3f(cost[j]*r0, sint[j]*r0, z0);
952 /* Cover each stack with a quad strip, except the top stack */
954 for( i=0; i<stacks-1; i++ )
956 glBegin(GL_QUAD_STRIP);
958 for(j=0; j<=slices; j++)
960 glNormal3f(cost[j]*cosn, sint[j]*cosn, sinn);
961 glVertex3f(cost[j]*r0, sint[j]*r0, z0 );
962 glVertex3f(cost[j]*r1, sint[j]*r1, z1 );
965 z0 = z1; z1 += zStep;
966 r0 = r1; r1 -= rStep;
971 /* The top stack is covered with individual triangles */
973 glBegin(GL_TRIANGLES);
975 glNormal3f(cost[0]*sinn, sint[0]*sinn, cosn);
977 for (j=0; j<slices; j++)
979 glVertex3f(cost[j+0]*r0, sint[j+0]*r0, z0 );
980 glVertex3f(0, 0, (GLfloat)height);
981 glNormal3f(cost[j+1]*sinn, sint[j+1]*sinn, cosn );
982 glVertex3f(cost[j+1]*r0, sint[j+1]*r0, z0 );
987 /* Release sin and cos tables */
996 void FGAPIENTRY glutWireCone( double base, double height, GLint slices, GLint stacks)
1000 /* Step in z and radius as stacks are drawn. */
1003 GLfloat r = (GLfloat)base;
1005 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
1006 const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 );
1008 /* Scaling factors for vertex normals */
1010 const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base ));
1011 const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base ));
1013 /* Pre-computed circle */
1015 GLfloat *sint,*cost;
1017 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" );
1019 fghCircleTable(&sint,&cost,-slices,FALSE);
1021 /* Draw the stacks... */
1023 for (i=0; i<stacks; i++)
1025 glBegin(GL_LINE_LOOP);
1027 for( j=0; j<slices; j++ )
1029 glNormal3f(cost[j]*sinn, sint[j]*sinn, cosn);
1030 glVertex3f(cost[j]*r, sint[j]*r, z );
1039 /* Draw the slices */
1045 for (j=0; j<slices; j++)
1047 glNormal3f(cost[j]*sinn, sint[j]*sinn, cosn );
1048 glVertex3f(cost[j]*r, sint[j]*r, 0 );
1049 glVertex3f(0, 0, (GLfloat)height);
1054 /* Release sin and cos tables */
1062 * Draws a solid cylinder
1064 void FGAPIENTRY glutSolidCylinder(double radius, double height, GLint slices, GLint stacks)
1068 /* Step in z and radius as stacks are drawn. */
1069 GLfloat radf = (GLfloat)radius;
1071 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
1073 /* Pre-computed circle */
1075 GLfloat *sint,*cost;
1077 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
1079 fghCircleTable(&sint,&cost,-slices,FALSE);
1081 /* Cover the base and top */
1083 glBegin(GL_TRIANGLE_FAN);
1084 glNormal3f(0, 0, -1 );
1085 glVertex3f(0, 0, 0 );
1086 for (j=0; j<=slices; j++)
1087 glVertex3f(cost[j]*radf, sint[j]*radf, 0);
1090 glBegin(GL_TRIANGLE_FAN);
1091 glNormal3f(0, 0, 1 );
1092 glVertex3f(0, 0, (GLfloat)height);
1093 for (j=slices; j>=0; j--)
1094 glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height);
1102 for (i=1; i<=stacks; i++)
1105 z1 = (GLfloat)height;
1107 glBegin(GL_QUAD_STRIP);
1108 for (j=0; j<=slices; j++ )
1110 glNormal3f(cost[j], sint[j], 0 );
1111 glVertex3f(cost[j]*radf, sint[j]*radf, z0 );
1112 glVertex3f(cost[j]*radf, sint[j]*radf, z1 );
1116 z0 = z1; z1 += zStep;
1119 /* Release sin and cos tables */
1126 * Draws a wire cylinder
1128 void FGAPIENTRY glutWireCylinder(double radius, double height, GLint slices, GLint stacks)
1132 /* Step in z and radius as stacks are drawn. */
1133 GLfloat radf = (GLfloat)radius;
1135 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
1137 /* Pre-computed circle */
1139 GLfloat *sint,*cost;
1141 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
1143 fghCircleTable(&sint,&cost,-slices,FALSE);
1145 /* Draw the stacks... */
1147 for (i=0; i<=stacks; i++)
1150 z = (GLfloat)height;
1152 glBegin(GL_LINE_LOOP);
1154 for( j=0; j<slices; j++ )
1156 glNormal3f(cost[j], sint[j], 0);
1157 glVertex3f(cost[j]*radf, sint[j]*radf, z);
1165 /* Draw the slices */
1169 for (j=0; j<slices; j++)
1171 glNormal3f(cost[j], sint[j], 0 );
1172 glVertex3f(cost[j]*radf, sint[j]*radf, 0 );
1173 glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height);
1178 /* Release sin and cos tables */
1185 * Draws a wire torus
1187 void FGAPIENTRY glutWireTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
1189 GLfloat iradius = (float)dInnerRadius, oradius = (float)dOuterRadius;
1190 GLfloat phi, psi, dpsi, dphi;
1191 GLfloat *vertex, *normal;
1193 GLfloat spsi, cpsi, sphi, cphi ;
1195 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
1197 if ( nSides < 1 ) nSides = 1;
1198 if ( nRings < 1 ) nRings = 1;
1200 /* Allocate the vertices array */
1201 vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1202 normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1206 dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings) ;
1207 dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides) ;
1210 for( j=0; j<nRings; j++ )
1212 cpsi = cosf( psi ) ;
1213 spsi = sinf( psi ) ;
1216 for( i=0; i<nSides; i++ )
1218 int offset = 3 * ( j * nSides + i ) ;
1219 cphi = cosf( phi ) ;
1220 sphi = sinf( phi ) ;
1221 *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
1222 *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
1223 *(vertex + offset + 2) = sphi * iradius ;
1224 *(normal + offset + 0) = cpsi * cphi ;
1225 *(normal + offset + 1) = spsi * cphi ;
1226 *(normal + offset + 2) = sphi ;
1233 for( i=0; i<nSides; i++ )
1235 glBegin( GL_LINE_LOOP );
1237 for( j=0; j<nRings; j++ )
1239 int offset = 3 * ( j * nSides + i ) ;
1240 glNormal3fv( normal + offset );
1241 glVertex3fv( vertex + offset );
1247 for( j=0; j<nRings; j++ )
1249 glBegin(GL_LINE_LOOP);
1251 for( i=0; i<nSides; i++ )
1253 int offset = 3 * ( j * nSides + i ) ;
1254 glNormal3fv( normal + offset );
1255 glVertex3fv( vertex + offset );
1267 * Draws a solid torus
1269 void FGAPIENTRY glutSolidTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
1271 GLfloat iradius = (float)dInnerRadius, oradius = (float)dOuterRadius;
1272 GLfloat phi, psi, dpsi, dphi;
1273 GLfloat *vertex, *normal;
1275 GLfloat spsi, cpsi, sphi, cphi ;
1277 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );
1279 if ( nSides < 1 ) nSides = 1;
1280 if ( nRings < 1 ) nRings = 1;
1282 /* Increment the number of sides and rings to allow for one more point than surface */
1286 /* Allocate the vertices array */
1287 vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1288 normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1292 dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings - 1) ;
1293 dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides - 1) ;
1296 for( j=0; j<nRings; j++ )
1298 cpsi = cosf( psi ) ;
1299 spsi = sinf( psi ) ;
1302 for( i=0; i<nSides; i++ )
1304 int offset = 3 * ( j * nSides + i ) ;
1305 cphi = cosf( phi ) ;
1306 sphi = sinf( phi ) ;
1307 *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
1308 *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
1309 *(vertex + offset + 2) = sphi * iradius ;
1310 *(normal + offset + 0) = cpsi * cphi ;
1311 *(normal + offset + 1) = spsi * cphi ;
1312 *(normal + offset + 2) = sphi ;
1319 glBegin( GL_QUADS );
1320 for( i=0; i<nSides-1; i++ )
1322 for( j=0; j<nRings-1; j++ )
1324 int offset = 3 * ( j * nSides + i ) ;
1325 glNormal3fv( normal + offset );
1326 glVertex3fv( vertex + offset );
1327 glNormal3fv( normal + offset + 3 );
1328 glVertex3fv( vertex + offset + 3 );
1329 glNormal3fv( normal + offset + 3 * nSides + 3 );
1330 glVertex3fv( vertex + offset + 3 * nSides + 3 );
1331 glNormal3fv( normal + offset + 3 * nSides );
1332 glVertex3fv( vertex + offset + 3 * nSides );
1342 #endif /* EGL_VERSION_1_0 */
1346 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
1347 /* Macro to generate interface functions */
1348 #define DECLARE_SHAPE_INTERFACE(nameICaps)\
1349 void FGAPIENTRY glutWire##nameICaps( void )\
1351 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWire"#nameICaps );\
1352 fgh##nameICaps( TRUE );\
1354 void FGAPIENTRY glutSolid##nameICaps( void )\
1356 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolid"#nameICaps );\
1357 fgh##nameICaps( FALSE );\
1360 void FGAPIENTRY glutWireCube( double dSize )
1362 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
1363 fghCube( (GLfloat)dSize, TRUE );
1365 void FGAPIENTRY glutSolidCube( double dSize )
1367 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
1368 fghCube( (GLfloat)dSize, FALSE );
1371 DECLARE_SHAPE_INTERFACE(Dodecahedron);
1372 DECLARE_SHAPE_INTERFACE(Icosahedron);
1373 DECLARE_SHAPE_INTERFACE(Octahedron);
1374 DECLARE_SHAPE_INTERFACE(RhombicDodecahedron);
1376 void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, double offset[3], double scale )
1378 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" );
1379 fghSierpinskiSponge ( num_levels, offset, (GLfloat)scale, TRUE );
1381 void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, double offset[3], double scale )
1383 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
1384 fghSierpinskiSponge ( num_levels, offset, (GLfloat)scale, FALSE );
1387 DECLARE_SHAPE_INTERFACE(Tetrahedron);
1390 /*** END OF FILE ***/