#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <GL/glut.h>
#include "skyvision.h"

/*
   Experiment with skyvision projections
*/

/* Flags */
int debug = FALSE;
int windowdump = FALSE;
int showconstruction = FALSE;

int currentbutton = -1;
double rotatespeed = 1;
double dtheta = 1;
CAMERA camera;
XYZ origin = {0.0,0.0,0.0};
double cuberange = 1.5;

PIXELA thetex[5][512][512];

#define FLAT   1
#define ANGLE  2
#define SHARP  3
int facemode = ANGLE;

#define MESH   1
#define CUBE   2
#define SPHERE 3
#define RANDOM 4
int modeltype = SPHERE;

#define FRONT  1
#define RIGHT  2
#define LEFT   3
#define TOP    4
#define BOTTOM 5
#define ALL    6
int viewtype = ALL;

int main(int argc,char **argv)
{
   int i;
   int mainmenu,modelmenu,viewmenu,facemenu;

   /* Parse the command line arguments */
   for (i=1;i<argc;i++) {
      if (strcmp(argv[i],"-h") == 0) 
         GiveUsage(argv[0]);
      if (strcmp(argv[i],"-d") == 0)
         debug = TRUE;
      if (strcmp(argv[i],"-c") == 0)
         showconstruction = TRUE;
   }

   /* Set things up and go */
   glutInit(&argc,argv);
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

   glutCreateWindow("SkyVision model");
   camera.screenwidth = 512;
   camera.screenheight = 512;
   glutReshapeWindow(camera.screenwidth,camera.screenheight);
   glutDisplayFunc(HandleDisplay);
   glutReshapeFunc(HandleReshape);
   glutVisibilityFunc(HandleVisibility);
   glutKeyboardFunc(HandleKeyboard);
   glutSpecialFunc(HandleSpecialKeyboard);
   glutMouseFunc(HandleMouse);
   glutMotionFunc(HandleMouseMotion);
   glutSetCursor(GLUT_CURSOR_NONE);
   CreateEnvironment();
   CameraHome(0);

   /* Set up the face mode menu */
   facemenu = glutCreateMenu(HandleFaceMenu);
   glutAddMenuEntry("Flat (0 degrees)",FLAT);
   glutAddMenuEntry("Angle (30 degrees)",ANGLE);
   glutAddMenuEntry("Cube (90 degrees)",SHARP);

   /* Set up the model menu */
   modelmenu = glutCreateMenu(HandleModelMenu);
   glutAddMenuEntry("Mesh",MESH);
   glutAddMenuEntry("Cube",CUBE);
   glutAddMenuEntry("Sphere",SPHERE);
   glutAddMenuEntry("Random",RANDOM);

   /* Set up the view menu */
   viewmenu = glutCreateMenu(HandleViewMenu);
   glutAddMenuEntry("Front",1);
   glutAddMenuEntry("Right",2);
   glutAddMenuEntry("Left",3);
   glutAddMenuEntry("Top",4);
   glutAddMenuEntry("Bottom",5);
   glutAddMenuEntry("Skyview",6);

   /* Set up the main menu */
   mainmenu = glutCreateMenu(HandleMainMenu);
   glutAddSubMenu("Model",modelmenu);
   glutAddSubMenu("View",viewmenu);
   glutAddSubMenu("Face angle",facemenu);
   glutAddMenuEntry("Quit",9);
   glutAttachMenu(GLUT_RIGHT_BUTTON);

   /* Ready to go! */
   glutMainLoop();
   return(0);
}

/*
   This is where global OpenGL/GLUT settings are made, 
   that is, things that will not change in time 
*/
void CreateEnvironment(void)
{
   glEnable(GL_DEPTH_TEST);
   glDisable(GL_LINE_SMOOTH);
   glDisable(GL_POINT_SMOOTH);
   glDisable(GL_POLYGON_SMOOTH); 
   glDisable(GL_DITHER);
   glDisable(GL_CULL_FACE);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
   glLineWidth(1.0);
   glPointSize(1.0);
   glFrontFace(GL_CW);
   glClearColor(0.0,0.0,0.0,0.0);
   glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
}

