开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
freeglut_geometry.c
资源名称：Box2D_v2.1.2.zip　[点击查看]
上传用户：gb3593
上传日期：2022-01-07
资源大小：3028k
文件大小：40k
源码类别：

游戏引擎

开发平台：

Visual C++

freeglut_geometry.c：源码内容
  1. /*
  2.  * freeglut_geometry.c
  3.  *
  4.  * Freeglut geometry rendering methods.
  5.  *
  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
  9.  *
  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:
  16.  *
  17.  * The above copyright notice and this permission notice shall be included
  18.  * in all copies or substantial portions of the Software.
  19.  *
  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.
  26.  */
  28. #include <GL/freeglut.h>
  29. #include "freeglut_internal.h"
  31. /*
  32.  * TODO BEFORE THE STABLE RELEASE:
  33.  *
  34.  * Following functions have been contributed by Andreas Umbach.
  35.  *
  36.  *      glutWireCube()          -- looks OK
  37.  *      glutSolidCube()         -- OK
  38.  *
  39.  * Those functions have been implemented by John Fay.
  40.  *
  41.  *      glutWireTorus()         -- looks OK
  42.  *      glutSolidTorus()        -- looks OK
  43.  *      glutWireDodecahedron()  -- looks OK
  44.  *      glutSolidDodecahedron() -- looks OK
  45.  *      glutWireOctahedron()    -- looks OK
  46.  *      glutSolidOctahedron()   -- looks OK
  47.  *      glutWireTetrahedron()   -- looks OK
  48.  *      glutSolidTetrahedron()  -- looks OK
  49.  *      glutWireIcosahedron()   -- looks OK
  50.  *      glutSolidIcosahedron()  -- looks OK
  51.  *
  52.  *  The Following functions have been updated by Nigel Stewart, based
  53.  *  on FreeGLUT 2.0.0 implementations:
  54.  *
  55.  *      glutWireSphere()        -- looks OK
  56.  *      glutSolidSphere()       -- looks OK
  57.  *      glutWireCone()          -- looks OK
  58.  *      glutSolidCone()         -- looks OK
  59.  */
  62. /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
  64. /*
  65.  * Draws a wireframed cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
  66.  */
  67. void FGAPIENTRY glutWireCube( GLdouble dSize )
  68. {
  69.     double size = dSize * 0.5;
  71.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCube" );
  73. #   define V(a,b,c) glVertex3d( a size, b size, c size );
  74. #   define N(a,b,c) glNormal3d( a, b, c );
  76.     /* PWO: I dared to convert the code to use macros... */
  77.     glBegin( GL_LINE_LOOP ); N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); glEnd();
  78.     glBegin( GL_LINE_LOOP ); N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); glEnd();
  79.     glBegin( GL_LINE_LOOP ); N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); glEnd();
  80.     glBegin( GL_LINE_LOOP ); N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); glEnd();
  81.     glBegin( GL_LINE_LOOP ); N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); glEnd();
  82.     glBegin( GL_LINE_LOOP ); N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); glEnd();
  84. #   undef V
  85. #   undef N
  86. }
  88. /*
  89.  * Draws a solid cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
  90.  */
  91. void FGAPIENTRY glutSolidCube( GLdouble dSize )
  92. {
  93.     double size = dSize * 0.5;
  95.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCube" );
  97. #   define V(a,b,c) glVertex3d( a size, b size, c size );
  98. #   define N(a,b,c) glNormal3d( a, b, c );
  100.     /* PWO: Again, I dared to convert the code to use macros... */
  101.     glBegin( GL_QUADS );
  102.         N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+);
  103.         N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+);
  104.         N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+);
  105.         N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-);
  106.         N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+);
  107.         N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-);
  108.     glEnd();
  110. #   undef V
  111. #   undef N
  112. }
  114. /*
  115.  * Compute lookup table of cos and sin values forming a cirle
  116.  *
  117.  * Notes:
  118.  *    It is the responsibility of the caller to free these tables
  119.  *    The size of the table is (n+1) to form a connected loop
  120.  *    The last entry is exactly the same as the first
  121.  *    The sign of n can be flipped to get the reverse loop
  122.  */
  124. static void fghCircleTable(double **sint,double **cost,const int n)
  125. {
  126.     int i;
  128.     /* Table size, the sign of n flips the circle direction */
  130.     const int size = abs(n);
  132.     /* Determine the angle between samples */
  134.     const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n );
  136.     /* Allocate memory for n samples, plus duplicate of first entry at the end */
  138.     *sint = (double *) calloc(sizeof(double), size+1);
  139.     *cost = (double *) calloc(sizeof(double), size+1);
  141.     /* Bail out if memory allocation fails, fgError never returns */
  143.     if (!(*sint) || !(*cost))
  144.     {
  145.         free(*sint);
  146.         free(*cost);
  147.         fgError("Failed to allocate memory in fghCircleTable");
  148.     }
  150.     /* Compute cos and sin around the circle */
  152.     (*sint)[0] = 0.0;
  153.     (*cost)[0] = 1.0;
  155.     for (i=1; i<size; i++)
  156.     {
  157.         (*sint)[i] = sin(angle*i);
  158.         (*cost)[i] = cos(angle*i);
  159.     }
  161.     /* Last sample is duplicate of the first */
  163.     (*sint)[size] = (*sint)[0];
  164.     (*cost)[size] = (*cost)[0];
  165. }
  167. /*
  168.  * Draws a solid sphere
  169.  */
  170. void FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
  171. {
  172.     int i,j;
  174.     /* Adjust z and radius as stacks are drawn. */
  176.     double z0,z1;
  177.     double r0,r1;
  179.     /* Pre-computed circle */
  181.     double *sint1,*cost1;
  182.     double *sint2,*cost2;
  184.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );
  186.     fghCircleTable(&sint1,&cost1,-slices);
  187.     fghCircleTable(&sint2,&cost2,stacks*2);
  189.     /* The top stack is covered with a triangle fan */
  191.     z0 = 1.0;
  192.     z1 = cost2[(stacks>0)?1:0];
  193.     r0 = 0.0;
  194.     r1 = sint2[(stacks>0)?1:0];
  196.     glBegin(GL_TRIANGLE_FAN);
  198.         glNormal3d(0,0,1);
  199.         glVertex3d(0,0,radius);
  201.         for (j=slices; j>=0; j--)
  202.         {
  203.             glNormal3d(cost1[j]*r1,        sint1[j]*r1,        z1       );
  204.             glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);
  205.         }
  207.     glEnd();
  209.     /* Cover each stack with a quad strip, except the top and bottom stacks */
  211.     for( i=1; i<stacks-1; i++ )
  212.     {
  213.         z0 = z1; z1 = cost2[i+1];
  214.         r0 = r1; r1 = sint2[i+1];
  216.         glBegin(GL_QUAD_STRIP);
  218.             for(j=0; j<=slices; j++)
  219.             {
  220.                 glNormal3d(cost1[j]*r1,        sint1[j]*r1,        z1       );
  221.                 glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);
  222.                 glNormal3d(cost1[j]*r0,        sint1[j]*r0,        z0       );
  223.                 glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);
  224.             }
  226.         glEnd();
  227.     }
  229.     /* The bottom stack is covered with a triangle fan */
  231.     z0 = z1;
  232.     r0 = r1;
  234.     glBegin(GL_TRIANGLE_FAN);
  236.         glNormal3d(0,0,-1);
  237.         glVertex3d(0,0,-radius);
  239.         for (j=0; j<=slices; j++)
  240.         {
  241.             glNormal3d(cost1[j]*r0,        sint1[j]*r0,        z0       );
  242.             glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);
  243.         }
  245.     glEnd();
  247.     /* Release sin and cos tables */
  249.     free(sint1);
  250.     free(cost1);
  251.     free(sint2);
  252.     free(cost2);
  253. }
  255. /*
  256.  * Draws a wire sphere
  257.  */
  258. void FGAPIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
  259. {
  260.     int i,j;
  262.     /* Adjust z and radius as stacks and slices are drawn. */
  264.     double r;
  265.     double x,y,z;
  267.     /* Pre-computed circle */
  269.     double *sint1,*cost1;
  270.     double *sint2,*cost2;
  272.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
  274.     fghCircleTable(&sint1,&cost1,-slices  );
  275.     fghCircleTable(&sint2,&cost2, stacks*2);
  277.     /* Draw a line loop for each stack */
  279.     for (i=1; i<stacks; i++)
  280.     {
  281.         z = cost2[i];
  282.         r = sint2[i];
  284.         glBegin(GL_LINE_LOOP);
  286.             for(j=0; j<=slices; j++)
  287.             {
  288.                 x = cost1[j];
  289.                 y = sint1[j];
  291.                 glNormal3d(x,y,z);
  292.                 glVertex3d(x*r*radius,y*r*radius,z*radius);
  293.             }
  295.         glEnd();
  296.     }
  298.     /* Draw a line loop for each slice */
  300.     for (i=0; i<slices; i++)
  301.     {
  302.         glBegin(GL_LINE_STRIP);
  304.             for(j=0; j<=stacks; j++)
  305.             {
  306.                 x = cost1[i]*sint2[j];
  307.                 y = sint1[i]*sint2[j];
  308.                 z = cost2[j];
  310.                 glNormal3d(x,y,z);
  311.                 glVertex3d(x*radius,y*radius,z*radius);
  312.             }
  314.         glEnd();
  315.     }
  317.     /* Release sin and cos tables */
  319.     free(sint1);
  320.     free(cost1);
  321.     free(sint2);
  322.     free(cost2);
  323. }
  325. /*
  326.  * Draws a solid cone
  327.  */
  328. void FGAPIENTRY glutSolidCone( GLdouble base, GLdouble height, GLint slices, GLint stacks )
  329. {
  330.     int i,j;
  332.     /* Step in z and radius as stacks are drawn. */
  334.     double z0,z1;
  335.     double r0,r1;
  337.     const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
  338.     const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
  340.     /* Scaling factors for vertex normals */
  342.     const double cosn = ( height / sqrt ( height * height + base * base ));
  343.     const double sinn = ( base   / sqrt ( height * height + base * base ));
  345.     /* Pre-computed circle */
  347.     double *sint,*cost;
  349.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );
  351.     fghCircleTable(&sint,&cost,-slices);
  353.     /* Cover the circular base with a triangle fan... */
  355.     z0 = 0.0;
  356.     z1 = zStep;
  358.     r0 = base;
  359.     r1 = r0 - rStep;
  361.     glBegin(GL_TRIANGLE_FAN);
  363.         glNormal3d(0.0,0.0,-1.0);
  364.         glVertex3d(0.0,0.0, z0 );
  366.         for (j=0; j<=slices; j++)
  367.             glVertex3d(cost[j]*r0, sint[j]*r0, z0);
  369.     glEnd();
  371.     /* Cover each stack with a quad strip, except the top stack */
  373.     for( i=0; i<stacks-1; i++ )
  374.     {
  375.         glBegin(GL_QUAD_STRIP);
  377.             for(j=0; j<=slices; j++)
  378.             {
  379.                 glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn);
  380.                 glVertex3d(cost[j]*r0,   sint[j]*r0,   z0  );
  381.                 glVertex3d(cost[j]*r1,   sint[j]*r1,   z1  );
  382.             }
  384.             z0 = z1; z1 += zStep;
  385.             r0 = r1; r1 -= rStep;
  387.         glEnd();
  388.     }
  390.     /* The top stack is covered with individual triangles */
  392.     glBegin(GL_TRIANGLES);
  394.         glNormal3d(cost[0]*sinn, sint[0]*sinn, cosn);
  396.         for (j=0; j<slices; j++)
  397.         {
  398.             glVertex3d(cost[j+0]*r0,   sint[j+0]*r0,   z0    );
  399.             glVertex3d(0,              0,              height);
  400.             glNormal3d(cost[j+1]*sinn, sint[j+1]*sinn, cosn  );
  401.             glVertex3d(cost[j+1]*r0,   sint[j+1]*r0,   z0    );
  402.         }
  404.     glEnd();
  406.     /* Release sin and cos tables */
  408.     free(sint);
  409.     free(cost);
  410. }
  412. /*
  413.  * Draws a wire cone
  414.  */
  415. void FGAPIENTRY glutWireCone( GLdouble base, GLdouble height, GLint slices, GLint stacks)
  416. {
  417.     int i,j;
  419.     /* Step in z and radius as stacks are drawn. */
  421.     double z = 0.0;
  422.     double r = base;
  424.     const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
  425.     const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
  427.     /* Scaling factors for vertex normals */
  429.     const double cosn = ( height / sqrt ( height * height + base * base ));
  430.     const double sinn = ( base   / sqrt ( height * height + base * base ));
  432.     /* Pre-computed circle */
  434.     double *sint,*cost;
  436.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" );
  438.     fghCircleTable(&sint,&cost,-slices);
  440.     /* Draw the stacks... */
  442.     for (i=0; i<stacks; i++)
  443.     {
  444.         glBegin(GL_LINE_LOOP);
  446.             for( j=0; j<slices; j++ )
  447.             {
  448.                 glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn);
  449.                 glVertex3d(cost[j]*r,    sint[j]*r,    z   );
  450.             }
  452.         glEnd();
  454.         z += zStep;
  455.         r -= rStep;
  456.     }
  458.     /* Draw the slices */
  460.     r = base;
  462.     glBegin(GL_LINES);
  464.         for (j=0; j<slices; j++)
  465.         {
  466.             glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn  );
  467.             glVertex3d(cost[j]*r,    sint[j]*r,    0.0   );
  468.             glVertex3d(0.0,          0.0,          height);
  469.         }
  471.     glEnd();
  473.     /* Release sin and cos tables */
  475.     free(sint);
  476.     free(cost);
  477. }
  480. /*
  481.  * Draws a solid cylinder
  482.  */
  483. void FGAPIENTRY glutSolidCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks)
  484. {
  485.     int i,j;
  487.     /* Step in z and radius as stacks are drawn. */
  489.     double z0,z1;
  490.     const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
  492.     /* Pre-computed circle */
  494.     double *sint,*cost;
  496.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCylinder" );
  498.     fghCircleTable(&sint,&cost,-slices);
  500.     /* Cover the base and top */
  502.     glBegin(GL_TRIANGLE_FAN);
  503.         glNormal3d(0.0, 0.0, -1.0 );
  504.         glVertex3d(0.0, 0.0,  0.0 );
  505.         for (j=0; j<=slices; j++)
  506.           glVertex3d(cost[j]*radius, sint[j]*radius, 0.0);
  507.     glEnd();
  509.     glBegin(GL_TRIANGLE_FAN);
  510.         glNormal3d(0.0, 0.0, 1.0   );
  511.         glVertex3d(0.0, 0.0, height);
  512.         for (j=slices; j>=0; j--)
  513.           glVertex3d(cost[j]*radius, sint[j]*radius, height);
  514.     glEnd();
  516.     /* Do the stacks */
  518.     z0 = 0.0;
  519.     z1 = zStep;
  521.     for (i=1; i<=stacks; i++)
  522.     {
  523.         if (i==stacks)
  524.             z1 = height;
  526.         glBegin(GL_QUAD_STRIP);
  527.             for (j=0; j<=slices; j++ )
  528.             {
  529.                 glNormal3d(cost[j],        sint[j],        0.0 );
  530.                 glVertex3d(cost[j]*radius, sint[j]*radius, z0  );
  531.                 glVertex3d(cost[j]*radius, sint[j]*radius, z1  );
  532.             }
  533.         glEnd();
  535.         z0 = z1; z1 += zStep;
  536.     }
  538.     /* Release sin and cos tables */
  540.     free(sint);
  541.     free(cost);
  542. }
  544. /*
  545.  * Draws a wire cylinder
  546.  */
  547. void FGAPIENTRY glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks)
  548. {
  549.     int i,j;
  551.     /* Step in z and radius as stacks are drawn. */
  553.           double z = 0.0;
  554.     const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
  556.     /* Pre-computed circle */
  558.     double *sint,*cost;
  560.     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCylinder" );
  562.     fghCircleTable(&sint,&cost,-slices);
  564.     /* Draw the stacks... */
  566.     for (i=0; i<=stacks; i++)
  567.     {
  568.         if (i==stacks)
  569.             z = height;
  571.         glBegin(GL_LINE_LOOP);
  573.             for( j=0; j<slices; j++ )
  574.             {
  575.                 glNormal3d(cost[j],        sint[j],        0.0);
  576.                 glVertex3d(cost[j]*radius, sint[j]*radius, z  );
  577.             }
  579.         glEnd();
  581.         z += zStep;
  582.     }
  584.     /* Draw the slices */
  586.     glBegin(GL_LINES);
  588.         for (j=0; j<slices; j++)
  589.         {
  590.             glNormal3d(cost[j],        sint[j],        0.0   );
  591.             glVertex3d(cost[j]*radius, sint[j]*radius, 0.0   );
  592.             glVertex3d(cost[j]*radius, sint[j]*radius, height);
  593.         }
  595.     glEnd();
  597.     /* Release sin and cos tables */
  599.     free(sint);
  600.     free(cost);
  601. }
  603. /*
  604.  * Draws a wire torus
  605.  */
  606. void FGAPIENTRY glutWireTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings )
  607. {
  608.   double  iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
  609.   double *vertex, *normal;
  610.   int    i, j;
  611.   double spsi, cpsi, sphi, cphi ;
  613.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );
  615.   if ( nSides < 1 ) nSides = 1;
  616.   if ( nRings < 1 ) nRings = 1;
  618.   /* Allocate the vertices array */
  619.   vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );
  620.   normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );
  622.   glPushMatrix();
  624.   dpsi =  2.0 * M_PI / (double)nRings ;
  625.   dphi = -2.0 * M_PI / (double)nSides ;
  626.   psi  = 0.0;
  628.   for( j=0; j<nRings; j++ )
  629.   {
  630.     cpsi = cos ( psi ) ;
  631.     spsi = sin ( psi ) ;
  632.     phi = 0.0;
  634.     for( i=0; i<nSides; i++ )
  635.     {
  636.       int offset = 3 * ( j * nSides + i ) ;
  637.       cphi = cos ( phi ) ;
  638.       sphi = sin ( phi ) ;
  639.       *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
  640.       *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
  641.       *(vertex + offset + 2) =                    sphi * iradius  ;
  642.       *(normal + offset + 0) = cpsi * cphi ;
  643.       *(normal + offset + 1) = spsi * cphi ;
  644.       *(normal + offset + 2) =        sphi ;
  645.       phi += dphi;
  646.     }
  648.     psi += dpsi;
  649.   }
  651.   for( i=0; i<nSides; i++ )
  652.   {
  653.     glBegin( GL_LINE_LOOP );
  655.     for( j=0; j<nRings; j++ )
  656.     {
  657.       int offset = 3 * ( j * nSides + i ) ;
  658.       glNormal3dv( normal + offset );
  659.       glVertex3dv( vertex + offset );
  660.     }
  662.     glEnd();
  663.   }
  665.   for( j=0; j<nRings; j++ )
  666.   {
  667.     glBegin(GL_LINE_LOOP);
  669.     for( i=0; i<nSides; i++ )
  670.     {
  671.       int offset = 3 * ( j * nSides + i ) ;
  672.       glNormal3dv( normal + offset );
  673.       glVertex3dv( vertex + offset );
  674.     }
  676.     glEnd();
  677.   }
  679.   free ( vertex ) ;
  680.   free ( normal ) ;
  681.   glPopMatrix();
  682. }
  684. /*
  685.  * Draws a solid torus
  686.  */
  687. void FGAPIENTRY glutSolidTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings )
  688. {
  689.   double  iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
  690.   double *vertex, *normal;
  691.   int    i, j;
  692.   double spsi, cpsi, sphi, cphi ;
  694.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );
  696.   if ( nSides < 1 ) nSides = 1;
  697.   if ( nRings < 1 ) nRings = 1;
  699.   /* Increment the number of sides and rings to allow for one more point than surface */
  700.   nSides ++ ;
  701.   nRings ++ ;
  703.   /* Allocate the vertices array */
  704.   vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );
  705.   normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );
  707.   glPushMatrix();
  709.   dpsi =  2.0 * M_PI / (double)(nRings - 1) ;
  710.   dphi = -2.0 * M_PI / (double)(nSides - 1) ;
  711.   psi  = 0.0;
  713.   for( j=0; j<nRings; j++ )
  714.   {
  715.     cpsi = cos ( psi ) ;
  716.     spsi = sin ( psi ) ;
  717.     phi = 0.0;
  719.     for( i=0; i<nSides; i++ )
  720.     {
  721.       int offset = 3 * ( j * nSides + i ) ;
  722.       cphi = cos ( phi ) ;
  723.       sphi = sin ( phi ) ;
  724.       *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
  725.       *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
  726.       *(vertex + offset + 2) =                    sphi * iradius  ;
  727.       *(normal + offset + 0) = cpsi * cphi ;
  728.       *(normal + offset + 1) = spsi * cphi ;
  729.       *(normal + offset + 2) =        sphi ;
  730.       phi += dphi;
  731.     }
  733.     psi += dpsi;
  734.   }
  736.     glBegin( GL_QUADS );
  737.   for( i=0; i<nSides-1; i++ )
  738.   {
  739.     for( j=0; j<nRings-1; j++ )
  740.     {
  741.       int offset = 3 * ( j * nSides + i ) ;
  742.       glNormal3dv( normal + offset );
  743.       glVertex3dv( vertex + offset );
  744.       glNormal3dv( normal + offset + 3 );
  745.       glVertex3dv( vertex + offset + 3 );
  746.       glNormal3dv( normal + offset + 3 * nSides + 3 );
  747.       glVertex3dv( vertex + offset + 3 * nSides + 3 );
  748.       glNormal3dv( normal + offset + 3 * nSides );
  749.       glVertex3dv( vertex + offset + 3 * nSides );
  750.     }
  751.   }
  753.   glEnd();
  755.   free ( vertex ) ;
  756.   free ( normal ) ;
  757.   glPopMatrix();
  758. }
  760. /*
  761.  *
  762.  */
  763. void FGAPIENTRY glutWireDodecahedron( void )
  764. {
  765.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireDodecahedron" );
  767.   /* Magic Numbers:  It is possible to create a dodecahedron by attaching two pentagons to each face of
  768.    * of a cube.  The coordinates of the points are:
  769.    *   (+-x,0, z); (+-1, 1, 1); (0, z, x )
  770.    * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2  or
  771.    *       x = 0.61803398875 and z = 1.61803398875.
  772.    */
  773.   glBegin ( GL_LINE_LOOP ) ;
  774.   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 ) ;
  775.   glEnd () ;
  776.   glBegin ( GL_LINE_LOOP ) ;
  777.   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 ) ;
  778.   glEnd () ;
  779.   glBegin ( GL_LINE_LOOP ) ;
  780.   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 ) ;
  781.   glEnd () ;
  782.   glBegin ( GL_LINE_LOOP ) ;
  783.   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 ) ;
  784.   glEnd () ;
  786.   glBegin ( GL_LINE_LOOP ) ;
  787.   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 ) ;
  788.   glEnd () ;
  789.   glBegin ( GL_LINE_LOOP ) ;
  790.   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 ) ;
  791.   glEnd () ;
  792.   glBegin ( GL_LINE_LOOP ) ;
  793.   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 ) ;
  794.   glEnd () ;
  795.   glBegin ( GL_LINE_LOOP ) ;
  796.   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 ) ;
  797.   glEnd () ;
  799.   glBegin ( GL_LINE_LOOP ) ;
  800.   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 ) ;
  801.   glEnd () ;
  802.   glBegin ( GL_LINE_LOOP ) ;
  803.   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 ) ;
  804.   glEnd () ;
  805.   glBegin ( GL_LINE_LOOP ) ;
  806.   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 ) ;
  807.   glEnd () ;
  808.   glBegin ( GL_LINE_LOOP ) ;
  809.   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 ) ;
  810.   glEnd () ;
  811. }
  813. /*
  814.  *
  815.  */
  816. void FGAPIENTRY glutSolidDodecahedron( void )
  817. {
  818.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidDodecahedron" );
  820.   /* Magic Numbers:  It is possible to create a dodecahedron by attaching two pentagons to each face of
  821.    * of a cube.  The coordinates of the points are:
  822.    *   (+-x,0, z); (+-1, 1, 1); (0, z, x )
  823.    * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or
  824.    *       x = 0.61803398875 and z = 1.61803398875.
  825.    */
  826.   glBegin ( GL_POLYGON ) ;
  827.   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 ) ;
  828.   glEnd () ;
  829.   glBegin ( GL_POLYGON ) ;
  830.   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 ) ;
  831.   glEnd () ;
  832.   glBegin ( GL_POLYGON ) ;
  833.   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 ) ;
  834.   glEnd () ;
  835.   glBegin ( GL_POLYGON ) ;
  836.   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 ) ;
  837.   glEnd () ;
  839.   glBegin ( GL_POLYGON ) ;
  840.   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 ) ;
  841.   glEnd () ;
  842.   glBegin ( GL_POLYGON ) ;
  843.   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 ) ;
  844.   glEnd () ;
  845.   glBegin ( GL_POLYGON ) ;
  846.   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 ) ;
  847.   glEnd () ;
  848.   glBegin ( GL_POLYGON ) ;
  849.   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 ) ;
  850.   glEnd () ;
  852.   glBegin ( GL_POLYGON ) ;
  853.   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 ) ;
  854.   glEnd () ;
  855.   glBegin ( GL_POLYGON ) ;
  856.   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 ) ;
  857.   glEnd () ;
  858.   glBegin ( GL_POLYGON ) ;
  859.   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 ) ;
  860.   glEnd () ;
  861.   glBegin ( GL_POLYGON ) ;
  862.   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 ) ;
  863.   glEnd () ;
  864. }
  866. /*
  867.  *
  868.  */
  869. void FGAPIENTRY glutWireOctahedron( void )
  870. {
  871.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireOctahedron" );
  873. #define RADIUS    1.0f
  874.   glBegin( GL_LINE_LOOP );
  875.     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 );
  876.     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 );
  877.     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 );
  878.     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 );
  879.     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 );
  880.     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 );
  881.     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 );
  882.     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 );
  883.   glEnd();
  884. #undef RADIUS
  885. }
  887. /*
  888.  *
  889.  */
  890. void FGAPIENTRY glutSolidOctahedron( void )
  891. {
  892.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidOctahedron" );
  894. #define RADIUS    1.0f
  895.   glBegin( GL_TRIANGLES );
  896.     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 );
  897.     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 );
  898.     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 );
  899.     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 );
  900.     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 );
  901.     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 );
  902.     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 );
  903.     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 );
  904.   glEnd();
  905. #undef RADIUS
  906. }
  908. /* Magic Numbers:  r0 = ( 1, 0, 0 )
  909.  *                 r1 = ( -1/3, 2 sqrt(2) / 3, 0 )
  910.  *                 r2 = ( -1/3, -sqrt(2) / 3, sqrt(6) / 3 )
  911.  *                 r3 = ( -1/3, -sqrt(2) / 3, -sqrt(6) / 3 )
  912.  * |r0| = |r1| = |r2| = |r3| = 1
  913.  * Distance between any two points is 2 sqrt(6) / 3
  914.  *
  915.  * Normals:  The unit normals are simply the negative of the coordinates of the point not on the surface.
  916.  */
  918. #define NUM_TETR_FACES     4
  920. static GLdouble tet_r[4][3] = { {             1.0,             0.0,             0.0 },
  921.                                 { -0.333333333333,  0.942809041582,             0.0 },
  922.                                 { -0.333333333333, -0.471404520791,  0.816496580928 },
  923.                                 { -0.333333333333, -0.471404520791, -0.816496580928 } } ;
  925. static GLint tet_i[4][3] =  /* Vertex indices */
  926. {
  927.   { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 }
  928. } ;
  930. /*
  931.  *
  932.  */
  933. void FGAPIENTRY glutWireTetrahedron( void )
  934. {
  935.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTetrahedron" );
  937.   glBegin( GL_LINE_LOOP ) ;
  938.     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] ) ;
  939.     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] ) ;
  940.     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] ) ;
  941.     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] ) ;
  942.   glEnd() ;
  943. }
  945. /*
  946.  *
  947.  */
  948. void FGAPIENTRY glutSolidTetrahedron( void )
  949. {
  950.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTetrahedron" );
  952.   glBegin( GL_TRIANGLES ) ;
  953.     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] ) ;
  954.     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] ) ;
  955.     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] ) ;
  956.     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] ) ;
  957.   glEnd() ;
  958. }
  960. /*
  961.  *
  962.  */
  963. static double icos_r[12][3] = {
  964.     {  1.0,             0.0,             0.0            },
  965.     {  0.447213595500,  0.894427191000,  0.0            },
  966.     {  0.447213595500,  0.276393202252,  0.850650808354 },
  967.     {  0.447213595500, -0.723606797748,  0.525731112119 },
  968.     {  0.447213595500, -0.723606797748, -0.525731112119 },
  969.     {  0.447213595500,  0.276393202252, -0.850650808354 },
  970.     { -0.447213595500, -0.894427191000,  0.0 },
  971.     { -0.447213595500, -0.276393202252,  0.850650808354 },
  972.     { -0.447213595500,  0.723606797748,  0.525731112119 },
  973.     { -0.447213595500,  0.723606797748, -0.525731112119 },
  974.     { -0.447213595500, -0.276393202252, -0.850650808354 },
  975.     { -1.0,             0.0,             0.0            }
  976. };
  978. static int icos_v [20][3] = {
  979.     {  0,  1,  2 },
  980.     {  0,  2,  3 },
  981.     {  0,  3,  4 },
  982.     {  0,  4,  5 },
  983.     {  0,  5,  1 },
  984.     {  1,  8,  2 },
  985.     {  2,  7,  3 },
  986.     {  3,  6,  4 },
  987.     {  4, 10,  5 },
  988.     {  5,  9,  1 },
  989.     {  1,  9,  8 },
  990.     {  2,  8,  7 },
  991.     {  3,  7,  6 },
  992.     {  4,  6, 10 },
  993.     {  5, 10,  9 },
  994.     { 11,  9, 10 },
  995.     { 11,  8,  9 },
  996.     { 11,  7,  8 },
  997.     { 11,  6,  7 },
  998.     { 11, 10,  6 }
  999. };
  1001. void FGAPIENTRY glutWireIcosahedron( void )
  1002. {
  1003.   int i ;
  1005.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireIcosahedron" );
  1007.   for ( i = 0; i < 20; i++ )
  1008.   {
  1009.     double normal[3] ;
  1010.     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] ) ;
  1011.     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] ) ;
  1012.     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] ) ;
  1013.     glBegin ( GL_LINE_LOOP ) ;
  1014.       glNormal3dv ( normal ) ;
  1015.       glVertex3dv ( icos_r[icos_v[i][0]] ) ;
  1016.       glVertex3dv ( icos_r[icos_v[i][1]] ) ;
  1017.       glVertex3dv ( icos_r[icos_v[i][2]] ) ;
  1018.     glEnd () ;
  1019.   }
  1020. }
  1022. /*
  1023.  *
  1024.  */
  1025. void FGAPIENTRY glutSolidIcosahedron( void )
  1026. {
  1027.   int i ;
  1029.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidIcosahedron" );
  1031.   glBegin ( GL_TRIANGLES ) ;
  1032.   for ( i = 0; i < 20; i++ )
  1033.   {
  1034.     double normal[3] ;
  1035.     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] ) ;
  1036.     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] ) ;
  1037.     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] ) ;
  1038.       glNormal3dv ( normal ) ;
  1039.       glVertex3dv ( icos_r[icos_v[i][0]] ) ;
  1040.       glVertex3dv ( icos_r[icos_v[i][1]] ) ;
  1041.       glVertex3dv ( icos_r[icos_v[i][2]] ) ;
  1042.   }
  1044.   glEnd () ;
  1045. }
  1047. /*
  1048.  *
  1049.  */
  1050. static double rdod_r[14][3] = {
  1051.     {  0.0,             0.0,             1.0 },
  1052.     {  0.707106781187,  0.000000000000,  0.5 },
  1053.     {  0.000000000000,  0.707106781187,  0.5 },
  1054.     { -0.707106781187,  0.000000000000,  0.5 },
  1055.     {  0.000000000000, -0.707106781187,  0.5 },
  1056.     {  0.707106781187,  0.707106781187,  0.0 },
  1057.     { -0.707106781187,  0.707106781187,  0.0 },
  1058.     { -0.707106781187, -0.707106781187,  0.0 },
  1059.     {  0.707106781187, -0.707106781187,  0.0 },
  1060.     {  0.707106781187,  0.000000000000, -0.5 },
  1061.     {  0.000000000000,  0.707106781187, -0.5 },
  1062.     { -0.707106781187,  0.000000000000, -0.5 },
  1063.     {  0.000000000000, -0.707106781187, -0.5 },
  1064.     {  0.0,             0.0,            -1.0 }
  1065. } ;
  1067. static int rdod_v [12][4] = {
  1068.     { 0,  1,  5,  2 },
  1069.     { 0,  2,  6,  3 },
  1070.     { 0,  3,  7,  4 },
  1071.     { 0,  4,  8,  1 },
  1072.     { 5, 10,  6,  2 },
  1073.     { 6, 11,  7,  3 },
  1074.     { 7, 12,  8,  4 },
  1075.     { 8,  9,  5,  1 },
  1076.     { 5,  9, 13, 10 },
  1077.     { 6, 10, 13, 11 },
  1078.     { 7, 11, 13, 12 },
  1079.     { 8, 12, 13,  9 }
  1080. };
  1082. static double rdod_n[12][3] = {
  1083.     {  0.353553390594,  0.353553390594,  0.5 },
  1084.     { -0.353553390594,  0.353553390594,  0.5 },
  1085.     { -0.353553390594, -0.353553390594,  0.5 },
  1086.     {  0.353553390594, -0.353553390594,  0.5 },
  1087.     {  0.000000000000,  1.000000000000,  0.0 },
  1088.     { -1.000000000000,  0.000000000000,  0.0 },
  1089.     {  0.000000000000, -1.000000000000,  0.0 },
  1090.     {  1.000000000000,  0.000000000000,  0.0 },
  1091.     {  0.353553390594,  0.353553390594, -0.5 },
  1092.     { -0.353553390594,  0.353553390594, -0.5 },
  1093.     { -0.353553390594, -0.353553390594, -0.5 },
  1094.     {  0.353553390594, -0.353553390594, -0.5 }
  1095. };
  1097. void FGAPIENTRY glutWireRhombicDodecahedron( void )
  1098. {
  1099.   int i ;
  1101.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireRhombicDodecahedron" );
  1103.   for ( i = 0; i < 12; i++ )
  1104.   {
  1105.     glBegin ( GL_LINE_LOOP ) ;
  1106.       glNormal3dv ( rdod_n[i] ) ;
  1107.       glVertex3dv ( rdod_r[rdod_v[i][0]] ) ;
  1108.       glVertex3dv ( rdod_r[rdod_v[i][1]] ) ;
  1109.       glVertex3dv ( rdod_r[rdod_v[i][2]] ) ;
  1110.       glVertex3dv ( rdod_r[rdod_v[i][3]] ) ;
  1111.     glEnd () ;
  1112.   }
  1113. }
  1115. /*
  1116.  *
  1117.  */
  1118. void FGAPIENTRY glutSolidRhombicDodecahedron( void )
  1119. {
  1120.   int i ;
  1122.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidRhombicDodecahedron" );
  1124.   glBegin ( GL_QUADS ) ;
  1125.   for ( i = 0; i < 12; i++ )
  1126.   {
  1127.       glNormal3dv ( rdod_n[i] ) ;
  1128.       glVertex3dv ( rdod_r[rdod_v[i][0]] ) ;
  1129.       glVertex3dv ( rdod_r[rdod_v[i][1]] ) ;
  1130.       glVertex3dv ( rdod_r[rdod_v[i][2]] ) ;
  1131.       glVertex3dv ( rdod_r[rdod_v[i][3]] ) ;
  1132.   }
  1134.   glEnd () ;
  1135. }
  1137. void FGAPIENTRY glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
  1138. {
  1139.   int i, j ;
  1141.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSierpinskiSponge" );
  1143.   if ( num_levels == 0 )
  1144.   {
  1146.     for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
  1147.     {
  1148.       glBegin ( GL_LINE_LOOP ) ;
  1149.       glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ;
  1150.       for ( j = 0; j < 3; j++ )
  1151.       {
  1152.         double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ;
  1153.         double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ;
  1154.         double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ;
  1155.         glVertex3d ( x, y, z ) ;
  1156.       }
  1158.       glEnd () ;
  1159.     }
  1160.   }
  1161.   else if ( num_levels > 0 )
  1162.   {
  1163.     GLdouble local_offset[3] ;  /* Use a local variable to avoid buildup of roundoff errors */
  1164.     num_levels -- ;
  1165.     scale /= 2.0 ;
  1166.     for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
  1167.     {
  1168.       local_offset[0] = offset[0] + scale * tet_r[i][0] ;
  1169.       local_offset[1] = offset[1] + scale * tet_r[i][1] ;
  1170.       local_offset[2] = offset[2] + scale * tet_r[i][2] ;
  1171.       glutWireSierpinskiSponge ( num_levels, local_offset, scale ) ;
  1172.     }
  1173.   }
  1174. }
  1176. void FGAPIENTRY glutSolidSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
  1177. {
  1178.   int i, j ;
  1180.   FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSierpinskiSponge" );
  1182.   if ( num_levels == 0 )
  1183.   {
  1184.     glBegin ( GL_TRIANGLES ) ;
  1186.     for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
  1187.     {
  1188.       glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ;
  1189.       for ( j = 0; j < 3; j++ )
  1190.       {
  1191.         double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ;
  1192.         double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ;
  1193.         double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ;
  1194.         glVertex3d ( x, y, z ) ;
  1195.       }
  1196.     }
  1198.     glEnd () ;
  1199.   }
  1200.   else if ( num_levels > 0 )
  1201.   {
  1202.     GLdouble local_offset[3] ;  /* Use a local variable to avoid buildup of roundoff errors */
  1203.     num_levels -- ;
  1204.     scale /= 2.0 ;
  1205.     for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
  1206.     {
  1207.       local_offset[0] = offset[0] + scale * tet_r[i][0] ;
  1208.       local_offset[1] = offset[1] + scale * tet_r[i][1] ;
  1209.       local_offset[2] = offset[2] + scale * tet_r[i][2] ;
  1210.       glutSolidSierpinskiSponge ( num_levels, local_offset, scale ) ;
  1211.     }
  1212.   }
  1213. }
  1215. /*** END OF FILE ***/