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);
63 static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs, GLsizei numVertices, GLsizei numEdgePerFace)
65 glEnableClientState(GL_VERTEX_ARRAY);
66 glEnableClientState(GL_NORMAL_ARRAY);
68 glVertexPointer(3, GL_FLOAT, 0, vertices);
69 glNormalPointer(GL_FLOAT, 0, normals);
70 if (numEdgePerFace==3)
71 glDrawArrays(GL_TRIANGLES, 0, numVertices);
73 glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_BYTE, vertIdxs);
75 glDisableClientState(GL_VERTEX_ARRAY);
76 glDisableClientState(GL_NORMAL_ARRAY);
79 /* Shape decomposition to triangles
80 * We'll use glDrawElements to draw all shapes that are not triangles, so
81 * generate an index vector here, using the below sampling scheme.
82 * Be careful to keep winding of all triangles counter-clockwise,
83 * assuming that input has correct winding...
85 static GLubyte vert4Decomp[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */
86 static GLubyte vert5Decomp[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */
88 static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLubyte *vertIdxOut)
90 int i,j,numEdgeIdxPerFace;
91 GLubyte *vertSamps = NULL;
92 switch (numEdgePerFace)
95 /* nothing to do here, we'll drawn with glDrawArrays */
98 vertSamps = vert4Decomp;
99 numEdgeIdxPerFace = 6; /* 6 output vertices for each face */
102 vertSamps = vert5Decomp;
103 numEdgeIdxPerFace = 9; /* 9 output vertices for each face */
107 * Build array with vertices using vertex coordinates and vertex indices
108 * Do same for normals.
109 * Need to do this because of different normals at shared vertices.
111 for (i=0; i<numFaces; i++)
114 int faceIdxVertIdx = i*numEdgePerFace; // index to first element of "row" in vertex indices
115 for (j=0; j<numEdgePerFace; j++)
117 int outIdx = i*numEdgePerFace*3+j*3;
118 int vertIdx = vertIndices[faceIdxVertIdx+j]*3;
120 vertOut[outIdx ] = vertices[vertIdx ];
121 vertOut[outIdx+1] = vertices[vertIdx+1];
122 vertOut[outIdx+2] = vertices[vertIdx+2];
124 normOut[outIdx ] = normals [normIdx ];
125 normOut[outIdx+1] = normals [normIdx+1];
126 normOut[outIdx+2] = normals [normIdx+2];
129 /* generate vertex indices for each face */
131 for (j=0; j<numEdgeIdxPerFace; j++)
132 vertIdxOut[i*numEdgeIdxPerFace+j] = faceIdxVertIdx + vertSamps[j];
136 static void fghGenerateGeometry(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut)
138 /* This function does the same as fghGenerateGeometryWithIndexArray, just skipping the index array generation... */
139 fghGenerateGeometryWithIndexArray(numFaces, numEdgePerFace, vertices, vertIndices, normals, vertOut, normOut, NULL);
143 /* -- INTERNAL SETUP OF GEOMETRY --------------------------------------- */
144 /* -- stuff that can be cached -- */
145 /* Cache of input to glDrawArrays or glDrawElements
146 * In general, we build arrays with all vertices or normals.
147 * We cant compress this and use glDrawElements as all combinations of
148 * vertex and normals are unique.
150 #define DECLARE_SHAPE_CACHE(name,nameICaps,nameCaps)\
151 static GLboolean name##Cached = FALSE;\
152 static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
153 static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\
154 static void fgh##nameICaps##Generate()\
156 fghGenerateGeometry(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
157 name##_v, name##_vi, name##_n,\
158 name##_verts, name##_norms);\
160 #define DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(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 GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\
165 static void fgh##nameICaps##Generate()\
167 fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
168 name##_v, name##_vi, name##_n,\
169 name##_verts, name##_norms, name##_vertIdxs);\
173 #define CUBE_NUM_VERT 8
174 #define CUBE_NUM_FACES 6
175 #define CUBE_NUM_EDGE_PER_FACE 4
176 #define CUBE_VERT_PER_OBJ (CUBE_NUM_FACES*CUBE_NUM_EDGE_PER_FACE)
177 #define CUBE_VERT_ELEM_PER_OBJ (CUBE_VERT_PER_OBJ*3)
178 #define CUBE_VERT_PER_OBJ_TRI (CUBE_VERT_PER_OBJ+CUBE_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */
179 /* Vertex Coordinates */
180 static GLfloat cube_v[CUBE_NUM_VERT*3] =
192 static GLfloat cube_n[CUBE_NUM_FACES*3] =
203 static GLubyte cube_vi[CUBE_VERT_PER_OBJ] =
212 DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(cube,Cube,CUBE);
214 /* -- Dodecahedron -- */
215 /* Magic Numbers: It is possible to create a dodecahedron by attaching two
216 * pentagons to each face of of a cube. The coordinates of the points are:
217 * (+-x,0, z); (+-1, 1, 1); (0, z, x )
218 * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or
219 * x = 0.61803398875 and z = 1.61803398875.
221 #define DODECAHEDRON_NUM_VERT 20
222 #define DODECAHEDRON_NUM_FACES 12
223 #define DODECAHEDRON_NUM_EDGE_PER_FACE 5
224 #define DODECAHEDRON_VERT_PER_OBJ (DODECAHEDRON_NUM_FACES*DODECAHEDRON_NUM_EDGE_PER_FACE)
225 #define DODECAHEDRON_VERT_ELEM_PER_OBJ (DODECAHEDRON_VERT_PER_OBJ*3)
226 #define DODECAHEDRON_VERT_PER_OBJ_TRI (DODECAHEDRON_VERT_PER_OBJ+DODECAHEDRON_NUM_FACES*4) /* 4 extra edges per face when drawing pentagons as triangles */
227 /* Vertex Coordinates */
228 static GLfloat dodecahedron_v[DODECAHEDRON_NUM_VERT*3] =
230 0.0f, 1.61803398875f, 0.61803398875f,
232 -0.61803398875f, 0.0f, 1.61803398875f,
233 0.61803398875f, 0.0f, 1.61803398875f,
235 0.0f, 1.61803398875f, -0.61803398875f,
237 0.61803398875f, 0.0f, -1.61803398875f,
238 -0.61803398875f, 0.0f, -1.61803398875f,
239 - 1.0f, 1.0f, - 1.0f,
240 0.0f, -1.61803398875f, 0.61803398875f,
242 - 1.0f, - 1.0f, 1.0f,
243 0.0f, -1.61803398875f, -0.61803398875f,
244 - 1.0f, - 1.0f, - 1.0f,
245 1.0f, - 1.0f, - 1.0f,
246 1.61803398875f, -0.61803398875f, 0.0f,
247 1.61803398875f, 0.61803398875f, 0.0f,
248 -1.61803398875f, 0.61803398875f, 0.0f,
249 -1.61803398875f, -0.61803398875f, 0.0f
252 static GLfloat dodecahedron_n[DODECAHEDRON_NUM_FACES*3] =
254 0.0f, 0.525731112119f, 0.850650808354f,
255 0.0f, 0.525731112119f, -0.850650808354f,
256 0.0f, -0.525731112119f, 0.850650808354f,
257 0.0f, -0.525731112119f, -0.850650808354f,
259 0.850650808354f, 0.0f, 0.525731112119f,
260 -0.850650808354f, 0.0f, 0.525731112119f,
261 0.850650808354f, 0.0f, -0.525731112119f,
262 -0.850650808354f, 0.0f, -0.525731112119f,
264 0.525731112119f, 0.850650808354f, 0.0f,
265 0.525731112119f, -0.850650808354f, 0.0f,
266 -0.525731112119f, 0.850650808354f, 0.0f,
267 -0.525731112119f, -0.850650808354f, 0.0f,
271 static GLubyte dodecahedron_vi[DODECAHEDRON_VERT_PER_OBJ] =
288 DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON);
291 /* -- Icosahedron -- */
292 #define ICOSAHEDRON_NUM_VERT 12
293 #define ICOSAHEDRON_NUM_FACES 20
294 #define ICOSAHEDRON_NUM_EDGE_PER_FACE 3
295 #define ICOSAHEDRON_VERT_PER_OBJ (ICOSAHEDRON_NUM_FACES*ICOSAHEDRON_NUM_EDGE_PER_FACE)
296 #define ICOSAHEDRON_VERT_ELEM_PER_OBJ (ICOSAHEDRON_VERT_PER_OBJ*3)
297 #define ICOSAHEDRON_VERT_PER_OBJ_TRI ICOSAHEDRON_VERT_PER_OBJ
298 /* Vertex Coordinates */
299 static GLfloat icosahedron_v[ICOSAHEDRON_NUM_VERT*3] =
302 0.447213595500f, 0.894427191000f, 0.0f,
303 0.447213595500f, 0.276393202252f, 0.850650808354f,
304 0.447213595500f, -0.723606797748f, 0.525731112119f,
305 0.447213595500f, -0.723606797748f, -0.525731112119f,
306 0.447213595500f, 0.276393202252f, -0.850650808354f,
307 -0.447213595500f, -0.894427191000f, 0.0f,
308 -0.447213595500f, -0.276393202252f, 0.850650808354f,
309 -0.447213595500f, 0.723606797748f, 0.525731112119f,
310 -0.447213595500f, 0.723606797748f, -0.525731112119f,
311 -0.447213595500f, -0.276393202252f, -0.850650808354f,
315 * 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] ) ;
316 * 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] ) ;
317 * 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] ) ;
319 static GLfloat icosahedron_n[ICOSAHEDRON_NUM_FACES*3] =
321 0.760845213037948f, 0.470228201835026f, 0.341640786498800f,
322 0.760845213036861f, -0.179611190632978f, 0.552786404500000f,
323 0.760845213033849f, -0.581234022404097f, 0.0f,
324 0.760845213036861f, -0.179611190632978f, -0.552786404500000f,
325 0.760845213037948f, 0.470228201835026f, -0.341640786498800f,
326 0.179611190628666f, 0.760845213037948f, 0.552786404498399f,
327 0.179611190634277f, -0.290617011204044f, 0.894427191000000f,
328 0.179611190633958f, -0.940456403667806f, 0.0f,
329 0.179611190634278f, -0.290617011204044f, -0.894427191000000f,
330 0.179611190628666f, 0.760845213037948f, -0.552786404498399f,
331 -0.179611190633958f, 0.940456403667806f, 0.0f,
332 -0.179611190634277f, 0.290617011204044f, 0.894427191000000f,
333 -0.179611190628666f, -0.760845213037948f, 0.552786404498399f,
334 -0.179611190628666f, -0.760845213037948f, -0.552786404498399f,
335 -0.179611190634277f, 0.290617011204044f, -0.894427191000000f,
336 -0.760845213036861f, 0.179611190632978f, -0.552786404500000f,
337 -0.760845213033849f, 0.581234022404097f, 0.0f,
338 -0.760845213036861f, 0.179611190632978f, 0.552786404500000f,
339 -0.760845213037948f, -0.470228201835026f, 0.341640786498800f,
340 -0.760845213037948f, -0.470228201835026f, -0.341640786498800f,
344 static GLubyte icosahedron_vi[ICOSAHEDRON_VERT_PER_OBJ] =
367 DECLARE_SHAPE_CACHE(icosahedron,Icosahedron,ICOSAHEDRON);
369 /* -- Octahedron -- */
370 #define OCTAHEDRON_NUM_VERT 6
371 #define OCTAHEDRON_NUM_FACES 8
372 #define OCTAHEDRON_NUM_EDGE_PER_FACE 3
373 #define OCTAHEDRON_VERT_PER_OBJ (OCTAHEDRON_NUM_FACES*OCTAHEDRON_NUM_EDGE_PER_FACE)
374 #define OCTAHEDRON_VERT_ELEM_PER_OBJ (OCTAHEDRON_VERT_PER_OBJ*3)
375 #define OCTAHEDRON_VERT_PER_OBJ_TRI OCTAHEDRON_VERT_PER_OBJ
377 /* Vertex Coordinates */
378 static GLfloat octahedron_v[OCTAHEDRON_NUM_VERT*3] =
389 static GLfloat octahedron_n[OCTAHEDRON_NUM_FACES*3] =
391 0.577350269189f, 0.577350269189f, 0.577350269189f, /* sqrt(1/3) */
392 0.577350269189f, 0.577350269189f,-0.577350269189f,
393 0.577350269189f,-0.577350269189f, 0.577350269189f,
394 0.577350269189f,-0.577350269189f,-0.577350269189f,
395 -0.577350269189f, 0.577350269189f, 0.577350269189f,
396 -0.577350269189f, 0.577350269189f,-0.577350269189f,
397 -0.577350269189f,-0.577350269189f, 0.577350269189f,
398 -0.577350269189f,-0.577350269189f,-0.577350269189f
403 static GLubyte octahedron_vi[OCTAHEDRON_VERT_PER_OBJ] =
414 DECLARE_SHAPE_CACHE(octahedron,Octahedron,OCTAHEDRON);
416 /* -- RhombicDodecahedron -- */
417 #define RHOMBICDODECAHEDRON_NUM_VERT 14
418 #define RHOMBICDODECAHEDRON_NUM_FACES 12
419 #define RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE 4
420 #define RHOMBICDODECAHEDRON_VERT_PER_OBJ (RHOMBICDODECAHEDRON_NUM_FACES*RHOMBICDODECAHEDRON_NUM_EDGE_PER_FACE)
421 #define RHOMBICDODECAHEDRON_VERT_ELEM_PER_OBJ (RHOMBICDODECAHEDRON_VERT_PER_OBJ*3)
422 #define RHOMBICDODECAHEDRON_VERT_PER_OBJ_TRI (RHOMBICDODECAHEDRON_VERT_PER_OBJ+RHOMBICDODECAHEDRON_NUM_FACES*2) /* 2 extra edges per face when drawing quads as triangles */
424 /* Vertex Coordinates */
425 static GLfloat rhombicdodecahedron_v[RHOMBICDODECAHEDRON_NUM_VERT*3] =
428 0.707106781187f, 0.0f, 0.5f,
429 0.0f, 0.707106781187f, 0.5f,
430 -0.707106781187f, 0.0f, 0.5f,
431 0.0f, -0.707106781187f, 0.5f,
432 0.707106781187f, 0.707106781187f, 0.0f,
433 -0.707106781187f, 0.707106781187f, 0.0f,
434 -0.707106781187f, -0.707106781187f, 0.0f,
435 0.707106781187f, -0.707106781187f, 0.0f,
436 0.707106781187f, 0.0f, -0.5f,
437 0.0f, 0.707106781187f, -0.5f,
438 -0.707106781187f, 0.0f, -0.5f,
439 0.0f, -0.707106781187f, -0.5f,
443 static GLfloat rhombicdodecahedron_n[RHOMBICDODECAHEDRON_NUM_FACES*3] =
445 0.353553390594f, 0.353553390594f, 0.5f,
446 -0.353553390594f, 0.353553390594f, 0.5f,
447 -0.353553390594f, -0.353553390594f, 0.5f,
448 0.353553390594f, -0.353553390594f, 0.5f,
453 0.353553390594f, 0.353553390594f, -0.5f,
454 -0.353553390594f, 0.353553390594f, -0.5f,
455 -0.353553390594f, -0.353553390594f, -0.5f,
456 0.353553390594f, -0.353553390594f, -0.5f
460 static GLubyte rhombicdodecahedron_vi[RHOMBICDODECAHEDRON_VERT_PER_OBJ] =
475 DECLARE_SHAPE_CACHE_DECOMPOSE_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON);
477 /* -- Tetrahedron -- */
478 /* Magic Numbers: r0 = ( 1, 0, 0 )
479 * r1 = ( -1/3, 2 sqrt(2) / 3, 0 )
480 * r2 = ( -1/3, - sqrt(2) / 3, sqrt(6) / 3 )
481 * r3 = ( -1/3, - sqrt(2) / 3, -sqrt(6) / 3 )
482 * |r0| = |r1| = |r2| = |r3| = 1
483 * Distance between any two points is 2 sqrt(6) / 3
485 * Normals: The unit normals are simply the negative of the coordinates of the point not on the surface.
487 #define TETRAHEDRON_NUM_VERT 4
488 #define TETRAHEDRON_NUM_FACES 4
489 #define TETRAHEDRON_NUM_EDGE_PER_FACE 3
490 #define TETRAHEDRON_VERT_PER_OBJ (TETRAHEDRON_NUM_FACES*TETRAHEDRON_NUM_EDGE_PER_FACE)
491 #define TETRAHEDRON_VERT_ELEM_PER_OBJ (TETRAHEDRON_VERT_PER_OBJ*3)
492 #define TETRAHEDRON_VERT_PER_OBJ_TRI TETRAHEDRON_VERT_PER_OBJ
494 /* Vertex Coordinates */
495 static GLfloat tetrahedron_v[TETRAHEDRON_NUM_VERT*3] =
498 -0.333333333333f, 0.942809041582f, 0.0f,
499 -0.333333333333f, -0.471404520791f, 0.816496580928f,
500 -0.333333333333f, -0.471404520791f, -0.816496580928f
503 static GLfloat tetrahedron_n[TETRAHEDRON_NUM_FACES*3] =
506 0.333333333333f, -0.942809041582f, 0.0f,
507 0.333333333333f, 0.471404520791f, -0.816496580928f,
508 0.333333333333f, 0.471404520791f, 0.816496580928f
512 static GLubyte tetrahedron_vi[TETRAHEDRON_VERT_PER_OBJ] =
519 DECLARE_SHAPE_CACHE(tetrahedron,Tetrahedron,TETRAHEDRON);
521 /* -- Sierpinski Sponge -- */
522 static unsigned int ipow (int x, unsigned int y)
524 return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2);
527 static void fghSierpinskiSpongeGenerate ( int numLevels, double offset[3], GLfloat scale, GLfloat* vertices, GLfloat* normals )
530 if ( numLevels == 0 )
532 for (i=0; i<TETRAHEDRON_NUM_FACES; i++)
535 int faceIdxVertIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE;
536 for (j=0; j<TETRAHEDRON_NUM_EDGE_PER_FACE; j++)
538 int outIdx = i*TETRAHEDRON_NUM_EDGE_PER_FACE*3+j*3;
539 int vertIdx = tetrahedron_vi[faceIdxVertIdx+j]*3;
541 vertices[outIdx ] = (GLfloat)offset[0] + scale * tetrahedron_v[vertIdx ];
542 vertices[outIdx+1] = (GLfloat)offset[1] + scale * tetrahedron_v[vertIdx+1];
543 vertices[outIdx+2] = (GLfloat)offset[2] + scale * tetrahedron_v[vertIdx+2];
545 normals [outIdx ] = tetrahedron_n[normIdx ];
546 normals [outIdx+1] = tetrahedron_n[normIdx+1];
547 normals [outIdx+2] = tetrahedron_n[normIdx+2];
551 else if ( numLevels > 0 )
553 double local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */
554 unsigned int stride = ipow(4,--numLevels)*TETRAHEDRON_VERT_ELEM_PER_OBJ;
556 for ( i = 0 ; i < TETRAHEDRON_NUM_FACES ; i++ )
559 local_offset[0] = offset[0] + scale * tetrahedron_v[idx ];
560 local_offset[1] = offset[1] + scale * tetrahedron_v[idx+1];
561 local_offset[2] = offset[2] + scale * tetrahedron_v[idx+2];
562 fghSierpinskiSpongeGenerate ( numLevels, local_offset, scale, vertices+i*stride, normals+i*stride );
567 /* -- Now the various shapes involving circles -- */
569 * Compute lookup table of cos and sin values forming a circle
570 * (or half circle if halfCircle==TRUE)
573 * It is the responsibility of the caller to free these tables
574 * The size of the table is (n+1) to form a connected loop
575 * The last entry is exactly the same as the first
576 * The sign of n can be flipped to get the reverse loop
578 static void fghCircleTable(GLfloat **sint, GLfloat **cost, const int n, const GLboolean halfCircle)
582 /* Table size, the sign of n flips the circle direction */
583 const int size = abs(n);
585 /* Determine the angle between samples */
586 const GLfloat angle = (halfCircle?1:2)*(GLfloat)M_PI/(GLfloat)( ( n == 0 ) ? 1 : n );
588 /* Allocate memory for n samples, plus duplicate of first entry at the end */
589 *sint = malloc(sizeof(GLfloat) * (size+1));
590 *cost = malloc(sizeof(GLfloat) * (size+1));
592 /* Bail out if memory allocation fails, fgError never returns */
593 if (!(*sint) || !(*cost))
597 fgError("Failed to allocate memory in fghCircleTable");
600 /* Compute cos and sin around the circle */
604 for (i=1; i<size; i++)
606 (*sint)[i] = sinf(angle*i);
607 (*cost)[i] = cosf(angle*i);
613 (*sint)[size] = 0.0f; /* sin PI */
614 (*cost)[size] = -1.0f; /* cos PI */
618 /* Last sample is duplicate of the first (sin or cos of 2 PI) */
619 (*sint)[size] = (*sint)[0];
620 (*cost)[size] = (*cost)[0];
625 /* -- INTERNAL DRAWING functions --------------------------------------- */
626 #define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\
627 static void fgh##nameICaps( GLboolean useWireMode )\
631 fgh##nameICaps##Generate();\
632 name##Cached = GL_TRUE;\
637 fghDrawGeometryWire (name##_verts,name##_norms,\
638 nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\
642 fghDrawGeometrySolid(name##_verts,name##_norms,vertIdxs,\
643 nameCaps##_VERT_PER_OBJ_TRI, nameCaps##_NUM_EDGE_PER_FACE);\
646 #define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL)
647 #define DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,name##_vertIdxs)
649 static void fghCube( GLfloat dSize, GLboolean useWireMode )
656 cubeCached = GL_TRUE;
661 /* Need to build new vertex list containing vertices for cube of different size */
664 vertices = malloc(CUBE_VERT_ELEM_PER_OBJ * sizeof(GLfloat));
666 /* Bail out if memory allocation fails, fgError never returns */
670 fgError("Failed to allocate memory in fghCube");
673 for (i=0; i<CUBE_VERT_ELEM_PER_OBJ; i++)
674 vertices[i] = dSize*cube_verts[i];
677 vertices = cube_verts;
680 fghDrawGeometryWire (vertices,cube_norms, CUBE_NUM_FACES,CUBE_NUM_EDGE_PER_FACE);
682 fghDrawGeometrySolid(vertices,cube_norms,cube_vertIdxs,CUBE_VERT_PER_OBJ_TRI, CUBE_NUM_EDGE_PER_FACE);
685 /* cleanup allocated memory */
689 DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(dodecahedron,Dodecahedron,DODECAHEDRON);
690 DECLARE_INTERNAL_DRAW(icosahedron,Icosahedron,ICOSAHEDRON);
691 DECLARE_INTERNAL_DRAW(octahedron,Octahedron,OCTAHEDRON);
692 DECLARE_INTERNAL_DRAW_DECOMPOSED_TO_TRIANGLE(rhombicdodecahedron,RhombicDodecahedron,RHOMBICDODECAHEDRON);
693 DECLARE_INTERNAL_DRAW(tetrahedron,Tetrahedron,TETRAHEDRON);
695 static void fghSierpinskiSponge ( int numLevels, double offset[3], GLfloat scale, GLboolean useWireMode )
699 GLsizei numTetr = numLevels<0? 0 : ipow(4,numLevels); /* No sponge for numLevels below 0 */
700 GLsizei numVert = numTetr*TETRAHEDRON_VERT_PER_OBJ;
701 GLsizei numFace = numTetr*TETRAHEDRON_NUM_FACES;
705 /* Allocate memory */
706 vertices = malloc(numVert*3 * sizeof(GLfloat));
707 normals = malloc(numVert*3 * sizeof(GLfloat));
708 /* Bail out if memory allocation fails, fgError never returns */
709 if (!vertices || !normals)
713 fgError("Failed to allocate memory in fghSierpinskiSponge");
716 /* Generate elements */
717 fghSierpinskiSpongeGenerate ( numLevels, offset, scale, vertices, normals );
719 /* Draw and cleanup */
721 fghDrawGeometryWire (vertices,normals, numFace,TETRAHEDRON_NUM_EDGE_PER_FACE);
723 fghDrawGeometrySolid(vertices,normals,NULL,numVert, TETRAHEDRON_NUM_EDGE_PER_FACE);
729 #endif /* GL_ES_VERSION_2_0 */
732 /* -- INTERFACE FUNCTIONS ---------------------------------------------- */
735 #ifndef EGL_VERSION_1_0
737 * Draws a solid sphere
739 void FGAPIENTRY glutSolidSphere(double radius, GLint slices, GLint stacks)
743 /* Adjust z and radius as stacks are drawn. */
744 GLfloat radf = (GLfloat)radius;
748 /* Pre-computed circle */
750 GLfloat *sint1,*cost1;
751 GLfloat *sint2,*cost2;
753 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );
755 fghCircleTable(&sint1,&cost1,-slices,FALSE);
756 fghCircleTable(&sint2,&cost2, stacks,TRUE);
758 /* The top stack is covered with a triangle fan */
761 z1 = cost2[(stacks>0)?1:0];
763 r1 = sint2[(stacks>0)?1:0];
765 glBegin(GL_TRIANGLE_FAN);
768 glVertex3f(0,0,radf);
770 for (j=slices; j>=0; j--)
772 glNormal3f(cost1[j]*r1, sint1[j]*r1, z1 );
773 glVertex3f(cost1[j]*r1*radf, sint1[j]*r1*radf, z1*radf);
778 /* Cover each stack with a quad strip, except the top and bottom stacks */
780 for( i=1; i<stacks-1; i++ )
782 z0 = z1; z1 = cost2[i+1];
783 r0 = r1; r1 = sint2[i+1];
785 glBegin(GL_QUAD_STRIP);
787 for(j=0; j<=slices; j++)
789 glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 );
790 glVertex3d(cost1[j]*r1*radf, sint1[j]*r1*radf, z1*radf);
791 glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
792 glVertex3d(cost1[j]*r0*radf, sint1[j]*r0*radf, z0*radf);
798 /* The bottom stack is covered with a triangle fan */
803 glBegin(GL_TRIANGLE_FAN);
806 glVertex3d(0,0,-radius);
808 for (j=0; j<=slices; j++)
810 glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
811 glVertex3d(cost1[j]*r0*radf, sint1[j]*r0*radf, z0*radf);
816 /* Release sin and cos tables */
825 * Draws a wire sphere
827 void FGAPIENTRY glutWireSphere(double radius, GLint slices, GLint stacks)
831 /* Adjust z and radius as stacks and slices are drawn. */
832 GLfloat radf = (GLfloat)radius;
836 /* Pre-computed circle */
838 GLfloat *sint1,*cost1;
839 GLfloat *sint2,*cost2;
841 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
843 fghCircleTable(&sint1,&cost1,-slices,FALSE);
844 fghCircleTable(&sint2,&cost2, stacks,TRUE);
846 /* Draw a line loop for each stack */
848 for (i=1; i<stacks; i++)
853 glBegin(GL_LINE_LOOP);
855 for(j=0; j<=slices; j++)
861 glVertex3f(x*r*radf,y*r*radf,z*radf);
867 /* Draw a line loop for each slice */
869 for (i=0; i<slices; i++)
871 glBegin(GL_LINE_STRIP);
873 for(j=0; j<=stacks; j++)
875 x = cost1[i]*sint2[j];
876 y = sint1[i]*sint2[j];
880 glVertex3f(x*radf,y*radf,z*radf);
886 /* Release sin and cos tables */
897 void FGAPIENTRY glutSolidCone( double base, double height, GLint slices, GLint stacks )
901 /* Step in z and radius as stacks are drawn. */
906 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
907 const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 );
909 /* Scaling factors for vertex normals */
911 const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base ));
912 const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base ));
914 /* Pre-computed circle */
918 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );
920 fghCircleTable(&sint,&cost,-slices,FALSE);
922 /* Cover the circular base with a triangle fan... */
930 glBegin(GL_TRIANGLE_FAN);
933 glVertex3f(0,0, z0 );
935 for (j=0; j<=slices; j++)
936 glVertex3f(cost[j]*r0, sint[j]*r0, z0);
940 /* Cover each stack with a quad strip, except the top stack */
942 for( i=0; i<stacks-1; i++ )
944 glBegin(GL_QUAD_STRIP);
946 for(j=0; j<=slices; j++)
948 glNormal3f(cost[j]*cosn, sint[j]*cosn, sinn);
949 glVertex3f(cost[j]*r0, sint[j]*r0, z0 );
950 glVertex3f(cost[j]*r1, sint[j]*r1, z1 );
953 z0 = z1; z1 += zStep;
954 r0 = r1; r1 -= rStep;
959 /* The top stack is covered with individual triangles */
961 glBegin(GL_TRIANGLES);
963 glNormal3f(cost[0]*sinn, sint[0]*sinn, cosn);
965 for (j=0; j<slices; j++)
967 glVertex3f(cost[j+0]*r0, sint[j+0]*r0, z0 );
968 glVertex3f(0, 0, (GLfloat)height);
969 glNormal3f(cost[j+1]*sinn, sint[j+1]*sinn, cosn );
970 glVertex3f(cost[j+1]*r0, sint[j+1]*r0, z0 );
975 /* Release sin and cos tables */
984 void FGAPIENTRY glutWireCone( double base, double height, GLint slices, GLint stacks)
988 /* Step in z and radius as stacks are drawn. */
991 GLfloat r = (GLfloat)base;
993 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
994 const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 );
996 /* Scaling factors for vertex normals */
998 const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base ));
999 const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base ));
1001 /* Pre-computed circle */
1003 GLfloat *sint,*cost;
1005 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" );
1007 fghCircleTable(&sint,&cost,-slices,FALSE);
1009 /* Draw the stacks... */
1011 for (i=0; i<stacks; i++)
1013 glBegin(GL_LINE_LOOP);
1015 for( j=0; j<slices; j++ )
1017 glNormal3f(cost[j]*sinn, sint[j]*sinn, cosn);
1018 glVertex3f(cost[j]*r, sint[j]*r, z );
1027 /* Draw the slices */
1033 for (j=0; j<slices; j++)
1035 glNormal3f(cost[j]*sinn, sint[j]*sinn, cosn );
1036 glVertex3f(cost[j]*r, sint[j]*r, 0 );
1037 glVertex3f(0, 0, (GLfloat)height);
1042 /* Release sin and cos tables */
1050 * Draws a solid cylinder
1052 void FGAPIENTRY glutSolidCylinder(double radius, double height, GLint slices, GLint stacks)
1056 /* Step in z and radius as stacks are drawn. */
1057 GLfloat radf = (GLfloat)radius;
1059 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
1061 /* Pre-computed circle */
1063 GLfloat *sint,*cost;
1065 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
1067 fghCircleTable(&sint,&cost,-slices,FALSE);
1069 /* Cover the base and top */
1071 glBegin(GL_TRIANGLE_FAN);
1072 glNormal3f(0, 0, -1 );
1073 glVertex3f(0, 0, 0 );
1074 for (j=0; j<=slices; j++)
1075 glVertex3f(cost[j]*radf, sint[j]*radf, 0);
1078 glBegin(GL_TRIANGLE_FAN);
1079 glNormal3f(0, 0, 1 );
1080 glVertex3f(0, 0, (GLfloat)height);
1081 for (j=slices; j>=0; j--)
1082 glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height);
1090 for (i=1; i<=stacks; i++)
1093 z1 = (GLfloat)height;
1095 glBegin(GL_QUAD_STRIP);
1096 for (j=0; j<=slices; j++ )
1098 glNormal3f(cost[j], sint[j], 0 );
1099 glVertex3f(cost[j]*radf, sint[j]*radf, z0 );
1100 glVertex3f(cost[j]*radf, sint[j]*radf, z1 );
1104 z0 = z1; z1 += zStep;
1107 /* Release sin and cos tables */
1114 * Draws a wire cylinder
1116 void FGAPIENTRY glutWireCylinder(double radius, double height, GLint slices, GLint stacks)
1120 /* Step in z and radius as stacks are drawn. */
1121 GLfloat radf = (GLfloat)radius;
1123 const GLfloat zStep = (GLfloat)height / ( ( stacks > 0 ) ? stacks : 1 );
1125 /* Pre-computed circle */
1127 GLfloat *sint,*cost;
1129 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
1131 fghCircleTable(&sint,&cost,-slices,FALSE);
1133 /* Draw the stacks... */
1135 for (i=0; i<=stacks; i++)
1138 z = (GLfloat)height;
1140 glBegin(GL_LINE_LOOP);
1142 for( j=0; j<slices; j++ )
1144 glNormal3f(cost[j], sint[j], 0);
1145 glVertex3f(cost[j]*radf, sint[j]*radf, z);
1153 /* Draw the slices */
1157 for (j=0; j<slices; j++)
1159 glNormal3f(cost[j], sint[j], 0 );
1160 glVertex3f(cost[j]*radf, sint[j]*radf, 0 );
1161 glVertex3f(cost[j]*radf, sint[j]*radf, (GLfloat)height);
1166 /* Release sin and cos tables */
1173 * Draws a wire torus
1175 void FGAPIENTRY glutWireTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
1177 GLfloat iradius = (float)dInnerRadius, oradius = (float)dOuterRadius;
1178 GLfloat phi, psi, dpsi, dphi;
1179 GLfloat *vertex, *normal;
1181 GLfloat spsi, cpsi, sphi, cphi ;
1183 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
1185 if ( nSides < 1 ) nSides = 1;
1186 if ( nRings < 1 ) nRings = 1;
1188 /* Allocate the vertices array */
1189 vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1190 normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1194 dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings) ;
1195 dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides) ;
1198 for( j=0; j<nRings; j++ )
1200 cpsi = cosf( psi ) ;
1201 spsi = sinf( psi ) ;
1204 for( i=0; i<nSides; i++ )
1206 int offset = 3 * ( j * nSides + i ) ;
1207 cphi = cosf( phi ) ;
1208 sphi = sinf( phi ) ;
1209 *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
1210 *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
1211 *(vertex + offset + 2) = sphi * iradius ;
1212 *(normal + offset + 0) = cpsi * cphi ;
1213 *(normal + offset + 1) = spsi * cphi ;
1214 *(normal + offset + 2) = sphi ;
1221 for( i=0; i<nSides; i++ )
1223 glBegin( GL_LINE_LOOP );
1225 for( j=0; j<nRings; j++ )
1227 int offset = 3 * ( j * nSides + i ) ;
1228 glNormal3fv( normal + offset );
1229 glVertex3fv( vertex + offset );
1235 for( j=0; j<nRings; j++ )
1237 glBegin(GL_LINE_LOOP);
1239 for( i=0; i<nSides; i++ )
1241 int offset = 3 * ( j * nSides + i ) ;
1242 glNormal3fv( normal + offset );
1243 glVertex3fv( vertex + offset );
1255 * Draws a solid torus
1257 void FGAPIENTRY glutSolidTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GLint nRings )
1259 GLfloat iradius = (float)dInnerRadius, oradius = (float)dOuterRadius;
1260 GLfloat phi, psi, dpsi, dphi;
1261 GLfloat *vertex, *normal;
1263 GLfloat spsi, cpsi, sphi, cphi ;
1265 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );
1267 if ( nSides < 1 ) nSides = 1;
1268 if ( nRings < 1 ) nRings = 1;
1270 /* Increment the number of sides and rings to allow for one more point than surface */
1274 /* Allocate the vertices array */
1275 vertex = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1276 normal = (GLfloat *)calloc( sizeof(GLfloat), 3 * nSides * nRings );
1280 dpsi = 2.0f * (GLfloat)M_PI / (GLfloat)(nRings - 1) ;
1281 dphi = -2.0f * (GLfloat)M_PI / (GLfloat)(nSides - 1) ;
1284 for( j=0; j<nRings; j++ )
1286 cpsi = cosf( psi ) ;
1287 spsi = sinf( psi ) ;
1290 for( i=0; i<nSides; i++ )
1292 int offset = 3 * ( j * nSides + i ) ;
1293 cphi = cosf( phi ) ;
1294 sphi = sinf( phi ) ;
1295 *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
1296 *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
1297 *(vertex + offset + 2) = sphi * iradius ;
1298 *(normal + offset + 0) = cpsi * cphi ;
1299 *(normal + offset + 1) = spsi * cphi ;
1300 *(normal + offset + 2) = sphi ;
1307 glBegin( GL_QUADS );
1308 for( i=0; i<nSides-1; i++ )
1310 for( j=0; j<nRings-1; j++ )
1312 int offset = 3 * ( j * nSides + i ) ;
1313 glNormal3fv( normal + offset );
1314 glVertex3fv( vertex + offset );
1315 glNormal3fv( normal + offset + 3 );
1316 glVertex3fv( vertex + offset + 3 );
1317 glNormal3fv( normal + offset + 3 * nSides + 3 );
1318 glVertex3fv( vertex + offset + 3 * nSides + 3 );
1319 glNormal3fv( normal + offset + 3 * nSides );
1320 glVertex3fv( vertex + offset + 3 * nSides );
1330 #endif /* EGL_VERSION_1_0 */
1334 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
1335 /* Macro to generate interface functions */
1336 #define DECLARE_SHAPE_INTERFACE(nameICaps)\
1337 void FGAPIENTRY glutWire##nameICaps( void )\
1339 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWire"#nameICaps );\
1340 fgh##nameICaps( TRUE );\
1342 void FGAPIENTRY glutSolid##nameICaps( void )\
1344 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolid"#nameICaps );\
1345 fgh##nameICaps( FALSE );\
1348 void FGAPIENTRY glutWireCube( double dSize )
1350 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
1351 fghCube( (GLfloat)dSize, TRUE );
1353 void FGAPIENTRY glutSolidCube( double dSize )
1355 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
1356 fghCube( (GLfloat)dSize, FALSE );
1359 DECLARE_SHAPE_INTERFACE(Dodecahedron);
1360 DECLARE_SHAPE_INTERFACE(Icosahedron);
1361 DECLARE_SHAPE_INTERFACE(Octahedron);
1362 DECLARE_SHAPE_INTERFACE(RhombicDodecahedron);
1364 void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, double offset[3], double scale )
1366 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" );
1367 fghSierpinskiSponge ( num_levels, offset, (GLfloat)scale, TRUE );
1369 void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, double offset[3], double scale )
1371 FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
1372 fghSierpinskiSponge ( num_levels, offset, (GLfloat)scale, FALSE );
1375 DECLARE_SHAPE_INTERFACE(Tetrahedron);
1378 /*** END OF FILE ***/