/*
   This is the basic display callback routine
   Render the scene 5 times and map the textures onto a split cube
   The faces are ordered "front, right, left, top, bottom"
*/
void HandleDisplay(void)
{
   int i,j,iview;
   double delta;
   XYZ n,p1,p2;
   CAMERA oldcamera;
   unsigned int textureid[5];
   GLfloat white[4] = {1.0,1.0,1.0,1.0};
   XYZ f[20];
   XYZ faces1[20] = {   /* Split sides */
      -1,  -1,   1,   1,  -1,   1,    1,  1,  1,    -1,  1,  1, 
       1,  -1,   1,   1.5,-1,  -1,    1.5,1, -1,     1,  1,  1,
      -1.5,-1,  -1,  -1,  -1,   1,   -1,  1,  1,    -1.5,1, -1,
      -1,   1,   1,   1,   1,   1,    1,  1.5,-1,   -1,  1.5,-1,
      -1,  -1.5,-1,   1,  -1.5,-1,    1, -1,  1,    -1, -1,  1 
   };
   XYZ faces2[20] = {   /* Normal box */
      -1,  -1,   1,   1,  -1,   1,    1,  1,  1,    -1,  1,  1,
       1,  -1,   1,   1,  -1,  -1,    1,  1, -1,     1,  1,  1,
      -1,  -1,  -1,  -1,  -1,   1,   -1,  1,  1,    -1,  1, -1,
      -1,   1,   1,   1,   1,   1,    1,  1, -1,    -1,  1, -1,
      -1,  -1,  -1,   1,  -1,  -1,    1, -1,  1,    -1, -1,  1
   };
   XYZ faces3[20] = {   /* Flat sides */
      -1,  -1,   1,   1,  -1,   1,    1,  1,  1,    -1,  1,  1,
       1,  -1,   1,   3,  -1,   1,    3,  1,  1,     1,  1,  1,
      -3,  -1,   1,  -1,  -1,   1,   -1,  1,  1,    -3,  1,  1,
      -1,   1,   1,   1,   1,   1,    1,  3,  1,    -1,  3,  1,
      -1,  -3,   1,   1,  -3,   1,    1, -1,  1,    -1, -1,  1
   };

   delta = 2.0/512.0;
   glGenTextures(5,textureid);

   /* Copy the appropriate mapping geometry */
   for (i=0;i<20;i++) {
      switch (facemode) {
      case FLAT:
         f[i] = faces3[i];
         break;
      case ANGLE:
         f[i] = faces1[i];
         break;
      case SHARP:
         f[i] = faces2[i];
         break;
      }
   }

   for (iview=0;iview<5;iview++) {
      oldcamera = camera;
      CameraHome(iview+1);

      glDrawBuffer(GL_BACK);
      glClearColor(0.0,0.0,0.0,0.0);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluPerspective(90.0,1.0,0.1,1000.0);
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
      gluLookAt(camera.vp.x,camera.vp.y,camera.vp.z,
                camera.focus.x,camera.focus.y,camera.focus.z,
                camera.vu.x,camera.vu.y,camera.vu.z);

      MakeLighting();
      glShadeModel(GL_SMOOTH);
      glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
      switch (modeltype) {
      case MESH:
           MakeMesh();
         break;
      case CUBE:
         MakeCube();
         break;
      case SPHERE:
         CreateSphere(origin,100.0,32);
         break;
      case RANDOM:
         MakeRandom();
         break;
      }
      glFlush();

      glReadPixels(0,0,camera.screenwidth,camera.screenheight,
         GL_RGBA,GL_UNSIGNED_BYTE,thetex[iview]);

      glBindTexture(GL_TEXTURE_2D,textureid[iview]);
      glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
      glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); 
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
      glTexImage2D(GL_TEXTURE_2D,0,4,
         camera.screenwidth,camera.screenheight,
         0,GL_RGBA,GL_UNSIGNED_BYTE,thetex[iview]);
      glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
   
      camera = oldcamera;

      if (viewtype == iview+1) 
         break;
   }

   if (viewtype == ALL) {

      /* We now have all the textures, draw the "real" scene */
      glDrawBuffer(GL_BACK);
      glClearColor(0.5,0.5,1.0,0.0);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glLineWidth(1.0);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluPerspective(camera.aperture,1.0,0.1,1000.0);
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
      gluLookAt(0.0,0.0,-cuberange,   0.0,0.0,0.0,   0.0,1.0,0.0);
   
      glDisable(GL_LIGHTING);
      glShadeModel(GL_FLAT);
      glLightModelfv(GL_LIGHT_MODEL_AMBIENT,white);
      glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);

      for (iview=0;iview<5;iview++) {
      
         /* Draw borders in construction mode */
         if (showconstruction) {
            glColor3f(1.0,0.0,0.0);
            glBegin(GL_LINE_LOOP);
            for (i=0;i<4;i++)
               glVertex3f(f[iview*4+i].x,f[iview*4+i].y,f[iview*4+i].z);
            glEnd();
         }

         glEnable(GL_TEXTURE_2D);
         glBindTexture(GL_TEXTURE_2D,textureid[iview]);
         glColor3f(1.0,1.0,1.0);
         n = CalcNormal(f[iview*4],f[iview*4+1],f[iview*4+2]);
         glNormal3f(n.x,n.y,n.z);
         glBegin(GL_QUADS);
         glTexCoord2f(0.0+delta,0.0+delta);
         glVertex3f(f[iview*4+0].x,f[iview*4+0].y,f[iview*4+0].z);
         glTexCoord2f(1.0-delta,0.0+delta);
         glVertex3f(f[iview*4+1].x,f[iview*4+1].y,f[iview*4+1].z);
         glTexCoord2f(1.0-delta,1.0-delta);
         glVertex3f(f[iview*4+2].x,f[iview*4+2].y,f[iview*4+2].z);
         glTexCoord2f(0.0+delta,1.0-delta);
         glVertex3f(f[iview*4+3].x,f[iview*4+3].y,f[iview*4+3].z);
         glEnd();
         glDisable(GL_TEXTURE_2D);
      }

      /* Draw construction lines */
      if (showconstruction) {
         glDisable(GL_DEPTH_TEST);

         /* Draw 50% lines */
         glColor3f(0.0,1.0,0.0);
         glBegin(GL_LINES);
         iview = RIGHT-1;
         p1 = MidPoint(f[iview*4+0],f[iview*4+1]);
         p2 = MidPoint(f[iview*4+2],f[iview*4+3]);
         glVertex3f(p1.x,p1.y,p1.z);
         glVertex3f(p2.x,p2.y,p2.z);
         iview = LEFT-1;
         p1 = MidPoint(f[iview*4+0],f[iview*4+1]);
         p2 = MidPoint(f[iview*4+2],f[iview*4+3]);
         glVertex3f(p1.x,p1.y,p1.z);
         glVertex3f(p2.x,p2.y,p2.z);
         iview = TOP-1;
         p1 = MidPoint(f[iview*4+0],f[iview*4+3]);
         p2 = MidPoint(f[iview*4+1],f[iview*4+2]);
         glVertex3f(p1.x,p1.y,p1.z);
         glVertex3f(p2.x,p2.y,p2.z);
         iview = BOTTOM-1;
         p1 = MidPoint(f[iview*4+0],f[iview*4+3]);
         p2 = MidPoint(f[iview*4+1],f[iview*4+2]);
         glVertex3f(p1.x,p1.y,p1.z);
         glVertex3f(p2.x,p2.y,p2.z);
         glEnd();

         /* Draw face borders */
         for (iview=0;iview<5;iview++) {
            glColor3f(1.0,0.0,0.0);
            glBegin(GL_LINE_LOOP);
            for (i=0;i<4;i++)
               glVertex3f(f[iview*4+i].x,f[iview*4+i].y,f[iview*4+i].z);
            glEnd();
         }

         glEnable(GL_DEPTH_TEST);
      }

   }

   /* Save the image */
   if (windowdump) {
      WindowDump(camera.screenwidth,camera.screenheight);
      windowdump = FALSE;
   }

   /* Finally ready to view the image */
   glutSwapBuffers();

   glDeleteTextures(5,textureid);
}

