git.mutantstargoat.com Git - freeglut/blob - progs/demos/shapes/shapes.c

   1 /*! \file    shapes.c
   2     \ingroup demos
   3
   4     This program is a test harness for the various shapes
   5     in OpenGLUT.  It may also be useful to see which
   6     parameters control what behavior in the OpenGLUT
   7     objects.
   8
   9     Spinning wireframe and solid-shaded shapes are
  10     displayed.  Some parameters can be adjusted.
  11
  12    Keys:
  13       -    <tt>Esc &nbsp;</tt> Quit
  14       -    <tt>q Q &nbsp;</tt> Quit
  15       -    <tt>i I &nbsp;</tt> Show info
  16       -    <tt>p P &nbsp;</tt> Toggle perspective or orthographic projection
  17       -    <tt>r R &nbsp;</tt> Toggle fixed or animated rotation around model X-axis
  18       -    <tt>s S &nbsp;</tt> Toggle toggle fixed function or shader render path
  19       -    <tt>n N &nbsp;</tt> Toggle visualization of object's normal vectors
  20       -    <tt>= + &nbsp;</tt> Increase \a slices
  21       -    <tt>- _ &nbsp;</tt> Decreate \a slices
  22       -    <tt>, < &nbsp;</tt> Decreate \a stacks
  23       -    <tt>. > &nbsp;</tt> Increase \a stacks
  24       -    <tt>9 ( &nbsp;</tt> Decreate \a depth  (Sierpinski Sponge)
  25       -    <tt>0 ) &nbsp;</tt> Increase \a depth  (Sierpinski Sponge)
  26       -    <tt>up&nbsp; &nbsp;</tt> Increase "outer radius"
  27       -    <tt>down&nbsp;</tt> Decrease "outer radius"
  28       -    <tt>left&nbsp;</tt> Decrease "inner radius"
  29       -    <tt>right</tt> Increase "inner radius"
  30       -    <tt>PgUp&nbsp;</tt> Next shape-drawing function
  31       -    <tt>PgDn&nbsp;</tt> Prev shape-drawing function
  32
  33     \author  Written by Nigel Stewart November 2003
  34
  35     \author  Portions Copyright (C) 2004, the OpenGLUT project contributors. <br>
  36              OpenGLUT branched from freeglut in February, 2004.
  37
  38     \image   html openglut_shapes.png OpenGLUT Geometric Shapes Demonstration
  39     \include demos/shapes/shapes.c
  40 */
  41
  42 #include <GL/freeglut.h>
  43
  44 #include <stdarg.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <stddef.h>
  48
  49 #include "glmatrix.h"
  50
  51 #ifdef _MSC_VER
  52 /* DUMP MEMORY LEAKS */
  53 #include <crtdbg.h>
  54 #endif
  55
  56 /* report GL errors, if any, to stderr */
  57 void checkError(const char *functionName)
  58 {
  59     GLenum error;
  60     while (( error = glGetError() ) != GL_NO_ERROR) {
  61         fprintf (stderr, "GL error 0x%X detected in %s\n", error, functionName);
  62     }
  63 }
  64
  65 /*
  66  * OpenGL 2+ shader mode needs some function and macro definitions,
  67  * avoiding a dependency on additional libraries like GLEW or the
  68  * GL/glext.h header
  69  */
  70 #ifndef GL_FRAGMENT_SHADER
  71 #define GL_FRAGMENT_SHADER 0x8B30
  72 #endif
  73
  74 #ifndef GL_VERTEX_SHADER
  75 #define GL_VERTEX_SHADER 0x8B31
  76 #endif
  77
  78 #ifndef GL_COMPILE_STATUS
  79 #define GL_COMPILE_STATUS 0x8B81
  80 #endif
  81
  82 #ifndef GL_LINK_STATUS
  83 #define GL_LINK_STATUS 0x8B82
  84 #endif
  85
  86 #ifndef GL_INFO_LOG_LENGTH
  87 #define GL_INFO_LOG_LENGTH 0x8B84
  88 #endif
  89
  90 typedef ptrdiff_t ourGLsizeiptr;
  91 typedef char ourGLchar;
  92
  93 #ifndef APIENTRY
  94 #define APIENTRY
  95 #endif
  96
  97 #ifndef GL_VERSION_2_0
  98 typedef GLuint (APIENTRY *PFNGLCREATESHADERPROC) (GLenum type);
  99 typedef void (APIENTRY *PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const ourGLchar **string, const GLint *length);
 100 typedef void (APIENTRY *PFNGLCOMPILESHADERPROC) (GLuint shader);
 101 typedef GLuint (APIENTRY *PFNGLCREATEPROGRAMPROC) (void);
 102 typedef void (APIENTRY *PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
 103 typedef void (APIENTRY *PFNGLLINKPROGRAMPROC) (GLuint program);
 104 typedef void (APIENTRY *PFNGLUSEPROGRAMPROC) (GLuint program);
 105 typedef void (APIENTRY *PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
 106 typedef void (APIENTRY *PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, ourGLchar *infoLog);
 107 typedef void (APIENTRY *PFNGLGETPROGRAMIVPROC) (GLenum target, GLenum pname, GLint *params);
 108 typedef void (APIENTRY *PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, ourGLchar *infoLog);
 109 typedef GLint (APIENTRY *PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const ourGLchar *name);
 110 typedef GLint (APIENTRY *PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const ourGLchar *name);
 111 typedef void (APIENTRY *PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 112 typedef void (APIENTRY *PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 113 #endif
 114
 115 PFNGLCREATESHADERPROC gl_CreateShader;
 116 PFNGLSHADERSOURCEPROC gl_ShaderSource;
 117 PFNGLCOMPILESHADERPROC gl_CompileShader;
 118 PFNGLCREATEPROGRAMPROC gl_CreateProgram;
 119 PFNGLATTACHSHADERPROC gl_AttachShader;
 120 PFNGLLINKPROGRAMPROC gl_LinkProgram;
 121 PFNGLUSEPROGRAMPROC gl_UseProgram;
 122 PFNGLGETSHADERIVPROC gl_GetShaderiv;
 123 PFNGLGETSHADERINFOLOGPROC gl_GetShaderInfoLog;
 124 PFNGLGETPROGRAMIVPROC gl_GetProgramiv;
 125 PFNGLGETPROGRAMINFOLOGPROC gl_GetProgramInfoLog;
 126 PFNGLGETATTRIBLOCATIONPROC gl_GetAttribLocation;
 127 PFNGLGETUNIFORMLOCATIONPROC gl_GetUniformLocation;
 128 PFNGLUNIFORMMATRIX4FVPROC gl_UniformMatrix4fv;
 129 PFNGLUNIFORMMATRIX3FVPROC gl_UniformMatrix3fv;
 130
 131 void initExtensionEntries(void)
 132 {
 133     gl_CreateShader = (PFNGLCREATESHADERPROC) glutGetProcAddress ("glCreateShader");
 134     gl_ShaderSource = (PFNGLSHADERSOURCEPROC) glutGetProcAddress ("glShaderSource");
 135     gl_CompileShader = (PFNGLCOMPILESHADERPROC) glutGetProcAddress ("glCompileShader");
 136     gl_CreateProgram = (PFNGLCREATEPROGRAMPROC) glutGetProcAddress ("glCreateProgram");
 137     gl_AttachShader = (PFNGLATTACHSHADERPROC) glutGetProcAddress ("glAttachShader");
 138     gl_LinkProgram = (PFNGLLINKPROGRAMPROC) glutGetProcAddress ("glLinkProgram");
 139     gl_UseProgram = (PFNGLUSEPROGRAMPROC) glutGetProcAddress ("glUseProgram");
 140     gl_GetShaderiv = (PFNGLGETSHADERIVPROC) glutGetProcAddress ("glGetShaderiv");
 141     gl_GetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) glutGetProcAddress ("glGetShaderInfoLog");
 142     gl_GetProgramiv = (PFNGLGETPROGRAMIVPROC) glutGetProcAddress ("glGetProgramiv");
 143     gl_GetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) glutGetProcAddress ("glGetProgramInfoLog");
 144     gl_GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) glutGetProcAddress ("glGetAttribLocation");
 145     gl_GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) glutGetProcAddress ("glGetUniformLocation");
 146     gl_UniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) glutGetProcAddress ("glUniformMatrix4fv");
 147     gl_UniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) glutGetProcAddress ("glUniformMatrix3fv");
 148     if (!gl_CreateShader || !gl_ShaderSource || !gl_CompileShader || !gl_CreateProgram || !gl_AttachShader || !gl_LinkProgram || !gl_UseProgram || !gl_GetShaderiv || !gl_GetShaderInfoLog || !gl_GetProgramiv || !gl_GetProgramInfoLog || !gl_GetAttribLocation || !gl_GetUniformLocation || !gl_UniformMatrix4fv || !gl_UniformMatrix3fv)
 149     {
 150         fprintf (stderr, "glCreateShader, glShaderSource, glCompileShader, glCreateProgram, glAttachShader, glLinkProgram, glUseProgram, glGetShaderiv, glGetShaderInfoLog, glGetProgramiv, glGetProgramInfoLog, glGetAttribLocation, glGetUniformLocation, glUniformMatrix4fv or gl_UniformMatrix3fv not found");
 151         exit(1);
 152     }
 153 }
 154
 155 const ourGLchar *vertexShaderSource[] = {
 156     "/**",
 157     " * From the OpenGL Programming wikibook: http://en.wikibooks.org/wiki/GLSL_Programming/GLUT/Smooth_Specular_Highlights",
 158     " * This file is in the public domain.",
 159     " * Contributors: Sylvain Beucler",
 160     " */",
 161     "attribute vec3 fg_coord;",
 162     "attribute vec3 fg_normal;",
 163     "varying vec4 position;  /* position of the vertex (and fragment) in world space */",
 164     "varying vec3 varyingNormalDirection;  /* surface normal vector in world space */",
 165     "uniform mat4 m, p;      /* don't need v, as always identity in our demo */",
 166     "uniform mat3 m_3x3_inv_transp;",
 167     " ",
 168     "void main()",
 169     "{",
 170     "  vec4 fg_coord4 = vec4(fg_coord, 1.0);",
 171     "  position = m * fg_coord4;",
 172     "  varyingNormalDirection = normalize(m_3x3_inv_transp * fg_normal);",
 173     " ",
 174     "  mat4 mvp = p*m;   /* normally p*v*m */",
 175     "  gl_Position = mvp * fg_coord4;",
 176     "}"
 177 };
 178
 179 const ourGLchar *fragmentShaderSource[] = {
 180     "/**",
 181     " * From the OpenGL Programming wikibook: http://en.wikibooks.org/wiki/GLSL_Programming/GLUT/Smooth_Specular_Highlights",
 182     " * This file is in the public domain.",
 183     " * Contributors: Martin Kraus, Sylvain Beucler",
 184     " */",
 185     "varying vec4 position;  /* position of the vertex (and fragment) in world space */",
 186     "varying vec3 varyingNormalDirection;  /* surface normal vector in world space */",
 187     "/* uniform mat4 v_inv;   // in this demo, the view matrix is always an identity matrix */",
 188     " ",
 189     "struct lightSource",
 190     "{",
 191     "  vec4 position;",
 192     "  vec4 diffuse;",
 193     "  vec4 specular;",
 194     "  float constantAttenuation, linearAttenuation, quadraticAttenuation;",
 195     "  float spotCutoff, spotExponent;",
 196     "  vec3 spotDirection;",
 197     "};",
 198     "lightSource light0 = lightSource(",
 199     "  vec4(2.0, 5.0, 5.0, 0.0),",
 200     "  vec4(1.0, 1.0, 1.0, 1.0),",
 201     "  vec4(1.0, 1.0, 1.0, 1.0),",
 202     "    0.0, 1.0, 0.0,",
 203     "  180.0, 0.0,",
 204     "  vec3(0.0, 0.0, 0.0)",
 205     ");",
 206     "vec4 scene_ambient = vec4(0.2, 0.2, 0.2, 1.0);",
 207     " ",
 208     "struct material",
 209     "{",
 210     "  vec4 ambient;",
 211     "  vec4 diffuse;",
 212     "  vec4 specular;",
 213     "  float shininess;",
 214     "};",
 215     "material frontMaterial = material(",
 216     "  vec4(1.0, 0.0, 0.0, 1.0),",
 217     "  vec4(1.0, 0.0, 0.0, 1.0),",
 218     "  vec4(1.0, 1.0, 1.0, 1.0),",
 219     "  100.0",
 220     ");",
 221     " ",
 222     "void main()",
 223     "{",
 224     "  vec3 normalDirection = normalize(varyingNormalDirection);",
 225     "  /* vec3 viewDirection = normalize(vec3(v_inv * vec4(0.0, 0.0, 0.0, 1.0) - position)); */",
 226     "  vec3 viewDirection = normalize(vec3(vec4(0.0, 0.0, 0.0, 1.0) - position));    /* in this demo, the view matrix is always an identity matrix */",
 227     "  vec3 lightDirection;",
 228     "  float attenuation;",
 229     " ",
 230     "  if (0.0 == light0.position.w) /* directional light? */",
 231     "    {",
 232     "      attenuation = 1.0; /* no attenuation */",
 233     "      lightDirection = normalize(vec3(light0.position));",
 234     "    } ",
 235     "  else /* point light or spotlight (or other kind of light) */",
 236     "    {",
 237     "      vec3 positionToLightSource = vec3(light0.position - position);",
 238     "      float distance = length(positionToLightSource);",
 239     "      lightDirection = normalize(positionToLightSource);",
 240     "      attenuation = 1.0 / (light0.constantAttenuation",
 241     "                           + light0.linearAttenuation * distance",
 242     "                           + light0.quadraticAttenuation * distance * distance);",
 243     " ",
 244     "      if (light0.spotCutoff <= 90.0) /* spotlight? */",
 245     "        {",
 246     "          float clampedCosine = max(0.0, dot(-lightDirection, light0.spotDirection));",
 247     "          if (clampedCosine < cos(radians(light0.spotCutoff))) /* outside of spotlight cone? */",
 248     "            {",
 249     "              attenuation = 0.0;",
 250     "            }",
 251     "          else",
 252     "            {",
 253     "              attenuation = attenuation * pow(clampedCosine, light0.spotExponent);   ",
 254     "            }",
 255     "        }",
 256     "    }",
 257     " ",
 258     "  vec3 ambientLighting = vec3(scene_ambient) * vec3(frontMaterial.ambient);",
 259     " ",
 260     "  vec3 diffuseReflection = attenuation ",
 261     "    * vec3(light0.diffuse) * vec3(frontMaterial.diffuse)",
 262     "    * max(0.0, dot(normalDirection, lightDirection));",
 263     " ",
 264     "  vec3 specularReflection;",
 265     "  if (dot(normalDirection, lightDirection) < 0.0) /* light source on the wrong side? */",
 266     "    {",
 267     "      specularReflection = vec3(0.0, 0.0, 0.0); /* no specular reflection */",
 268     "    }",
 269     "  else /* light source on the right side */",
 270     "    {",
 271     "      specularReflection = attenuation * vec3(light0.specular) * vec3(frontMaterial.specular) ",
 272     "        * pow(max(0.0, dot(reflect(-lightDirection, normalDirection), viewDirection)), frontMaterial.shininess);",
 273     "    }",
 274     " ",
 275     "  gl_FragColor = vec4(ambientLighting + diffuseReflection + specularReflection, 1.0);",
 276     "}"
 277 };
 278
 279 GLint getAttribOrUniformLocation(const char* name, GLuint program, GLboolean isAttrib)
 280 {
 281     if (isAttrib)
 282     {
 283         GLint attrib = gl_GetAttribLocation(program, name);
 284         if (attrib == -1)
 285         {
 286             fprintf(stderr, "Warning: Could not bind attrib %s\n", name);
 287         }
 288
 289         checkError ("getAttribOrUniformLocation");
 290         return attrib;
 291     }
 292     else
 293     {
 294         GLint uniform = gl_GetUniformLocation(program, name);
 295         if (uniform == -1)
 296         {
 297             fprintf(stderr, "Warning: Could not bind uniform %s\n", name);
 298         }
 299
 300         checkError ("getAttribOrUniformLocation");
 301         return uniform;
 302     }
 303 }
 304
 305 GLuint program;
 306 GLint attribute_fg_coord = -1, attribute_fg_normal = -1;
 307 GLint uniform_m = -1, uniform_p = -1, uniform_m_3x3_inv_transp = -1;
 308 GLint shaderReady = 0;  /* Set to 1 when all initialization went well, to -1 when shader somehow unusable. */
 309
 310
 311
 312 void compileAndCheck(GLuint shader)
 313 {
 314     GLint status;
 315     gl_CompileShader (shader);
 316     gl_GetShaderiv (shader, GL_COMPILE_STATUS, &status);
 317     if (status == GL_FALSE) {
 318         GLint infoLogLength;
 319         ourGLchar *infoLog;
 320         gl_GetShaderiv (shader, GL_INFO_LOG_LENGTH, &infoLogLength);
 321         infoLog = (ourGLchar*) malloc (infoLogLength);
 322         gl_GetShaderInfoLog (shader, infoLogLength, NULL, infoLog);
 323         fprintf (stderr, "compile log: %s\n", infoLog);
 324         free (infoLog);
 325     }
 326     checkError ("compileAndCheck");
 327 }
 328
 329 GLuint compileShaderSource(GLenum type, GLsizei count, const ourGLchar **string)
 330 {
 331     GLuint shader = gl_CreateShader (type);
 332     gl_ShaderSource (shader, count, string, NULL);
 333
 334     checkError ("compileShaderSource");
 335
 336     compileAndCheck (shader);
 337     return shader;
 338 }
 339
 340 void linkAndCheck(GLuint program)
 341 {
 342     GLint status;
 343     gl_LinkProgram (program);
 344     gl_GetProgramiv (program, GL_LINK_STATUS, &status);
 345     if (status == GL_FALSE) {
 346         GLint infoLogLength;
 347         ourGLchar *infoLog;
 348         gl_GetProgramiv (program, GL_INFO_LOG_LENGTH, &infoLogLength);
 349         infoLog = (ourGLchar*) malloc (infoLogLength);
 350         gl_GetProgramInfoLog (program, infoLogLength, NULL, infoLog);
 351         fprintf (stderr, "link log: %s\n", infoLog);
 352         free (infoLog);
 353     }
 354     checkError ("linkAndCheck");
 355 }
 356
 357 void createProgram(GLuint vertexShader, GLuint fragmentShader)
 358 {
 359     program = gl_CreateProgram ();
 360     if (vertexShader != 0) {
 361         gl_AttachShader (program, vertexShader);
 362     }
 363     if (fragmentShader != 0) {
 364         gl_AttachShader (program, fragmentShader);
 365     }
 366
 367     checkError ("createProgram");
 368
 369     linkAndCheck (program);
 370 }
 371
 372 void initShader(void)
 373 {
 374     const GLsizei vertexShaderLines = sizeof(vertexShaderSource) / sizeof(ourGLchar*);
 375     GLuint vertexShader =
 376         compileShaderSource (GL_VERTEX_SHADER, vertexShaderLines, vertexShaderSource);
 377
 378     const GLsizei fragmentShaderLines = sizeof(fragmentShaderSource) / sizeof(ourGLchar*);
 379     GLuint fragmentShader =
 380         compileShaderSource (GL_FRAGMENT_SHADER, fragmentShaderLines, fragmentShaderSource);
 381
 382     checkError ("initShader - 1");
 383
 384     createProgram (vertexShader, fragmentShader);
 385
 386     gl_UseProgram (program);
 387
 388     attribute_fg_coord      = getAttribOrUniformLocation("fg_coord"         , program, GL_TRUE);
 389     attribute_fg_normal     = getAttribOrUniformLocation("fg_normal"        , program, GL_TRUE);
 390     uniform_m               = getAttribOrUniformLocation("m"                , program, GL_FALSE);
 391     uniform_p               = getAttribOrUniformLocation("p"                , program, GL_FALSE);
 392     uniform_m_3x3_inv_transp= getAttribOrUniformLocation("m_3x3_inv_transp" , program, GL_FALSE);
 393
 394     gl_UseProgram (0);
 395
 396     if (attribute_fg_coord==-1 || attribute_fg_normal==-1 ||
 397         uniform_m==-1 || uniform_p==-1 || uniform_m_3x3_inv_transp==-1)
 398         shaderReady = -1;
 399     else
 400         shaderReady = 1;
 401
 402     checkError ("initShader - 2");
 403 }
 404
 405 /*
 406  * This macro is only intended to be used on arrays, of course.
 407  */
 408 #define NUMBEROF(x) ((sizeof(x))/(sizeof(x[0])))
 409
 410 /*
 411  * These global variables control which object is drawn,
 412  * and how it is drawn.  No object uses all of these
 413  * variables.
 414  */
 415 static int function_index;
 416 static int slices = 16;
 417 static int stacks = 16;
 418 static double irad = .25;
 419 static double orad = 1.0;   /* doubles as size for objects other than Torus */
 420 static int depth = 4;
 421 static double offset[ 3 ] = { 0, 0, 0 };
 422 static GLboolean show_info = GL_TRUE;
 423 static float ar;
 424 static GLboolean persProject = GL_TRUE;
 425 static GLboolean animateXRot = GL_FALSE;
 426 static GLboolean useShader   = GL_FALSE;
 427 static GLboolean visNormals  = GL_FALSE;
 428 static GLboolean flat;
 429
 430 /*
 431  * Enum to tell drawSizeInfo what to draw for each object
 432  */
 433 #define GEO_NO_SIZE 0
 434 #define GEO_SIZE 1
 435 #define GEO_SCALE 2
 436 #define GEO_INNER_OUTER_RAD 4
 437 #define GEO_RAD 8
 438 #define GEO_BASE_HEIGHT 16
 439 #define GEO_RAD_HEIGHT 32
 440
 441 /*
 442  * These one-liners draw particular objects, fetching appropriate
 443  * information from the above globals.  They are just thin wrappers
 444  * for the FreeGLUT objects.
 445  */
 446 static void drawSolidTetrahedron(void)         { glutSolidTetrahedron ();                        }
 447 static void drawWireTetrahedron(void)          { glutWireTetrahedron ();                         }
 448 static void drawSolidCube(void)                { glutSolidCube(orad);                            }  /* orad doubles as size input */
 449 static void drawWireCube(void)                 { glutWireCube(orad);                             }  /* orad doubles as size input */
 450 static void drawSolidOctahedron(void)          { glutSolidOctahedron ();                         }
 451 static void drawWireOctahedron(void)           { glutWireOctahedron ();                          }
 452 static void drawSolidDodecahedron(void)        { glutSolidDodecahedron ();                       }
 453 static void drawWireDodecahedron(void)         { glutWireDodecahedron ();                        }
 454 static void drawSolidRhombicDodecahedron(void) { glutSolidRhombicDodecahedron ();                }
 455 static void drawWireRhombicDodecahedron(void)  { glutWireRhombicDodecahedron ();                 }
 456 static void drawSolidIcosahedron(void)         { glutSolidIcosahedron ();                        }
 457 static void drawWireIcosahedron(void)          { glutWireIcosahedron ();                         }
 458 static void drawSolidSierpinskiSponge(void)    { glutSolidSierpinskiSponge (depth, offset, orad);}  /* orad doubles as size input */
 459 static void drawWireSierpinskiSponge(void)     { glutWireSierpinskiSponge (depth, offset, orad); }  /* orad doubles as size input */
 460 static void drawSolidTorus(void)               { glutSolidTorus(irad,orad,slices,stacks);        }
 461 static void drawWireTorus(void)                { glutWireTorus (irad,orad,slices,stacks);        }
 462 static void drawSolidSphere(void)              { glutSolidSphere(orad,slices,stacks);            }  /* orad doubles as size input */
 463 static void drawWireSphere(void)               { glutWireSphere(orad,slices,stacks);             }  /* orad doubles as size input */
 464 static void drawSolidCone(void)                { glutSolidCone(irad,orad,slices,stacks);         }  /* irad doubles as base input, and orad as height input */
 465 static void drawWireCone(void)                 { glutWireCone(irad,orad,slices,stacks);          }  /* irad doubles as base input, and orad as height input */
 466 static void drawSolidCylinder(void)            { glutSolidCylinder(irad,orad,slices,stacks);     }  /* irad doubles as radius input, and orad as height input */
 467 static void drawWireCylinder(void)             { glutWireCylinder(irad,orad,slices,stacks);      }  /* irad doubles as radius input, and orad as height input */
 468 /* per Glut manpage, it should be noted that the teapot is rendered
 469  * with clockwise winding for front facing polygons...
 470  * Same for the teacup and teaspoon
 471  */
 472 static void drawSolidTeapot(void)
 473 {   glFrontFace(GL_CW);    glutSolidTeapot(orad);   glFrontFace(GL_CCW);    /* orad doubles as size input */}
 474 static void drawWireTeapot(void)
 475 {   glFrontFace(GL_CW);    glutWireTeapot(orad);    glFrontFace(GL_CCW);    /* orad doubles as size input */}
 476 static void drawSolidTeacup(void)
 477 {   glFrontFace(GL_CW);    glutSolidTeacup(orad);   glFrontFace(GL_CCW);    /* orad doubles as size input */}
 478 static void drawWireTeacup(void)
 479 {   glFrontFace(GL_CW);    glutWireTeacup(orad);    glFrontFace(GL_CCW);    /* orad doubles as size input */}
 480 static void drawSolidTeaspoon(void)
 481 {   glFrontFace(GL_CW);    glutSolidTeaspoon(orad); glFrontFace(GL_CCW);    /* orad doubles as size input */}
 482 static void drawWireTeaspoon(void)
 483 {   glFrontFace(GL_CW);    glutWireTeaspoon(orad);  glFrontFace(GL_CCW);    /* orad doubles as size input */}
 484
 485 #define RADIUSFAC    0.70710678118654752440084436210485f
 486
 487 static void drawSolidCuboctahedron(void)
 488 {
 489   GLfloat radius = RADIUSFAC*(GLfloat)orad; /* orad doubles as size */
 490   glBegin( GL_TRIANGLES );
 491     glNormal3d( 0.577350269189, 0.577350269189, 0.577350269189); glVertex3d( radius, radius, 0.0 ); glVertex3d( 0.0, radius, radius ); glVertex3d( radius, 0.0, radius );
 492     glNormal3d( 0.577350269189, 0.577350269189,-0.577350269189); glVertex3d( radius, radius, 0.0 ); glVertex3d( radius, 0.0,-radius ); glVertex3d( 0.0, radius,-radius );
 493     glNormal3d( 0.577350269189,-0.577350269189, 0.577350269189); glVertex3d( radius,-radius, 0.0 ); glVertex3d( radius, 0.0, radius ); glVertex3d( 0.0,-radius, radius );
 494     glNormal3d( 0.577350269189,-0.577350269189,-0.577350269189); glVertex3d( radius,-radius, 0.0 ); glVertex3d( 0.0,-radius,-radius ); glVertex3d( radius, 0.0,-radius );
 495     glNormal3d(-0.577350269189, 0.577350269189, 0.577350269189); glVertex3d(-radius, radius, 0.0 ); glVertex3d(-radius, 0.0, radius ); glVertex3d( 0.0, radius, radius );
 496     glNormal3d(-0.577350269189, 0.577350269189,-0.577350269189); glVertex3d(-radius, radius, 0.0 ); glVertex3d( 0.0, radius,-radius ); glVertex3d(-radius, 0.0,-radius );
 497     glNormal3d(-0.577350269189,-0.577350269189, 0.577350269189); glVertex3d(-radius,-radius, 0.0 ); glVertex3d( 0.0,-radius, radius ); glVertex3d(-radius, 0.0, radius );
 498     glNormal3d(-0.577350269189,-0.577350269189,-0.577350269189); glVertex3d(-radius,-radius, 0.0 ); glVertex3d(-radius, 0.0,-radius ); glVertex3d( 0.0,-radius,-radius );
 499   glEnd();
 500
 501   glBegin( GL_QUADS );
 502     glNormal3d( 1.0, 0.0, 0.0 ); glVertex3d( radius, radius, 0.0 ); glVertex3d( radius, 0.0, radius ); glVertex3d( radius,-radius, 0.0 ); glVertex3d( radius, 0.0,-radius );
 503     glNormal3d(-1.0, 0.0, 0.0 ); glVertex3d(-radius, radius, 0.0 ); glVertex3d(-radius, 0.0,-radius ); glVertex3d(-radius,-radius, 0.0 ); glVertex3d(-radius, 0.0, radius );
 504     glNormal3d( 0.0, 1.0, 0.0 ); glVertex3d( radius, radius, 0.0 ); glVertex3d( 0.0, radius,-radius ); glVertex3d(-radius, radius, 0.0 ); glVertex3d( 0.0, radius, radius );
 505     glNormal3d( 0.0,-1.0, 0.0 ); glVertex3d( radius,-radius, 0.0 ); glVertex3d( 0.0,-radius, radius ); glVertex3d(-radius,-radius, 0.0 ); glVertex3d( 0.0,-radius,-radius );
 506     glNormal3d( 0.0, 0.0, 1.0 ); glVertex3d( radius, 0.0, radius ); glVertex3d( 0.0, radius, radius ); glVertex3d(-radius, 0.0, radius ); glVertex3d( 0.0,-radius, radius );
 507     glNormal3d( 0.0, 0.0,-1.0 ); glVertex3d( radius, 0.0,-radius ); glVertex3d( 0.0,-radius,-radius ); glVertex3d(-radius, 0.0,-radius ); glVertex3d( 0.0, radius,-radius );
 508   glEnd();
 509 }
 510
 511 static void drawWireCuboctahedron(void)
 512 {
 513   GLfloat radius = RADIUSFAC*(GLfloat)orad; /* orad doubles as size */
 514   glBegin( GL_LINE_LOOP );
 515     glNormal3d( 1.0, 0.0, 0.0 ); glVertex3d( radius, radius, 0.0 ); glVertex3d( radius, 0.0, radius ); glVertex3d( radius,-radius, 0.0 ); glVertex3d( radius, 0.0,-radius );
 516   glEnd();
 517   glBegin( GL_LINE_LOOP );
 518     glNormal3d(-1.0, 0.0, 0.0 ); glVertex3d(-radius, radius, 0.0 ); glVertex3d(-radius, 0.0,-radius ); glVertex3d(-radius,-radius, 0.0 ); glVertex3d(-radius, 0.0, radius );
 519   glEnd();
 520   glBegin( GL_LINE_LOOP );
 521     glNormal3d( 0.0, 1.0, 0.0 ); glVertex3d( radius, radius, 0.0 ); glVertex3d( 0.0, radius,-radius ); glVertex3d(-radius, radius, 0.0 ); glVertex3d( 0.0, radius, radius );
 522   glEnd();
 523   glBegin( GL_LINE_LOOP );
 524     glNormal3d( 0.0,-1.0, 0.0 ); glVertex3d( radius,-radius, 0.0 ); glVertex3d( 0.0,-radius, radius ); glVertex3d(-radius,-radius, 0.0 ); glVertex3d( 0.0,-radius,-radius );
 525   glEnd();
 526   glBegin( GL_LINE_LOOP );
 527     glNormal3d( 0.0, 0.0, 1.0 ); glVertex3d( radius, 0.0, radius ); glVertex3d( 0.0, radius, radius ); glVertex3d(-radius, 0.0, radius ); glVertex3d( 0.0,-radius, radius );
 528   glEnd();
 529   glBegin( GL_LINE_LOOP );
 530     glNormal3d( 0.0, 0.0,-1.0 ); glVertex3d( radius, 0.0,-radius ); glVertex3d( 0.0,-radius,-radius ); glVertex3d(-radius, 0.0,-radius ); glVertex3d( 0.0, radius,-radius );
 531   glEnd();
 532 }
 533
 534 #undef RADIUSFAC
 535
 536 /*
 537  * This structure defines an entry in our function-table.
 538  */
 539 typedef struct
 540 {
 541     const char * const name;
 542     void (*solid) (void);
 543     void (*wire)  (void);
 544     int drawSizeInfoFlag;
 545 } entry;
 546
 547 #define ENTRY(e,f) {#e, drawSolid##e, drawWire##e,f}
 548 static const entry table [] =
 549 {
 550     ENTRY (Tetrahedron,GEO_NO_SIZE),
 551     ENTRY (Cube,GEO_SIZE),
 552     ENTRY (Octahedron,GEO_NO_SIZE),
 553     ENTRY (Dodecahedron,GEO_NO_SIZE),
 554     ENTRY (RhombicDodecahedron,GEO_NO_SIZE),
 555     ENTRY (Icosahedron,GEO_NO_SIZE),
 556     ENTRY (SierpinskiSponge,GEO_SCALE),
 557     ENTRY (Teapot,GEO_SIZE),
 558     ENTRY (Teacup,GEO_SIZE),
 559     ENTRY (Teaspoon,GEO_SIZE),
 560     ENTRY (Torus,GEO_INNER_OUTER_RAD),
 561     ENTRY (Sphere,GEO_RAD),
 562     ENTRY (Cone,GEO_BASE_HEIGHT),
 563     ENTRY (Cylinder,GEO_RAD_HEIGHT),
 564     ENTRY (Cuboctahedron,GEO_SIZE)   /* This one doesn't work when in shader mode and is then skipped */
 565 };
 566 #undef ENTRY
 567
 568 /*!
 569     Does printf()-like work using freeglut
 570     glutBitmapString().  Uses a fixed font.  Prints
 571     at the indicated row/column position.
 572
 573     Limitation: Cannot address pixels.
 574     Limitation: Renders in screen coords, not model coords.
 575 */
 576 static void shapesPrintf (int row, int col, const char *fmt, ...)
 577 {
 578     static char buf[256];
 579     int viewport[4];
 580     void *font = GLUT_BITMAP_9_BY_15;
 581     va_list args;
 582
 583     va_start(args, fmt);
 584 #if defined(WIN32) && !defined(__CYGWIN__)
 585     (void) _vsnprintf (buf, sizeof(buf), fmt, args);
 586 #else
 587     (void) vsnprintf (buf, sizeof(buf), fmt, args);
 588 #endif
 589     va_end(args);
 590
 591     glGetIntegerv(GL_VIEWPORT,viewport);
 592
 593     glPushMatrix();
 594     glLoadIdentity();
 595
 596     glMatrixMode(GL_PROJECTION);
 597     glPushMatrix();
 598     glLoadIdentity();
 599
 600         glOrtho(0,viewport[2],0,viewport[3],-1,1);
 601
 602         glRasterPos2i
 603         (
 604               glutBitmapWidth(font, ' ') * col,
 605             - glutBitmapHeight(font) * row + viewport[3]
 606         );
 607         glutBitmapString (font, (unsigned char*)buf);
 608
 609     glPopMatrix();
 610     glMatrixMode(GL_MODELVIEW);
 611     glPopMatrix();
 612 }
 613
 614 /* Print info about the about the current shape and render state on the screen */
 615 static void DrawSizeInfo(int *row)
 616 {
 617     switch (table [function_index].drawSizeInfoFlag)
 618     {
 619     case GEO_NO_SIZE:
 620         break;
 621     case GEO_SIZE:
 622         shapesPrintf ((*row)++, 1, "Size  Up  Down : %f", orad);
 623         break;
 624     case GEO_SCALE:
 625         shapesPrintf ((*row)++, 1, "Scale  Up  Down : %f", orad);
 626         break;
 627     case GEO_INNER_OUTER_RAD:
 628         shapesPrintf ((*row)++, 1, "Inner radius Left Right: %f", irad);
 629         shapesPrintf ((*row)++, 1, "Outer radius  Up  Down : %f", orad);
 630         break;
 631     case GEO_RAD:
 632         shapesPrintf ((*row)++, 1, "Radius  Up  Down : %f", orad);
 633         break;
 634     case GEO_BASE_HEIGHT:
 635         shapesPrintf ((*row)++, 1, "Base   Left Right: %f", irad);
 636         shapesPrintf ((*row)++, 1, "Height  Up  Down : %f", orad);
 637         break;
 638     case GEO_RAD_HEIGHT:
 639         shapesPrintf ((*row)++, 1, "Radius Left Right: %f", irad);
 640         shapesPrintf ((*row)++, 1, "Height  Up  Down : %f", orad);
 641         break;
 642     }
 643 }
 644
 645 static void drawInfo()
 646 {
 647     int row = 1;
 648     shapesPrintf (row++, 1, "Shape PgUp PgDn: %s", table [function_index].name);
 649     shapesPrintf (row++, 1, "Slices +-: %d   Stacks <>: %d", slices, stacks);
 650     shapesPrintf (row++, 1, "nSides +-: %d   nRings <>: %d", slices, stacks);
 651     shapesPrintf (row++, 1, "Depth  (): %d", depth);
 652     DrawSizeInfo(&row);
 653     if (persProject)
 654         shapesPrintf (row++, 1, "Perspective projection (p)");
 655     else
 656         shapesPrintf (row++, 1, "Orthographic projection (p)");
 657     if (useShader) {
 658         shapesPrintf (row++, 1, "Using shader (s)");
 659     } else {
 660         shapesPrintf (row++, 1, "Using fixed function pipeline (s)");
 661         if (flat)
 662             shapesPrintf (row++, 1, "Flat shading (f)");
 663         else
 664             shapesPrintf (row++, 1, "Smooth shading (f)");
 665     }
 666     if (animateXRot)
 667         shapesPrintf (row++, 1, "2D rotation (r)");
 668     else
 669         shapesPrintf (row++, 1, "1D rotation (r)");
 670     shapesPrintf (row++, 1, "visualizing normals: %i (n)",visNormals);
 671 }
 672
 673 /* GLUT callback Handlers */
 674 static void
 675 resize(int width, int height)
 676 {
 677     ar = (float) width / (float) height;
 678
 679     glViewport(0, 0, width, height);
 680 }
 681
 682 static void display(void)
 683 {
 684     const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
 685     const double a = t*89.0;
 686     const double b = (animateXRot?t:1)*67.0;
 687
 688     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 689
 690     glutSetOption(GLUT_GEOMETRY_VISUALIZE_NORMALS,visNormals);  /* Normals visualized or not? */
 691
 692     glShadeModel(flat ? GL_FLAT : GL_SMOOTH);  /* flat or gouraud shading */
 693
 694     if (useShader && !shaderReady)
 695         initShader();
 696
 697     if (useShader && shaderReady)
 698     {
 699         /* setup use of shader (and vertex buffer by FreeGLUT) */
 700         gl_UseProgram (program);
 701         glutSetVertexAttribCoord3(attribute_fg_coord);
 702         glutSetVertexAttribNormal(attribute_fg_normal);
 703         /* There is also a glutSetVertexAttribTexCoord2, which is used only when drawing the teapot, teacup or teaspoon */
 704
 705         gl_matrix_mode(GL_PROJECTION);
 706         gl_load_identity();
 707         if (persProject)
 708             gl_frustum(-ar, ar, -1.f, 1.f, 2.f, 100.f);
 709         else
 710             gl_ortho(-ar*3, ar*3, -3.f, 3.f, 2.f, 100.f);
 711         gl_UniformMatrix4fv (uniform_p, 1, GL_FALSE, get_matrix(GL_PROJECTION));
 712
 713
 714         gl_matrix_mode(GL_MODELVIEW);
 715         gl_load_identity();
 716
 717         gl_push_matrix();
 718             /* Not in reverse order like normal OpenGL, our util library multiplies the matrices in the order they are specified in */
 719             gl_rotatef((float)a,0,0,1);
 720             gl_rotatef((float)b,1,0,0);
 721             gl_translatef(0,1.2f,-6);
 722             gl_UniformMatrix4fv (uniform_m               , 1, GL_FALSE, get_matrix(GL_MODELVIEW));
 723             gl_UniformMatrix3fv (uniform_m_3x3_inv_transp, 1, GL_FALSE, get_inv_transpose_3x3(GL_MODELVIEW));
 724             table [function_index].solid ();
 725         gl_pop_matrix();
 726
 727         gl_push_matrix();
 728             gl_rotatef((float)a,0,0,1);
 729             gl_rotatef((float)b,1,0,0);
 730             gl_translatef(0,-1.2f,-6);
 731             gl_UniformMatrix4fv (uniform_m               , 1, GL_FALSE, get_matrix(GL_MODELVIEW));
 732             gl_UniformMatrix3fv (uniform_m_3x3_inv_transp, 1, GL_FALSE, get_inv_transpose_3x3(GL_MODELVIEW));
 733             table [function_index].wire ();
 734         gl_pop_matrix();
 735
 736         gl_UseProgram (0);
 737         glutSetVertexAttribCoord3(-1);
 738         glutSetVertexAttribNormal(-1);
 739
 740         checkError ("display");
 741     }
 742     else
 743     {
 744         /* fixed function pipeline */
 745         glMatrixMode(GL_PROJECTION);
 746         glLoadIdentity();
 747         if (persProject)
 748             glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
 749         else
 750             glOrtho(-ar*3, ar*3, -3.0, 3.0, 2.0, 100.0);
 751         glMatrixMode(GL_MODELVIEW);
 752         glLoadIdentity();
 753
 754         glEnable(GL_LIGHTING);
 755
 756         glColor3d(1,0,0);
 757
 758         glPushMatrix();
 759             glTranslated(0,1.2,-6);
 760             glRotated(b,1,0,0);
 761             glRotated(a,0,0,1);
 762             table [function_index].solid ();
 763         glPopMatrix();
 764
 765         glPushMatrix();
 766             glTranslated(0,-1.2,-6);
 767             glRotated(b,1,0,0);
 768             glRotated(a,0,0,1);
 769             table [function_index].wire ();
 770         glPopMatrix();
 771
 772         glDisable(GL_LIGHTING);
 773         glColor3d(0.1,0.1,0.4);
 774     }
 775
 776     if( show_info )
 777         /* print info to screen */
 778         drawInfo();
 779     else
 780         /* print to command line instead */
 781         printf ( "Shape %d slides %d stacks %d\n", function_index, slices, stacks ) ;
 782
 783     glutSwapBuffers();
 784 }
 785
 786
 787 static void
 788 key(unsigned char key, int x, int y)
 789 {
 790     switch (key)
 791     {
 792     case 27 :
 793     case 'Q':
 794     case 'q': glutLeaveMainLoop () ;      break;
 795
 796     case 'I':
 797     case 'i': show_info=!show_info;       break;
 798
 799     case '=':
 800     case '+': slices++;                   break;
 801
 802     case '-':
 803     case '_': if( slices > -1 ) slices--; break;
 804
 805     case ',':
 806     case '<': if( stacks > -1 ) stacks--; break;
 807
 808     case '.':
 809     case '>': stacks++;                   break;
 810
 811     case '9':
 812     case '(': if( depth > -1 ) depth--;   break;
 813
 814     case '0':
 815     case ')': ++depth;                    break;
 816
 817     case 'P':
 818     case 'p': persProject=!persProject;   break;
 819
 820     case 'R':
 821     case 'r': animateXRot=!animateXRot;   break;
 822
 823     case 'S':
 824     case 's':
 825         useShader=!useShader;
 826         /* Cuboctahedron can't be shown when in shader mode, move to next */
 827         if (useShader && NUMBEROF (table)-1 == ( unsigned )function_index)
 828                 function_index = 0;
 829         break;
 830
 831     case 'F':
 832     case 'f':
 833         flat ^= 1;
 834         break;
 835
 836     case 'N':
 837     case 'n': visNormals=!visNormals;     break;
 838
 839     default:
 840         break;
 841     }
 842
 843     glutPostRedisplay();
 844 }
 845
 846 static void special (int key, int x, int y)
 847 {
 848     switch (key)
 849     {
 850     case GLUT_KEY_PAGE_UP:    ++function_index; break;
 851     case GLUT_KEY_PAGE_DOWN:  --function_index; break;
 852     case GLUT_KEY_UP:         orad *= 2;        break;
 853     case GLUT_KEY_DOWN:       orad /= 2;        break;
 854
 855     case GLUT_KEY_RIGHT:      irad *= 2;        break;
 856     case GLUT_KEY_LEFT:       irad /= 2;        break;
 857
 858     default:
 859         break;
 860     }
 861
 862     if (0 > function_index)
 863         function_index = NUMBEROF (table) - 1;
 864
 865     if (NUMBEROF (table) <= ( unsigned )function_index)
 866         function_index = 0;
 867
 868     /* Cuboctahedron can't be shown when in shader mode, skip it */
 869     if (useShader && NUMBEROF (table)-1 == ( unsigned )function_index)
 870     {
 871         if (key==GLUT_KEY_PAGE_UP)
 872             function_index = 0;
 873         else
 874             function_index -= 1;
 875     }
 876 }
 877
 878
 879 static void
 880 idle(void)
 881 {
 882     glutPostRedisplay();
 883 }
 884
 885 const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
 886 const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
 887 const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
 888 const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };
 889
 890 const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
 891 const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
 892 const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
 893 const GLfloat high_shininess[] = { 100.0f };
 894
 895 /* Program entry point */
 896
 897 int
 898 main(int argc, char *argv[])
 899 {
 900     glutInitWindowSize(800,600);
 901     glutInitWindowPosition(40,40);
 902     glutInit(&argc, argv);
 903     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
 904
 905     glutCreateWindow("FreeGLUT Shapes");
 906
 907     glutReshapeFunc(resize);
 908     glutDisplayFunc(display);
 909     glutKeyboardFunc(key);
 910     glutSpecialFunc(special);
 911     glutIdleFunc(idle);
 912
 913     glutSetOption ( GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION ) ;
 914
 915     glClearColor(1,1,1,1);
 916     glEnable(GL_CULL_FACE);
 917     glCullFace(GL_BACK);
 918
 919     glEnable(GL_DEPTH_TEST);
 920     glDepthFunc(GL_LESS);
 921
 922     glEnable(GL_LIGHT0);
 923     glEnable(GL_NORMALIZE);
 924     glEnable(GL_COLOR_MATERIAL);
 925
 926     glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
 927     glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
 928     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
 929     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
 930
 931     glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
 932     glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
 933     glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
 934     glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
 935
 936     initExtensionEntries();
 937
 938     glutMainLoop();
 939
 940 #ifdef _MSC_VER
 941     /* DUMP MEMORY LEAK INFORMATION */
 942     _CrtDumpMemoryLeaks () ;
 943 #endif
 944
 945     return EXIT_SUCCESS;
 946 }