Squashed 'nx-X11/extras/Mesa_6.4.2/' content from commit 475b1f7

git-subtree-dir: nx-X11/extras/Mesa_6.4.2
git-subtree-split: 475b1f7b56fa36ef4f3b22a749f88a98ddc0d502

1 files changed, 712 insertions, 0 deletions

diff --git a/progs/demos/ipers.c b/progs/demos/ipers.c
new file mode 100644
index 000000000..6e153c04e
--- /dev/null
+++ b/progs/demos/ipers.c
@@ -0,0 +1,712 @@
+/*
+ * This program is under the GNU GPL.
+ * Use at your own risk.
+ *
+ * written by David Bucciarelli (tech.hmw@plus.it)
+ *            Humanware s.r.l.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#if defined (WIN32)|| defined(_WIN32)
+#include <windows.h>
+#include <mmsystem.h>
+#endif
+
+#include <GL/glut.h>
+
+#include "readtex.h"
+
+#ifdef XMESA
+#include "GL/xmesa.h"
+static int fullscreen = 1;
+#endif
+
+static int WIDTH = 640;
+static int HEIGHT = 480;
+
+static GLint T0;
+static GLint Frames;
+
+#define MAX_LOD 9
+
+#define TEX_SKY_WIDTH 256
+#define TEX_SKY_HEIGHT TEX_SKY_WIDTH
+
+#ifndef M_PI
+#define M_PI 3.1415926535
+#endif
+
+#define FROM_NONE   0
+#define FROM_DOWN   1
+#define FROM_UP     2
+#define FROM_LEFT   3
+#define FROM_RIGHT  4
+#define FROM_FRONT  5
+#define FROM_BACK   6
+
+static int win = 0;
+
+static float obs[3] = { 3.8, 0.0, 0.0 };
+static float dir[3];
+static float v = 0.0;
+static float alpha = -90.0;
+static float beta = 90.0;
+
+static int fog = 1;
+static int bfcull = 1;
+static int usetex = 1;
+static int help = 1;
+static int poutline = 0;
+static int normext = 1;
+static int joyavailable = 0;
+static int joyactive = 0;
+static int LODbias = 3;
+static int maxdepth = MAX_LOD;
+
+static unsigned int totpoly = 0;
+
+static GLuint t1id, t2id;
+static GLuint skydlist, LODdlist[MAX_LOD], LODnumpoly[MAX_LOD];
+
+static void
+initlight(void)
+{
+   GLfloat lspec[4] = { 1.0, 1.0, 1.0, 1.0 };
+   static GLfloat lightpos[4] = { 30, 15.0, 30.0, 1.0 };
+
+   glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
+   glLightfv(GL_LIGHT0, GL_SPECULAR, lspec);
+
+   glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 32.0);
+   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, lspec);
+}
+
+static void
+initdlists(void)
+{
+   static int slicetable[MAX_LOD][2] = {
+      {21, 10},
+      {18, 9},
+      {15, 8},
+      {12, 7},
+      {9, 6},
+      {7, 5},
+      {5, 4},
+      {4, 3},
+      {3, 2}
+   };
+   GLUquadricObj *obj;
+   int i, xslices, yslices;
+
+   obj = gluNewQuadric();
+
+   skydlist = glGenLists(1);
+   glNewList(skydlist, GL_COMPILE);
+   glBindTexture(GL_TEXTURE_2D, t2id);
+   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+   glColor3f(1.0f, 1.0f, 1.0f);
+
+   gluQuadricDrawStyle(obj, GLU_FILL);
+   gluQuadricNormals(obj, GLU_NONE);
+   gluQuadricTexture(obj, GL_TRUE);
+   gluQuadricOrientation(obj, GLU_INSIDE);
+   gluSphere(obj, 40.0f, 18, 9);
+
+   glEndList();
+
+   for (i = 0; i < MAX_LOD; i++) {
+      LODdlist[i] = glGenLists(1);
+      glNewList(LODdlist[i], GL_COMPILE);
+
+      gluQuadricDrawStyle(obj, GLU_FILL);
+      gluQuadricNormals(obj, GLU_SMOOTH);
+      gluQuadricTexture(obj, GL_TRUE);
+      gluQuadricOrientation(obj, GLU_OUTSIDE);
+      xslices = slicetable[i][0];
+      yslices = slicetable[i][1];
+      gluSphere(obj, 1.0f, xslices, yslices);
+      LODnumpoly[i] = xslices * (yslices - 2) + 2 * (xslices - 1);
+
+      glEndList();
+   }
+}
+
+static void
+inittextures(void)
+{
+   GLubyte tsky[TEX_SKY_HEIGHT][TEX_SKY_WIDTH][3];
+   GLuint x, y;
+   GLfloat fact;
+   GLenum gluerr;
+
+   /* Brick */
+
+   glGenTextures(1, &t1id);
+   glBindTexture(GL_TEXTURE_2D, t1id);
+
+   if (!LoadRGBMipmaps("../images/bw.rgb", 3)) {
+      fprintf(stderr, "Error reading a texture.\n");
+      exit(-1);
+   }
+
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+		   GL_LINEAR_MIPMAP_LINEAR);
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+   /* Sky */
+
+   glGenTextures(1, &t2id);
+   glBindTexture(GL_TEXTURE_2D, t2id);
+
+   for (y = 0; y < TEX_SKY_HEIGHT; y++)
+      for (x = 0; x < TEX_SKY_WIDTH; x++)
+	 if (y < TEX_SKY_HEIGHT / 2) {
+	    fact = y / (GLfloat) (TEX_SKY_HEIGHT / 2);
+	    tsky[y][x][0] =
+	       (GLubyte) (255.0f * (0.1f * fact + 0.3f * (1.0f - fact)));
+	    tsky[y][x][1] =
+	       (GLubyte) (255.0f * (0.2f * fact + 1.0f * (1.0f - fact)));
+	    tsky[y][x][2] = 255;
+	 }
+	 else {
+	    tsky[y][x][0] = tsky[TEX_SKY_HEIGHT - y - 1][x][0];
+	    tsky[y][x][1] = tsky[TEX_SKY_HEIGHT - y - 1][x][1];
+	    tsky[y][x][2] = 255;
+	 }
+
+   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+   if (
+       (gluerr =
+	gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TEX_SKY_WIDTH, TEX_SKY_HEIGHT,
+			  GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *) (tsky)))) {
+      fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
+      exit(-1);
+   }
+
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+		   GL_LINEAR_MIPMAP_LINEAR);
+   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+}
+
+static void
+calcposobs(void)
+{
+   dir[0] = sin(alpha * M_PI / 180.0);
+   dir[1] = cos(alpha * M_PI / 180.0) * sin(beta * M_PI / 180.0);
+   dir[2] = cos(beta * M_PI / 180.0);
+
+   if (dir[0] < 1.0e-5 && dir[0] > -1.0e-5)
+      dir[0] = 0;
+   if (dir[1] < 1.0e-5 && dir[1] > -1.0e-5)
+      dir[1] = 0;
+   if (dir[2] < 1.0e-5 && dir[2] > -1.0e-5)
+      dir[2] = 0;
+
+   obs[0] += v * dir[0];
+   obs[1] += v * dir[1];
+   obs[2] += v * dir[2];
+}
+
+static void
+special(int k, int x, int y)
+{
+   switch (k) {
+   case GLUT_KEY_LEFT:
+      alpha -= 2.0;
+      break;
+   case GLUT_KEY_RIGHT:
+      alpha += 2.0;
+      break;
+   case GLUT_KEY_DOWN:
+      beta -= 2.0;
+      break;
+   case GLUT_KEY_UP:
+      beta += 2.0;
+      break;
+   }
+}
+
+static void
+key(unsigned char k, int x, int y)
+{
+   switch (k) {
+   case 27:
+      exit(0);
+      break;
+
+   case 'a':
+      v += 0.01;
+      break;
+   case 'z':
+      v -= 0.01;
+      break;
+
+#ifdef XMESA
+   case ' ':
+      fullscreen = (!fullscreen);
+      XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW);
+      break;
+#endif
+
+   case '+':
+      LODbias--;
+      break;
+   case '-':
+      LODbias++;
+      break;
+   case 'j':
+      joyactive = (!joyactive);
+      break;
+   case 'h':
+      help = (!help);
+      break;
+   case 'f':
+      fog = (!fog);
+      break;
+   case 't':
+      usetex = (!usetex);
+      break;
+   case 'n':
+      normext = (!normext);
+      break;
+   case 'b':
+      if (bfcull) {
+	 glDisable(GL_CULL_FACE);
+	 bfcull = 0;
+      }
+      else {
+	 glEnable(GL_CULL_FACE);
+	 bfcull = 1;
+      }
+      break;
+   case 'p':
+      if (poutline) {
+	 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+	 poutline = 0;
+	 usetex = 1;
+      }
+      else {
+	 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	 poutline = 1;
+	 usetex = 0;
+      }
+      break;
+   }
+}
+
+static void
+reshape(int w, int h)
+{
+   WIDTH = w;
+   HEIGHT = h;
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   gluPerspective(90.0, w / (float) h, 0.8, 100.0);
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+   glViewport(0, 0, w, h);
+}
+
+static void
+printstring(void *font, char *string)
+{
+   int len, i;
+
+   len = (int) strlen(string);
+   for (i = 0; i < len; i++)
+      glutBitmapCharacter(font, string[i]);
+}
+
+static void
+printhelp(void)
+{
+   glEnable(GL_BLEND);
+   glColor4f(0.5, 0.5, 0.5, 0.5);
+   glRecti(40, 40, 600, 440);
+   glDisable(GL_BLEND);
+
+   glColor3f(1.0, 0.0, 0.0);
+   glRasterPos2i(300, 420);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "Help");
+
+   glRasterPos2i(60, 390);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "h - Toggle Help");
+   glRasterPos2i(60, 360);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "t - Toggle Textures");
+   glRasterPos2i(60, 330);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "f - Toggle Fog");
+   glRasterPos2i(60, 300);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "b - Toggle Back face culling");
+   glRasterPos2i(60, 270);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "Arrow Keys - Rotate");
+   glRasterPos2i(60, 240);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "a - Increase velocity");
+   glRasterPos2i(60, 210);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "z - Decrease velocity");
+   glRasterPos2i(60, 180);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24, "p - Toggle Wire frame");
+   glRasterPos2i(60, 150);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24,
+	       "n - Toggle GL_EXT_rescale_normal extension");
+   glRasterPos2i(60, 120);
+   printstring(GLUT_BITMAP_TIMES_ROMAN_24,
+	       "+/- - Increase/decrease the Object maximum LOD");
+
+   glRasterPos2i(60, 90);
+   if (joyavailable)
+      printstring(GLUT_BITMAP_TIMES_ROMAN_24,
+		  "j - Toggle jostick control (Joystick control available)");
+   else
+      printstring(GLUT_BITMAP_TIMES_ROMAN_24,
+		  "(No Joystick control available)");
+}
+
+static void
+dojoy(void)
+{
+#ifdef _WIN32
+   static UINT max[2] = { 0, 0 };
+   static UINT min[2] = { 0xffffffff, 0xffffffff }, center[2];
+   MMRESULT res;
+   JOYINFO joy;
+
+   res = joyGetPos(JOYSTICKID1, &joy);
+
+   if (res == JOYERR_NOERROR) {
+      joyavailable = 1;
+
+      if (max[0] < joy.wXpos)
+	 max[0] = joy.wXpos;
+      if (min[0] > joy.wXpos)
+	 min[0] = joy.wXpos;
+      center[0] = (max[0] + min[0]) / 2;
+
+      if (max[1] < joy.wYpos)
+	 max[1] = joy.wYpos;
+      if (min[1] > joy.wYpos)
+	 min[1] = joy.wYpos;
+      center[1] = (max[1] + min[1]) / 2;
+
+      if (joyactive) {
+	 if (fabs(center[0] - (float) joy.wXpos) > 0.1 * (max[0] - min[0]))
+	    alpha -=
+	       2.0 * (center[0] - (float) joy.wXpos) / (max[0] - min[0]);
+	 if (fabs(center[1] - (float) joy.wYpos) > 0.1 * (max[1] - min[1]))
+	    beta += 2.0 * (center[1] - (float) joy.wYpos) / (max[1] - min[1]);
+
+	 if (joy.wButtons & JOY_BUTTON1)
+	    v += 0.01;
+	 if (joy.wButtons & JOY_BUTTON2)
+	    v -= 0.01;
+      }
+   }
+   else
+      joyavailable = 0;
+#endif
+}
+
+static void
+drawipers(int depth, int from)
+{
+   int lod;
+
+   if (depth == maxdepth)
+      return;
+
+   lod = depth + LODbias;
+   if (lod < 0)
+      lod = 0;
+   if (lod >= MAX_LOD)
+      return;
+
+   switch (from) {
+   case FROM_NONE:
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_DOWN);
+      drawipers(depth, FROM_UP);
+      drawipers(depth, FROM_FRONT);
+      drawipers(depth, FROM_BACK);
+      drawipers(depth, FROM_LEFT);
+      drawipers(depth, FROM_RIGHT);
+      break;
+   case FROM_FRONT:
+      glPushMatrix();
+      glTranslatef(0.0f, -1.5f, 0.0f);
+      glScalef(0.5f, 0.5f, 0.5f);
+
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_DOWN);
+      drawipers(depth, FROM_UP);
+      drawipers(depth, FROM_FRONT);
+      drawipers(depth, FROM_LEFT);
+      drawipers(depth, FROM_RIGHT);
+      glPopMatrix();
+      break;
+   case FROM_BACK:
+      glPushMatrix();
+      glTranslatef(0.0f, 1.5f, 0.0f);
+      glScalef(0.5f, 0.5f, 0.5f);
+
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_DOWN);
+      drawipers(depth, FROM_UP);
+      drawipers(depth, FROM_BACK);
+      drawipers(depth, FROM_LEFT);
+      drawipers(depth, FROM_RIGHT);
+      glPopMatrix();
+      break;
+   case FROM_LEFT:
+      glPushMatrix();
+      glTranslatef(-1.5f, 0.0f, 0.0f);
+      glScalef(0.5f, 0.5f, 0.5f);
+
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_DOWN);
+      drawipers(depth, FROM_UP);
+      drawipers(depth, FROM_FRONT);
+      drawipers(depth, FROM_BACK);
+      drawipers(depth, FROM_LEFT);
+      glPopMatrix();
+      break;
+   case FROM_RIGHT:
+      glPushMatrix();
+      glTranslatef(1.5f, 0.0f, 0.0f);
+      glScalef(0.5f, 0.5f, 0.5f);
+
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_DOWN);
+      drawipers(depth, FROM_UP);
+      drawipers(depth, FROM_FRONT);
+      drawipers(depth, FROM_BACK);
+      drawipers(depth, FROM_RIGHT);
+      glPopMatrix();
+      break;
+   case FROM_DOWN:
+      glPushMatrix();
+      glTranslatef(0.0f, 0.0f, 1.5f);
+      glScalef(0.5f, 0.5f, 0.5f);
+
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_DOWN);
+      drawipers(depth, FROM_FRONT);
+      drawipers(depth, FROM_BACK);
+      drawipers(depth, FROM_LEFT);
+      drawipers(depth, FROM_RIGHT);
+      glPopMatrix();
+      break;
+   case FROM_UP:
+      glPushMatrix();
+      glTranslatef(0.0f, 0.0f, -1.5f);
+      glScalef(0.5f, 0.5f, 0.5f);
+
+      glCallList(LODdlist[lod]);
+
+      depth++;
+      drawipers(depth, FROM_UP);
+      drawipers(depth, FROM_FRONT);
+      drawipers(depth, FROM_BACK);
+      drawipers(depth, FROM_LEFT);
+      drawipers(depth, FROM_RIGHT);
+      glPopMatrix();
+      break;
+   }
+
+   totpoly += LODnumpoly[lod];
+}
+
+static void
+draw(void)
+{
+   static char frbuf[80] = "";
+   static GLfloat alpha = 0.0f;
+   static GLfloat beta = 0.0f;
+   static float fr = 0.0;
+   static double t0 = -1.;
+   double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
+   if (t0 < 0.0)
+      t0 = t;
+   dt = t - t0;
+   t0 = t;
+
+   dojoy();
+
+   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+   if (usetex)
+      glEnable(GL_TEXTURE_2D);
+   else
+      glDisable(GL_TEXTURE_2D);
+
+   if (fog)
+      glEnable(GL_FOG);
+   else
+      glDisable(GL_FOG);
+
+   glPushMatrix();
+   calcposobs();
+   gluLookAt(obs[0], obs[1], obs[2],
+	     obs[0] + dir[0], obs[1] + dir[1], obs[2] + dir[2],
+	     0.0, 0.0, 1.0);
+
+   /* Scene */
+   glEnable(GL_DEPTH_TEST);
+
+   glShadeModel(GL_SMOOTH);
+   glBindTexture(GL_TEXTURE_2D, t1id);
+   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+   glColor3f(1.0f, 1.0f, 1.0f);
+   glEnable(GL_LIGHT0);
+   glEnable(GL_LIGHTING);
+
+   if (normext)
+      glEnable(GL_RESCALE_NORMAL_EXT);
+   else
+      glEnable(GL_NORMALIZE);
+
+   glPushMatrix();
+   glRotatef(alpha, 0.0f, 0.0f, 1.0f);
+   glRotatef(beta, 1.0f, 0.0f, 0.0f);
+   totpoly = 0;
+   drawipers(0, FROM_NONE);
+   glPopMatrix();
+
+   alpha += 4.f * dt;
+   beta += 2.4f * dt;
+
+   glDisable(GL_LIGHTING);
+   glDisable(GL_LIGHT0);
+   glShadeModel(GL_FLAT);
+
+   if (normext)
+      glDisable(GL_RESCALE_NORMAL_EXT);
+   else
+      glDisable(GL_NORMALIZE);
+
+   glCallList(skydlist);
+
+   glPopMatrix();
+
+   /* Help Screen */
+
+   sprintf(frbuf,
+	   "Frame rate: %0.2f   LOD: %d   Tot. poly.: %d   Poly/sec: %.1f",
+	   fr, LODbias, totpoly, totpoly * fr);
+
+   glDisable(GL_TEXTURE_2D);
+   glDisable(GL_FOG);
+   glShadeModel(GL_FLAT);
+   glDisable(GL_DEPTH_TEST);
+
+   glMatrixMode(GL_PROJECTION);
+   glPushMatrix();
+   glLoadIdentity();
+   glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0);
+
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+
+   glColor3f(1.0, 0.0, 0.0);
+   glRasterPos2i(10, 10);
+   printstring(GLUT_BITMAP_HELVETICA_18, frbuf);
+   glRasterPos2i(350, 470);
+   printstring(GLUT_BITMAP_HELVETICA_10,
+	       "IperS V1.0 Written by David Bucciarelli (tech.hmw@plus.it)");
+
+   if (help)
+      printhelp();
+
+   glMatrixMode(GL_PROJECTION);
+   glPopMatrix();
+   glMatrixMode(GL_MODELVIEW);
+
+   glutSwapBuffers();
+
+   Frames++;
+   {
+      GLint t = glutGet(GLUT_ELAPSED_TIME);
+      if (t - T0 >= 2000) {
+         GLfloat seconds = (t - T0) / 1000.0;
+         fr = Frames / seconds;
+         T0 = t;
+         Frames = 0;
+      }
+   }
+}
+
+int
+main(int ac, char **av)
+{
+   float fogcolor[4] = { 0.7, 0.7, 0.7, 1.0 };
+
+   fprintf(stderr,
+	   "IperS V1.0\nWritten by David Bucciarelli (tech.hmw@plus.it)\n");
+
+   glutInitWindowPosition(0, 0);
+   glutInitWindowSize(WIDTH, HEIGHT);
+   glutInit(&ac, av);
+
+   glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
+
+   if (!(win = glutCreateWindow("IperS"))) {
+      fprintf(stderr, "Error, couldn't open window\n");
+      exit(-1);
+   }
+
+   reshape(WIDTH, HEIGHT);
+
+   glShadeModel(GL_SMOOTH);
+   glEnable(GL_DEPTH_TEST);
+   glEnable(GL_CULL_FACE);
+   glEnable(GL_TEXTURE_2D);
+
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+   glEnable(GL_FOG);
+   glFogi(GL_FOG_MODE, GL_EXP2);
+   glFogfv(GL_FOG_COLOR, fogcolor);
+
+   glFogf(GL_FOG_DENSITY, 0.006);
+
+   glHint(GL_FOG_HINT, GL_NICEST);
+
+   inittextures();
+   initdlists();
+   initlight();
+
+   glClearColor(fogcolor[0], fogcolor[1], fogcolor[2], fogcolor[3]);
+   glClear(GL_COLOR_BUFFER_BIT);
+
+   calcposobs();
+
+   glutReshapeFunc(reshape);
+   glutDisplayFunc(draw);
+   glutKeyboardFunc(key);
+   glutSpecialFunc(special);
+   glutIdleFunc(draw);
+
+   glutMainLoop();
+
+   return 0;
+}