/*
   Create the grometry for the mesh
*/
void MakeMesh(void)
{
   int i,j,n=5,w=100;
   COLOUR colour;
   double wmax;

   glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
   glLineWidth(3.0);
   wmax = sqrt(w*w+(double)w*w);

   glBegin(GL_LINES);
   for (i=-w;i<=w;i+=n) {
      for (j=-w;j<w;j+=n) {
         colour.r = (i + w) / (2.0 * w);
         colour.g = 1;
         colour.b = (w - j) / (2.0 * w);
         glColor3f(colour.r,colour.g,colour.b);
         glVertex3f(0.0,(double)i,(double)j);
         glVertex3f(0.0,(double)i,(double)j+n);
      }
   }
   for (j=-w;j<=w;j+=n) {
      for (i=-w;i<w;i+=n) {
         colour.r = (i + w) / (2.0 * w);
         colour.g = 1;
         colour.b = (w - j) / (2.0 * w);
         glColor3f(colour.r,colour.g,colour.b);
         glVertex3f(0.0,(double)i,(double)j);
         glVertex3f(0.0,(double)i+n,(double)j);
      }
   }
   glEnd();
}

/*
   Create a random star field
*/
void MakeRandom(void)
{
   int i,n=10000;
   double r = 100;
   XYZ p;
   COLOUR colour;

   glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
   glPointSize(3.0);

   srand(12345);

   glBegin(GL_POINTS);
   for (i=0;i<n;i++) {
      p.x = (rand() % 2000 - 1000) / 1000.0;
      p.y = (rand() % 2000 - 1000) / 1000.0;
      p.z = (rand() % 2000 - 1000) / 1000.0;
      Normalise(&p);
      colour.r = (p.x+1)/2;
      colour.g = (p.y+1)/2;
      colour.b = (p.z+1)/2;
      glColor3f(colour.r,colour.g,colour.b);
      glVertex3f(r*p.x,r*p.y,r*p.z);
   }
   glEnd();
}

/*
   Create the geometry for the cube
*/
void MakeCube(void)
{
   int i,n=100,dn=20;
   COLOUR colour;

   glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
   glLineWidth(3.0);

   glBegin(GL_LINES);
   for (i=-n;i<=n;i+=dn) {
      glColor3f(1.0,0.0,0.0);
      glVertex3i(i, n,-n);
      glVertex3i(i, n, n);
      glVertex3i(i,-n,-n);
      glVertex3i(i,-n, n);
      glVertex3i( n,-n,i);
      glVertex3i(-n,-n,i);
      glVertex3i( n, n,i);
      glVertex3i(-n, n,i);
   }
   for (i=-n;i<=n;i+=dn) {
      glColor3f(0.0,1.0,0.0);
      glVertex3i( n,-n,i);
      glVertex3i( n, n,i);
      glVertex3i(-n,-n,i);
      glVertex3i(-n, n,i);
      glVertex3i( n,i, n);
      glVertex3i( n,i,-n);
      glVertex3i(-n,i, n);
      glVertex3i(-n,i,-n);
   }
   for (i=-n;i<=n;i+=dn) {
      glColor3f(0.0,0.0,1.0);
      glVertex3i(i, n, n);
      glVertex3i(i,-n, n);
      glVertex3i(i, n,-n);
      glVertex3i(i,-n,-n);
      glVertex3i( n,i, n);
      glVertex3i(-n,i, n);
      glVertex3i( n,i,-n);
      glVertex3i(-n,i,-n);
   }
   glEnd();
}

/*
   Set up the lighing environment
*/
void MakeLighting(void)
{
   GLfloat fullambient[4] = {1.0,1.0,1.0,1.0};
   GLfloat position[4] = {0.0,0.0,0.0,0.0};
   GLfloat ambient[4]  = {0.2,0.2,0.2,1.0};
   GLfloat diffuse[4]  = {1.0,1.0,1.0,1.0};
   GLfloat specular[4] = {0.0,0.0,0.0,1.0};

   /* Turn off all the lights */
   glDisable(GL_LIGHT0);
   glDisable(GL_LIGHT1);
   glDisable(GL_LIGHT2);
   glDisable(GL_LIGHT3);
   glDisable(GL_LIGHT4);
   glDisable(GL_LIGHT5);
   glDisable(GL_LIGHT6);
   glDisable(GL_LIGHT7);
   glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);
   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_FALSE);

   /* Turn on the appropriate lights */
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT,fullambient);
   glLightfv(GL_LIGHT0,GL_POSITION,position);
   glLightfv(GL_LIGHT0,GL_AMBIENT,ambient);
   glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuse);
   glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
   glEnable(GL_LIGHT0);

   /* Sort out the shading algorithm */
   glShadeModel(GL_SMOOTH);

   /* Turn lighting on */
   glEnable(GL_LIGHTING);
}

/*
   Deal with plain key strokes
*/
void HandleKeyboard(unsigned char key,int x, int y)
{
   double delta = 0.1;

   switch (key) {
   case ESC:                            /* Quit */
   case 'Q':
   case 'q': 
      exit(0); 
      break;
   case 'c':                           /* Toggle construction lines */
   case 'C':
      showconstruction = !showconstruction;
      break;
   case 'h':                           /* Go home     */
   case 'H':
      CameraHome(0);
      break;
   case '[':                           /* Roll anti clockwise */
      RotateCamera(0,0,-1);
      break;
   case ']':                           /* Roll clockwise */
      RotateCamera(0,0,1);
      break;
   case 'i':                           /* Translate camera up */
   case 'I':
      TranslateCamera(0,1);
      break;
   case 'k':                           /* Translate camera down */
   case 'K':
      TranslateCamera(0,-1);
      break;
   case 'j':                           /* Translate camera left */
   case 'J':
      TranslateCamera(-1,0);
      break;
   case 'l':                           /* Translate camera right */
   case 'L':
      TranslateCamera(1,0);
      break;
   case '-':                           /* Move backward */
   case '_':
      cuberange -= delta;
      break;
   case '=':                           /* Move forward */
   case '+':
      cuberange += delta;
      break;
   case 'w':
   case 'W':
      windowdump = TRUE;
      break;
   }
}

/*
   Deal with special key strokes
*/
void HandleSpecialKeyboard(int key,int x, int y)
{
   switch (key) {
   case GLUT_KEY_LEFT:
      RotateCamera(-1,0,0);
      break;
   case GLUT_KEY_RIGHT:
      RotateCamera(1,0,0);
      break;
   case GLUT_KEY_UP:
      RotateCamera(0,1,0);
      break;
   case GLUT_KEY_DOWN:
      RotateCamera(0,-1,0);
      break;
   }
}

/*
   Rotate (ix,iy) or roll (iz) the camera about the focal point
   ix,iy,iz are flags, 0 do nothing, +- 1 rotates in opposite directions
   Correctly updating all camera attributes
*/
void RotateCamera(int ix,int iy,int iz)
{
   XYZ vp,vu,vd;
   XYZ right;
   XYZ newvp,newr;
   double radius,dd,radians;
   double dx,dy,dz;

   vu = camera.vu;
   Normalise(&vu);
   vp = camera.vp;
   vd = camera.vd;
   Normalise(&vd);
   CROSSPROD(vd,vu,right);
   Normalise(&right);
   radians = dtheta * PI / 180.0;

   /* Handle the roll */
   if (iz != 0) {
      camera.vu.x += iz * right.x * radians;
      camera.vu.y += iz * right.y * radians;
      camera.vu.z += iz * right.z * radians;
      Normalise(&camera.vu);
      return;
   }

   /* Distance from the rotate point */
   dx = camera.vp.x - camera.pr.x;
   dy = camera.vp.y - camera.pr.y;
   dz = camera.vp.z - camera.pr.z;
   radius = sqrt(dx*dx + dy*dy + dz*dz);

   /* Determine the new view point */
   dd = radius * radians;
   newvp.x = vp.x + dd * ix * right.x + dd * iy * vu.x - camera.pr.x;
   newvp.y = vp.y + dd * ix * right.y + dd * iy * vu.y - camera.pr.y;
   newvp.z = vp.z + dd * ix * right.z + dd * iy * vu.z - camera.pr.z;
   Normalise(&newvp);
   camera.vp.x = camera.pr.x + radius * newvp.x;
   camera.vp.y = camera.pr.y + radius * newvp.y;
   camera.vp.z = camera.pr.z + radius * newvp.z;

   /* Determine the new right vector */
   newr.x = camera.vp.x + right.x - camera.pr.x;
   newr.y = camera.vp.y + right.y - camera.pr.y;
   newr.z = camera.vp.z + right.z - camera.pr.z;
   Normalise(&newr);
   newr.x = camera.pr.x + radius * newr.x - camera.vp.x;
   newr.y = camera.pr.y + radius * newr.y - camera.vp.y;
   newr.z = camera.pr.z + radius * newr.z - camera.vp.z;

   camera.vd.x = camera.pr.x - camera.vp.x;
   camera.vd.y = camera.pr.y - camera.vp.y;
   camera.vd.z = camera.pr.z - camera.vp.z;
   Normalise(&camera.vd);

   /* Determine the new up vector */
   CROSSPROD(newr,camera.vd,camera.vu);
   Normalise(&camera.vu);

   if (debug)
      fprintf(stderr,"Camera position: (%g,%g,%g)\n",
         camera.vp.x,camera.vp.y,camera.vp.z);
}

/*
   Translate (pan) the camera view point
   In response to i,j,k,l keys
   Also move the camera rotate location in parallel
*/
void TranslateCamera(int ix,int iy)
{
   XYZ vp,vu,vd;
   XYZ right;
   XYZ newvp,newr;
   double radians,delta;

   vu = camera.vu;
   Normalise(&vu);
   vp = camera.vp;
   vd = camera.vd;
   Normalise(&vd);
   CROSSPROD(vd,vu,right);
   Normalise(&right);
   radians = dtheta * PI / 180.0;
   delta = dtheta * camera.focallength / 90.0;

   camera.vp.x += iy * vu.x * delta;
   camera.vp.y += iy * vu.y * delta;
   camera.vp.z += iy * vu.z * delta;
   camera.pr.x += iy * vu.x * delta;
   camera.pr.y += iy * vu.y * delta;
   camera.pr.z += iy * vu.z * delta;

   camera.vp.x += ix * right.x * delta;
   camera.vp.y += ix * right.y * delta;
   camera.vp.z += ix * right.z * delta;
   camera.pr.x += ix * right.x * delta;
   camera.pr.y += ix * right.y * delta;
   camera.pr.z += ix * right.z * delta;
}

/*
   Handle mouse events
   Right button events are passed to menu handlers
*/
void HandleMouse(int button,int state,int x,int y)
{
   if (state == GLUT_DOWN) {
      if (button == GLUT_LEFT_BUTTON) {
         currentbutton = GLUT_LEFT_BUTTON;
      } else if (button == GLUT_MIDDLE_BUTTON) {
         currentbutton = GLUT_MIDDLE_BUTTON;
      } 
   }
}

/*
   Handle the main menu
*/
void HandleMainMenu(int whichone)
{
   switch (whichone) {
   case 9: 
      exit(0); 
      break;
   }
}

/*
   Handle the model menu
*/
void HandleModelMenu(int whichone)
{
   modeltype = whichone; 
}

/*
   Handle the face mode menu
*/
void HandleFaceMenu(int whichone)
{
   facemode = whichone;
}

/*
   Handle the view menu
*/
void HandleViewMenu(int whichone)
{
   viewtype = whichone;
}

/*
   How to handle visibility
*/
void HandleVisibility(int visible)
{
   if (visible == GLUT_VISIBLE)
      HandleTimer(0);
}

/*
   What to do on an timer event
*/
void HandleTimer(int value)
{
   glutPostRedisplay();
   glutTimerFunc(10,HandleTimer,0);
}

/*
   Handle a window reshape/resize
*/
void HandleReshape(int w,int h)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   w = 512;
   h = 512;
   glutReshapeWindow(w,h);
   glViewport(0,0,(GLsizei)w,(GLsizei)h);
   camera.screenwidth = w;
   camera.screenheight = h;
}

/*
   Display the program usage information
*/
void GiveUsage(char *cmd)
{
   fprintf(stderr,"Usage: %s [-h] [-c]\n",cmd);
   fprintf(stderr,"          -h   this text\n");
   fprintf(stderr,"          -c   show construction lines\n");
   fprintf(stderr,"Key Strokes\n");
   fprintf(stderr,"           c   toggle construction lines\n");
   fprintf(stderr,"           q   quit\n");
   fprintf(stderr,"Model space\n");
   fprintf(stderr,"  arrow keys   rotate left/right/up/down\n");
   fprintf(stderr,"  left mouse   rotate left/right/up/down\n");
   fprintf(stderr,"middle mouse   roll clockwise and anticlockwise\n");
   fprintf(stderr,"           i   translate up\n");
   fprintf(stderr,"           k   translate down\n");
   fprintf(stderr,"           j   translate left\n");
   fprintf(stderr,"           l   translate right\n");
   fprintf(stderr,"           [   roll clockwise\n");
   fprintf(stderr,"           ]   roll anti clockwise\n");
   fprintf(stderr,"Projection space\n");
   fprintf(stderr,"         +.-   move camera forward/backwards\n");
   exit(-1);
}

/*
   Move the camera to the home position 
   Or one of 5 set positions
   Or the home position for the final image
*/
void CameraHome(int mode)
{
   XYZ ptmp;

   camera.aperture = 90;
   camera.focallength = 50;

   switch (mode) {
   case 0:
      camera.vp.x =  1; camera.vp.y = 0; camera.vp.z = 0;
      camera.vd.x = -1; camera.vd.y = 0; camera.vd.z = 0;
      camera.vu.x =  0; camera.vu.y = 1; camera.vu.z = 0;
      break;
   case 1: /* Look front */
      break;
   case 2: /* Look right */
      camera.vd = CrossProduct(camera.vd,camera.vu);
      break;
   case 3: /* Look left */
      camera.vd = CrossProduct(camera.vu,camera.vd);
      break;
   case 4: /* Look up */
      ptmp = camera.vu;
      camera.vu.x = -camera.vd.x;
      camera.vu.y = -camera.vd.y;
      camera.vu.z = -camera.vd.z;
      camera.vd = ptmp;
      break;
   case 5: /* Look down */
      ptmp = camera.vu;
      camera.vu = camera.vd;
      camera.vd.x = -ptmp.x;
      camera.vd.y = -ptmp.y;
      camera.vd.z = -ptmp.z;
      break;
   }
   Normalise(&camera.vp);
   camera.vp.x *= camera.focallength;
   camera.vp.y *= camera.focallength;
   camera.vp.z *= camera.focallength;

   camera.eyesep = camera.focallength / 20;
   camera.pr = origin;

   camera.focus.x = camera.vp.x + camera.vd.x;
   camera.focus.y = camera.vp.y + camera.vd.y;
   camera.focus.z = camera.vp.z + camera.vd.z;
}

/*
   Handle mouse motion
*/
void HandleMouseMotion(int x,int y)
{
   static int xlast=-1,ylast=-1;
   int dx,dy;

   dx = x - xlast;
   dy = y - ylast;
   if (dx < 0)      dx = -1;
   else if (dx > 0) dx =  1;
   if (dy < 0)      dy = -1;
   else if (dy > 0) dy =  1;

   if (currentbutton == GLUT_LEFT_BUTTON)
      RotateCamera(-dx,dy,0);
   else if (currentbutton == GLUT_MIDDLE_BUTTON)
      RotateCamera(0,0,dx);

   xlast = x;
   ylast = y;
}

/*
   Normalise a vector
*/
void Normalise(XYZ *p)
{
   double length;

   length = sqrt(p->x * p->x + p->y * p->y + p->z * p->z);
   if (length != 0) {
      p->x /= length;
      p->y /= length;
      p->z /= length;
   } else {
      p->x = 0;
      p->y = 0;
      p->z = 0;
   }
}

XYZ CrossProduct(XYZ p1,XYZ p2)
{
   XYZ p;

   p.x = p1.y * p2.z - p1.z * p2.y;
   p.y = p1.z * p2.x - p1.x * p2.z;
   p.z = p1.x * p2.y - p1.y * p2.x;

   return(p);
}

XYZ CalcNormal(XYZ p,XYZ p1,XYZ p2)
{
   XYZ n,pa,pb;

   pa.x = p1.x - p.x;
   pa.y = p1.y - p.y;
   pa.z = p1.z - p.z;
   pb.x = p2.x - p.x;
   pb.y = p2.y - p.y;
   pb.z = p2.z - p.z;
   Normalise(&pa);
   Normalise(&pb);

   n.x = pa.y * pb.z - pa.z * pb.y;
   n.y = pa.z * pb.x - pa.x * pb.z;
   n.z = pa.x * pb.y - pa.y * pb.x;
   Normalise(&n);

   return(n);
}

void CreateSphere(XYZ c,double r,int n)
{
   int i,j;
   double t1,t2,t3;
   COLOUR colour = {0.0,0.0,0.0};
   XYZ e,p;

   glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
   glLineWidth(3.0);

   for (j=0;j<n/2;j++) {
      t1 = -PID2 + j * PI / (n/2);
      t2 = -PID2 + (j + 1) * PI / (n/2);

      glBegin(GL_QUAD_STRIP);
      colour.r = j / (n/2.0);
      colour.g = 0;
      colour.b = (n/2-j) / (n/2.0);
      glColor3f(colour.r,colour.g,colour.b);

      for (i=0;i<=n;i++) {
         t3 = i * TWOPI / n;

         e.x = cos(t1) * cos(t3);
         e.y = sin(t1);
         e.z = cos(t1) * sin(t3);
         p.x = c.x + r * e.x;
         p.y = c.y + r * e.y;
         p.z = c.z + r * e.z;
         glNormal3f(e.x,e.y,e.z);
         glTexCoord2f(i/(double)n,2*j/(double)n);
         glVertex3f(p.x,p.y,p.z);

         e.x = cos(t2) * cos(t3);
         e.y = sin(t2);
         e.z = cos(t2) * sin(t3);
         p.x = c.x + r * e.x;
         p.y = c.y + r * e.y;
         p.z = c.z + r * e.z;

         glNormal3f(e.x,e.y,e.z);
         glTexCoord2f(i/(double)n,2*(j+1)/(double)n);
         glVertex3f(p.x,p.y,p.z);

      }
      glEnd();
   }
}

XYZ MidPoint(XYZ p1,XYZ p2)
{
   XYZ p;

   p.x = (p1.x + p2.x) / 2;
   p.y = (p1.y + p2.y) / 2;
   p.z = (p1.z + p2.z) / 2;

   return(p);
}

int WindowDump(int width,int height)
{
   int i,j;
   FILE *fptr;
   static int counter = 0;
   int status = TRUE;
   char fname[32];
   char *image;

   /* Allocate our buffer for the image */
   if ((image = malloc(3*width*height*sizeof(char))) == NULL) {
      fprintf(stderr,"WindowDump - Failed to allocate memory for image\n");
      return(FALSE);
   }

   glPixelStorei(GL_PACK_ALIGNMENT,1); /* Just in case */

   sprintf(fname,"skyvision_%04d.ppm",counter++);
   if ((fptr = fopen(fname,"w")) == NULL) {
      fprintf(stderr,"WindowDump - Failed to open file for window dump\n");
      return(FALSE);
   }

   /* Copy the image into our buffer */
   glReadBuffer(GL_BACK);
   glReadPixels(0,0,width,height,GL_RGB,GL_UNSIGNED_BYTE,image);

   /* Write the file */
   fprintf(fptr,"P6\n%d %d\n255\n",width,height);
   if (fwrite(image,3*width*height*sizeof(char),1,fptr) != 1)
      status = FALSE;
   fclose(fptr);

   free(image);
   return(status);
}