torus.cpp

Go to the documentation of this file.

 
#define GL_GLEXT_PROTOTYPES
 
#include <IL/il.h>
#include <GL/glut.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <Arcball/Arcball.hpp>
 
#define M_PI_ 3.14159265358979323846
#define checkImageWidth 128
#define checkImageHeight 128
#define farPlane (zobs+10*d)
#define frontPlane 1
#define posAng(x) ((x) < 0.0 ? ((x)+TWOPI) : (x))
#define TWOPI (2*M_PI)
#define toRad(x) ((x)*M_PI/180.0)
#define toDeg(x) ((x)*180.0/M_PI)
#define clamp(x) (fmin(fmax((x),0),1))
#define LEN(x,y,z) (sqrt((x)*(x)+(y)*(y)+(z)*(z)))
#define theAxes (2*nObjects)
#define nObjects (sizeof(objNames)/sizeof(char*))
#define scale (0.05*diag)  
 
double zobs = 10.0;
double viewingAngle = 45;
GLuint objects;
double R1 = 1.0;
double R2 = 0.3;
double R3 = 0.5;
int nR1 = 25;
int nR2 = 10;
int drawWire = 0;
int drawNormals = 0;
int applyTexture = 0;
int showAxes = 0;
int showBox = 0;
int backG = 0;
int procImage = 1;
int useArcball = 0;
int spin = 1;
typedef struct _Point {
  double x, y, z;
} Point;
typedef Point _BBOX[2];
 
typedef enum _oType {_torus = 0, _cylinder, _cone, _ellipsoid, _paraboloid, _hyperbolic_paraboloid, _hyperboloid} oType;
 
typedef enum _rAxes {xAxis, yAxis, zAxis} rAxes;
 
rAxes axis = xAxis;
 
GLfloat rotAngle = 2.0;
 
unsigned int delay = 60;
 
GLubyte checkImage[checkImageHeight][checkImageWidth][4];
GLuint texName;
ILuint ilImage;
const char *objNames[] = {"Torus", "Cylinder", "Cone", "Ellipsoid", "Paraboloid", "Hyperbolic Paraboloid", "Hyperboloid"};
_BBOX objBoxes[nObjects];
int OBJECT = _torus;
Arcball arcball;
 
void updateBox(oType index, double x, double y, double z) {
   _BBOX *bbox = objBoxes+index;
 
   (*bbox)[0].x = fmin(x,(*bbox)[0].x);
   (*bbox)[1].x = fmax(x,(*bbox)[1].x);
   (*bbox)[0].y = fmin(y,(*bbox)[0].y);
   (*bbox)[1].y = fmax(y,(*bbox)[1].y);
   (*bbox)[0].z = fmin(z,(*bbox)[0].z);
   (*bbox)[1].z = fmax(z,(*bbox)[1].z);
}
 
double getBoxSize(oType index, double *dx, double *dy, double *dz) {
   _BBOX *bbox = objBoxes+index;
 
   *dx = (*bbox)[1].x - (*bbox)[0].x;
   *dy = (*bbox)[1].y - (*bbox)[0].y;
   *dz = (*bbox)[1].z - (*bbox)[0].z;
 
   return LEN(*dx,*dy,*dz);
}
 
void cone(double h, double r, int vs, int rs, int normals) {
   int i, j, k;
   double z, th, x, y, ln, nx, ny, nz, u;
   double hr = h / r;
 
   double diag;
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_cone,&dx,&dy,&dz);
   }
 
   for (i = 0; i < vs; i++) {
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = 0; j <= rs; j++) {
         for (k = 1; k >= 0; k--) {
            z = h * (i+k) / vs;              
            u = (h-z) / hr; // cone is upside down
            
            th = j * TWOPI / rs;
            x = u * cos(th);
            y = u * sin(th);
 
            nx = x * hr; ny = y * hr; nz = u > 0 ? u : 1; // cone is upside down
            ln = LEN(nx,ny,nz);
            nx /= ln; ny /= ln; nz /= ln;
            th = clamp(th/TWOPI);
 
            glNormal3d(nx, ny, nz); 
            glTexCoord2d(th,z/h); 
            glVertex3d(x, y, z);
            if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z+scale*nz);
            else
               updateBox(_cone, x, y, z);
         }
      }
      glEnd();
   }
}
 
void cylinder(double h, double r, int vs, int rs, int normals) {
   int i, j;
   double z0, z1, th, x, y, ln, nx, ny;
 
   double diag;
 
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_cylinder,&dx,&dy,&dz);
   }
 
   for (i = 0; i < vs; i++) {       // generate stacks
      z0 = h * i / vs;              // stack bottom z
      z1 = h * (i+1) / vs;          // stack top z
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = 0; j <= rs; j++) {   // generate slices
           th = j * TWOPI / rs;     // slice left theta
           x = r * cos(th);
           y = r * sin(th);
 
           ln = LEN(x,y,0);
           nx = x/ln; ny = y/ln;
           th = clamp(th/TWOPI);
 
           glNormal3d(nx, ny, 0); 
           glTexCoord2d(th,z1/h); 
           glVertex3d(x, y, z1);
           if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z1);
           else
               updateBox(_cylinder, x, y, z1);
           glNormal3d(nx, ny, 0); 
           glTexCoord2d(th,z0/h); 
           glVertex3d(x, y, z0);
           if (normals) 
              glVertex3d(x+scale*nx, y+scale*ny, z0);
           else
              updateBox(_cylinder, x, y, z0);
      }
      glEnd();
   }
}
 
void paraboloid(double h, double r, int vs, int rs, int normals) {
   int i, j, k;
   double z, th, x, y, ln, nx, ny, nz, u;
   double hr2 = h/(r*r);
 
   double diag;
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_paraboloid,&dx,&dy,&dz);
   }
 
   for (i = 0; i < vs; i++) {
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = 0; j <= rs; j++) {
         for (k = 1; k >= 0; k--) {
            z = h * (i+k) / vs;              
            u = sqrt((h-z)/hr2); // paraboloid is upside down
 
            th = j * TWOPI / rs;
            x = u * cos(th);
            y = u * sin(th);
 
            nx = 2 * x * hr2; ny = 2 * y * hr2; nz = 1; // paraboloid is upside down
            ln = LEN(nx,ny,nz);
            nx /= ln; ny /= ln; nz /= ln;
            th = clamp(th/TWOPI);
 
            glNormal3d(nx, ny, nz); 
            glTexCoord2d(th,z/h); 
            glVertex3d(x, y, z);
            if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z+scale*nz);
            else
               updateBox(_paraboloid, x, y, z);
         }
      }
      glEnd();
   }
}
 
void hyperboloid(double h, double a, double r, int vs, int rs, int normals) {
   int i, j, k;
   double z, th, x, y, ln, nx, ny, nz, u;
   double c = sqrt( h*h / (4 * (r*r/(a*a) - 1)) );
   if ( r < a ) {
      printf ( "Hyperboloid: r < a -> invalid!\n" );
      return;
   }
 
   double diag;
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_hyperboloid,&dx,&dy,&dz);
   }
   
   for (i = -vs; i < vs; i++) {
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = 0; j <= rs; j++) {
         for (k = 1; k >= 0; k--) {
            z = h * (i+k) / vs;              
            u = z/c;
            u = a * sqrt(1+u*u);
 
            th = j * TWOPI / rs;
            x = u * cos(th);
            y = u * sin(th);
 
            nx = x * c; ny = y * c; nz = -z * a * a / c;
            ln = LEN(nx,ny,nz);
            nx /= ln; ny /= ln; nz /= ln;
            th = clamp(th/TWOPI);
 
            glNormal3d(nx, ny, nz); 
            glTexCoord2d(th,(z+h)/(2*h)); // map [0,1] to [-h,h]
            glVertex3d(x, y, z);
            if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z+scale*nz);
            else
               updateBox(_hyperboloid, x, y, z);
         }
      }
      glEnd();
   }
}
 
void hyperbolic_paraboloid(double w, double h, int ws, int hs, int normals) {
   int i, j, k;
   double u, v,  z, x, y, ln, nx, ny, nz;
 
   double diag;
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_hyperbolic_paraboloid,&dx,&dy,&dz);
   }
  
   for (i = -hs; i < hs; i++) {
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = -ws; j <= ws; j++) {
         for (k = 1; k >= 0; k--) {
            u = j*w/ws;
            v = (i+k)*h/hs;      
 
            x = u;
            y = v;
            z = u*v;
 
            nx = y; ny = x; nz = -1; 
            ln = LEN(nx,ny,nz);
            nx /= ln; ny /= ln; nz /= ln;
 
            glNormal3d(nx, ny, nz); 
            glTexCoord2d((u+w)/(2*w),(v+h)/(2*h)); // map [0,1] to [-h,h]
            glVertex3d(x, y, z);
            if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z+scale*nz);
            else
               updateBox(_hyperbolic_paraboloid, x, y, z);
         }
      }
      glEnd();
   }
}
 
void torus(double r1, double r2, int numc, int numt, int normals) {
   int i, j, k;
   double s, t, x, y, z;
   double u, v, cu, cv, su, sv, nx, ny, nz;
   double ln;
 
   double diag;
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_torus,&dx,&dy,&dz);
   }
 
   for (i = 0; i < numc; i++) {
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = 0; j <= numt; j++) {
         for (k = 1; k >= 0; k--) {
#if 0           
            s = (i + k) % numc + 0.5;
            t = j % numt;
#else
            s = (i + k); 
            t = j;
#endif
            u = t*TWOPI/numt;
            v = s*TWOPI/numc;
 
            cu = cos(u);
            cv = cos(v);
            su = sin(u);
            sv = sin(v);
 
            // (x,y,z) = f(u,v)
            x = (r1 + r2 * cv) * cu;
            y = (r1 + r2 * cv) * su;
            z = r2 * sv;
 
            // df/du x df/dv
            nx = cv * cu;
            ny = cv * su;
            nz = sv;
 
            ln = LEN(nx,ny,nz);
            nx /= ln; ny /= ln; nz /= ln;
 
            u = clamp(u/TWOPI);
            v = clamp(v/TWOPI);
 
            glTexCoord2d(u,v);
 
            glNormal3d(nx, ny, nz);
            glVertex3d(x, y, z);
            if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z+scale*nz);
            else
               updateBox(_torus, x, y, z);
         }
      }
      glEnd();
   }
}
 
void sphere(double r1, double r2, double r3, int numc, int numt, int normals) {
   int i, j, k;
   double s, x, y, z;
   double u, v, cu, cv, su, sv, nx, ny, nz;
   double ln;
 
   double diag;
   if (normals) {
      double dx,dy,dz;
      diag = getBoxSize(_ellipsoid,&dx,&dy,&dz);
   }
 
   for (i = 0; i < numc; i++) {
      glBegin(normals?GL_LINES:GL_QUAD_STRIP);
      for (j = 0; j <= numt; j++) {
         for (k = 1; k >= 0; k--) {
            s = (i + k); 
 
            u = j*TWOPI/numt;
            v = s*M_PI/numc;
 
            cu = cos(u);
            cv = cos(v);
            su = sin(u);
            sv = sin(v);
 
            // (x,y,z) = f(u,v)
            x = r1 * cu * sv;
            y = r2 * su * sv;
            z = r3 * cv;
 
            // df/du x df/dv
            nx = r2*r3*r2*r3 * x;
            ny = r1*r3*r1*r3 * y;
            nz = r1*r2*r1*r2 * z;
 
            ln = LEN(nx,ny,nz);
            nx /= ln; ny /= ln; nz /= ln;
 
            u = clamp(u/TWOPI);
            v = clamp(v/M_PI);
 
            glTexCoord2d(u,v);
 
            glNormal3d(nx, ny, nz);
            glVertex3d(x, y, z);
            if (normals) 
               glVertex3d(x+scale*nx, y+scale*ny, z+scale*nz);
            else
               updateBox(_ellipsoid, x, y, z);
         }
      }
      glEnd();
   }
}
 
void drawAxes (double r1, double r2) {
   double d;
   d = r1+r2;
   glBegin(GL_LINES);
      glColor3d(1.0,0.0,0.0);
      glVertex3d(0.0,0.0,0.0);
      glVertex3d(d,0.0,0.0);
      glColor3d(0.0,1.0,0.0);
      glVertex3d(0.0,0.0,0.0);
      glVertex3d(0.0,d,0.0);
      glColor3d(0.0,0.0,1.0);
      glVertex3d(0.0,0.0,0.0);
      glVertex3d(0.0,0.0,d);
   glEnd();
}
 
void drawBox (const _BBOX BBOX) {
    // glPushAttrib is done to return everything to normal after drawing
    glPushAttrib(GL_ENABLE_BIT);
    glLineStipple(3, 0xAAAA);  // [1]
    glEnable(GL_LINE_STIPPLE);
 
    glBegin(GL_LINE_LOOP);
    glColor3d(1.0,1.0,1.0);
    glVertex3d(BBOX[0].x, BBOX[0].y, BBOX[0].z);
    glVertex3d(BBOX[1].x, BBOX[0].y, BBOX[0].z);
    glVertex3d(BBOX[1].x, BBOX[1].y, BBOX[0].z);
    glVertex3d(BBOX[0].x, BBOX[1].y, BBOX[0].z);
    glEnd();
 
    glBegin(GL_LINE_LOOP);
    glVertex3d(BBOX[0].x, BBOX[0].y, BBOX[1].z);
    glVertex3d(BBOX[1].x, BBOX[0].y, BBOX[1].z);
    glVertex3d(BBOX[1].x, BBOX[1].y, BBOX[1].z);
    glVertex3d(BBOX[0].x, BBOX[1].y, BBOX[1].z);
    glEnd();
 
    glBegin(GL_LINE_LOOP);
    glVertex3d(BBOX[0].x, BBOX[0].y, BBOX[0].z);
    glVertex3d(BBOX[1].x, BBOX[0].y, BBOX[0].z);
    glVertex3d(BBOX[1].x, BBOX[0].y, BBOX[1].z);
    glVertex3d(BBOX[0].x, BBOX[0].y, BBOX[1].z);
    glEnd();
 
    glBegin(GL_LINE_LOOP);
    glVertex3d(BBOX[0].x, BBOX[1].y, BBOX[0].z);
    glVertex3d(BBOX[1].x, BBOX[1].y, BBOX[0].z);
    glVertex3d(BBOX[1].x, BBOX[1].y, BBOX[1].z);
    glVertex3d(BBOX[0].x, BBOX[1].y, BBOX[1].z);
    glEnd();
 
    glPopAttrib();
}
 
void makeCheckImage(void) {
   int i, j, c;
 
   for (i = 0; i < checkImageHeight; i++) {
      for (j = 0; j < checkImageWidth; j++) {
         // (i and 1000) xor (j and 1000)
         c = ( (i&0x8)==0 ) ^ ( (j&0x8)==0 );
         c *= 255;
         if ( (i&0x8)==0 ) {
            checkImage[i][j][0] = (GLubyte) fmax(c,255);  // red
            checkImage[i][j][1] = (GLubyte) c;            // green
         } else {
            checkImage[i][j][0] = (GLubyte) c;            // red
            checkImage[i][j][1] = (GLubyte) fmax(c,128);  // green
         }
         checkImage[i][j][2] = (GLubyte) c;               // blue
         checkImage[i][j][3] = (GLubyte) 255;             // alpha
      }
   }
}
 
int loadImage (const char *filename) {
    ILuint    imageName;
 
    ilGenImages(1, &imageName);    // load just one image
    ilBindImage(imageName);        // set image name as the current image in DevIL
 
    // load image filename using DevIL
    if ( !ilLoadImage(filename) )
         return -1;
 
    // convert every colour component to unsigned byte
    // one can replace IL_RGB with IL_RGBA if the image contains alpha channel
    if ( !ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE) )
         return -1;
 
    return imageName;
}
 
void initTexture(void) {
   // Create a checkerboard, by using a procedural texture: red, green and white.
   makeCheckImage();
 
   // UNSIGNED_BYTE requires one byte alignment.
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
   // Create a single texture and save its name as texName.
   glGenTextures(1, &texName);
   // Set texName as the current texture.
   glBindTexture(GL_TEXTURE_2D, texName);
   // Specifies a texture environment. 
   // GL_DECAL ignores the primary color and just shows the texel.
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   // GL_TEXTURE_MIN_FILTER is used whenever a surface is rendered with 
   // smaller dimensions than its corresponding texture bitmap (far away objects). 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
   // GL_TEXTURE_MAG_FILTER is used in the exact opposite case: 
   // a surface is bigger than the texture being applied (near objects)
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
   if ( procImage ) {
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight, 
                0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
   } else {
 
      glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),
                0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData());
   }
 
   // Mipmap only makes sense for the MIN_FILTER.
   glGenerateMipmap(GL_TEXTURE_2D); // allocate the mipmaps, after texture is created.
}
 
 
void init(void) {
   glEnable(GL_DEPTH_TEST);
   // Depth value used when the depth buffer is cleared. 
   glClearDepth(1.0);
   // Gouraud shading.
   glShadeModel (GL_SMOOTH);
   // Background color.
   glClearColor(1.0, 250/255.0, 205/255.0, 0.0);
   //glEnable(GL_NORMALIZE);
   glEnable(GL_RESCALE_NORMAL);
   // Disable clipping against near and far planes.
   glDisable(GL_DEPTH_CLAMP);
 
   // Create light components
   GLfloat global_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
   GLfloat ambient[] = { 0.05, 0.05, 0.05 };
   // diffuse light color
   GLfloat diffuseLight[] = { 0.8, 0.8, 0.8, 1.0 };
   // specular light color
   GLfloat specular[] = {1.0, 1.0, 1.0 , 1.0};
 
   // Gold color: OpenGL/VRML Materials
   // ambient material color
   GLfloat mAmbientB[] = {0.24725,0.1995,0.0745,1.0}; 
   // diffuse material color
   GLfloat mDiffuseLightB[] = {0.75164,0.60648,0.22648,1.0}; 
   // specular material color
   GLfloat mSpecularB[] = {0.628281,0.555802,0.366065, 1.0}; 
   // set the shininess of the material
   GLfloat mShininessB = 0.4; 
 
   // Cooper color: OpenGL/VRML Materials
   // ambient material color
   GLfloat mAmbient[] = {0.19125,0.0735,0.0225,1.0};
   // diffuse material color
   GLfloat mDiffuseLight[] = {0.7038, 0.27048, 0.0828, 1.0};
   // specular material color
   GLfloat mSpecular[] = {0.256777, 0.137622, 0.086014, 1.0};
   // set the shininess of the material
   GLfloat mShininess = 0.1; 
 
   // Assign created components to GL_LIGHT0
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient);
   glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
   glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
   glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
   glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
   glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLight);
   glLightfv(GL_LIGHT1, GL_SPECULAR, specular);
   glLightfv(GL_LIGHT2, GL_AMBIENT, ambient);
   glLightfv(GL_LIGHT2, GL_DIFFUSE, diffuseLight);
   glLightfv(GL_LIGHT2, GL_SPECULAR, specular);
 
   // It's a 4D vector. If w=1, then it's a positional light source. 
   // If w=0, it's a directional light source. 
   GLfloat positionZ[] = {0.0,0.0,zobs,1.0};
   GLfloat positionY[] = {0.0,1.0,0.0,0.0};
   GLfloat positionX[] = {1.0,0.0,0.0,0.0};
   glLightfv(GL_LIGHT0, GL_POSITION, positionZ);
   glLightfv(GL_LIGHT1, GL_POSITION, positionY);
   glLightfv(GL_LIGHT2, GL_POSITION, positionX);
 
   // mcolor will be applied to both ambient and diffuse components of the material.
   // This is done for convenience because in most cases Ambient and Diffuse properties
   // of a material should be set to the same color.
#if 0
   GLfloat mcolor[] = { 1.0, 0.0, 0.0, 1.0 };
   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mcolor);
#endif
 
   glMaterialfv(GL_FRONT, GL_AMBIENT, mAmbient);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mDiffuseLight);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mSpecular);
   glMaterialf(GL_FRONT, GL_SHININESS, mShininess*128);
 
   glMaterialfv(GL_BACK, GL_AMBIENT, mAmbientB);
   glMaterialfv(GL_BACK, GL_DIFFUSE, mDiffuseLightB);
   glMaterialfv(GL_BACK, GL_SPECULAR, mSpecularB);
   glMaterialf(GL_BACK, GL_SHININESS, mShininessB*128);
 
   glEnable (GL_LIGHT0);
   glEnable (GL_LIGHT1);
   glEnable (GL_LIGHT2);
   glEnable (GL_LIGHTING);
   // Whether one- or two-sided lighting calculations are done for polygons.
   // It has no effect on the lighting calculations for points, lines, or bitmaps.
   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
#if 0
   // enable color tracking (specify material properties by merely calling the glColor)
   glEnable (GL_COLOR_MATERIAL);
   // set material properties which will be assigned by glColor
   glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
#endif
   // specifies the orientation of front-facing polygons. 
   // GL_CW and GL_CCW are accepted. The initial value is GL_CCW.
   glFrontFace(GL_CCW);
   // specifies the function used to compare each incoming pixel depth value 
   // with the depth value present in the depth buffer.
   glDepthFunc(GL_LEQUAL);
   glLineWidth(2.0);
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
   initTexture();
 
   // create 2*nObjects+1 display lists
   objects = glGenLists (theAxes+1);
 
   glNewList(objects, GL_COMPILE);
        glFrontFace(GL_CCW);
        torus(R1, R2, nR2, nR1, 0);
   glEndList();
   glNewList(objects+1, GL_COMPILE);
        glFrontFace(GL_CCW);
        cylinder ( 2*R1, 2*R2, nR2, nR1 , 0 );
   glEndList();
   glNewList(objects+2, GL_COMPILE);
        glFrontFace(GL_CCW);
        cone ( 2*R1, 2*R2, nR2, nR1 , 0 );
   glEndList();
   glNewList(objects+3, GL_COMPILE);
        glFrontFace(GL_CW);
        sphere ( 1.5*R1, 1.5*R2, 1.5*R3, nR2, nR1 , 0 );
   glEndList();
   glNewList(objects+4, GL_COMPILE);
        glFrontFace(GL_CCW);
        paraboloid ( 2*R1, 2*R2, nR2, nR1 , 0 );
   glEndList();
   glNewList(objects+5, GL_COMPILE);
        glFrontFace(GL_CW);
        hyperbolic_paraboloid ( 2*R1, 2*R1, nR1/2, nR1/2, 0 );
   glEndList();
   glNewList(objects+6, GL_COMPILE);
        glFrontFace(GL_CCW);
        hyperboloid ( R1, R2, R3, nR1/3, nR2, 0 );
   glEndList();
   glNewList(objects+7, GL_COMPILE);
        torus(R1, R2, nR2, nR1, 1);
   glEndList();
   glNewList(objects+8, GL_COMPILE);
        cylinder ( 2*R1, 2*R2, nR2, nR1, 1 );
   glEndList();
   glNewList(objects+9, GL_COMPILE);
        cone ( 2*R1, 2*R2, nR2, nR1, 1 );
   glEndList();
   glNewList(objects+10, GL_COMPILE);
        sphere ( 1.5*R1, 1.5*R2, 1.5*R3, nR2, nR1, 1 );
   glEndList();
   glNewList(objects+11, GL_COMPILE);
        paraboloid ( 2*R1, 2*R2, nR2, nR1, 1 );
   glEndList();
   glNewList(objects+12, GL_COMPILE);
        hyperbolic_paraboloid ( 2*R1, 2*R1, nR1/2, nR1/2, 1 );
   glEndList();
   glNewList(objects+13, GL_COMPILE);
        hyperboloid ( R1, R2, R3, nR1/3, nR2, 1 );
   glEndList();
   glNewList(objects+14, GL_COMPILE);
        drawAxes ( R1, R2 );
   glEndList();
}
 
void display(void) {
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
   if (useArcball) {
      // Apply arcball transformation. 
      glMatrixMode (GL_MODELVIEW);
      glLoadIdentity();
      gluLookAt(0, 0, zobs, 0, 0, 0, 0, 1, 0);
      arcball.applyRotationMatrix();
   } else {
      if ( spin ) 
        switch (axis) {
           case xAxis:
             glRotatef(rotAngle, 1.0,0.0,0.0);
             break;
           case yAxis:
             glRotatef(rotAngle,0.0,1.0,0.0);
             break;
           case zAxis:
             glRotatef(rotAngle,0.0,0.0,1.0);
             break;
           default:
             ;
        }
   }
 
   if ( showAxes ) {
      glDisable (GL_LIGHTING);
      glCallList(objects+theAxes);
      glEnable (GL_LIGHTING);
   }
   if ( showBox ) {
      glDisable (GL_LIGHTING);
      drawBox(objBoxes[OBJECT]);
      glEnable (GL_LIGHTING);
   }
   if ( drawWire ) {
      glColor3d (0.8, 0.8, 0.0);
      glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
   } else {
      glColor3d (1.0, 1.0, 1.0);
      glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
      if ( applyTexture ) {
           glEnable(GL_TEXTURE_2D);
      }
   }
 
   glCallList(objects+OBJECT);
   glDisable(GL_TEXTURE_2D);
 
   glColor3d (1.0, 1.0, 1.0);
   if (drawNormals) glCallList(objects+OBJECT+nObjects);
 
   glutSwapBuffers();
}
 
int dateNow() {
   struct timeval tp;
   gettimeofday(&tp, NULL);
   int ms = tp.tv_sec * 1000 + tp.tv_usec / 1000;
   return ms;
}
 
void _timer(int value) {
   // Previous time.
   static int previousTimeStamp = dateNow();
   // Frames per second.
   static int numberOfFramesForFPS = 0;
   // Current time.
   int currentTime;
 
   // How many times we've been here in one second.
   currentTime = dateNow();
   if ( fabs(currentTime - previousTimeStamp) >= 1000 ) {
       if ( numberOfFramesForFPS > 60 ) delay *= 2;
       else if ( numberOfFramesForFPS < 30 ) delay /= 2;
       printf("\rfps = %d, delay = %d", numberOfFramesForFPS, delay);
       fflush(stdout);
       numberOfFramesForFPS = 0;
       previousTimeStamp = currentTime;
   }
   
   numberOfFramesForFPS++;
 
   // send redisplay event
   glutPostRedisplay();
 
   // call this function again in delay milliseconds
   glutTimerFunc(delay, _timer, value);
}
 
void reshape(int w, int h) {
   double d, dx, dy, dz;
   d = getBoxSize((oType)OBJECT, &dx, &dy, &dz);
 
   // Set the viewport to be the entire window
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
#if 0
   // set camera angle to fit object
   viewingAngle = 2.0 * atan2(d*0.8,zobs);
   viewingAngle = toDeg(viewingAngle);
#endif
   gluPerspective(viewingAngle, (GLfloat)w/h, frontPlane, farPlane);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
#if 1
   // set camera position to fit object
   zobs = d * 0.8 / tan(toRad(viewingAngle*0.5));
#endif
   gluLookAt(0, 0, zobs, 0, 0, 0, 0, 1, 0);
   arcball.setWidthHeight(w, h);
}
 
void keyboard(unsigned char key, int x, int y) {
   switch (key) {
   case 'a':
   case 'A':
      showAxes = !showAxes;
      glutPostRedisplay();
      break;
   case 'b':
   case 'B':
      showBox = !showBox;
      glutPostRedisplay();
      break;
   case 'g':
   case 'G':
      backG = !backG;
      if ( backG)
           glClearColor(0.0, 0.0, 0.0, 0.0);
      else
           glClearColor(1.0, 250/255.0, 205/255.0, 0.0);
      glutPostRedisplay();
      break;
   case 'x':
   case 'X':
      if (!spin) { 
         glRotatef(rotAngle,1.0,0.0,0.0);
         glutPostRedisplay();
      }
      axis = xAxis;
      break;
   case 'y':
   case 'Y':
      if (!spin) {
         glRotatef(rotAngle,0.0,1.0,0.0);
         glutPostRedisplay();
      }
      axis = yAxis;
      break;
   case 'z':
   case 'Z':
      if (!spin) {
         glRotatef(rotAngle,0.0,0.0,1.0);
         glutPostRedisplay();
      }
      axis = zAxis;
      break;
   case 'i':
   case 'I':
      glLoadIdentity();
      gluLookAt(0, 0, zobs, 0, 0, 0, 0, 1, 0);
      axis = xAxis;
      arcball.reset();
      glutPostRedisplay();
      break;
   case 'w':
   case 'W':
      drawWire = !drawWire;
      glutPostRedisplay();
      break;
   case 'n':
   case 'N':
      drawNormals = !drawNormals;
      glutPostRedisplay();
      break;
   case 'o':
   case 'O':
      ++OBJECT;
      OBJECT %= nObjects;
      goto code;
   case '1':
   case '2':
   case '3':
   case '4':
   case '5':
   case '6':
   case '7':
      OBJECT = key - '0' - 1;
      code:
      glutSetWindowTitle(objNames[OBJECT]);
      GLint viewport[4];
      glGetIntegerv(GL_VIEWPORT, viewport);
      reshape(viewport[2], viewport[3]);
      glutPostRedisplay();
      break;
   case 'r':
   case 'R':
      useArcball = !useArcball;
      if (useArcball) {
          GLMatrix model; 
          glGetFloatv(GL_MODELVIEW_MATRIX, model);
          arcball.setViewMatrix(model);
      }
      glutPostRedisplay();
      break;
   case 's':
   case 'S':
      spin = !spin;
      rotAngle = spin ? 2 : 30; 
      glutPostRedisplay();
      break;
   case 't':
   case 'T':
      applyTexture = !applyTexture;
      glutPostRedisplay();
      break;
   case 'p':
   case 'P':
      procImage = !procImage;
      // Delete the current texture, so it can be recreated.
      glDeleteTextures(1, &texName);
      initTexture();
      glutPostRedisplay();
      break;
   case 'h':
   case 'H':
      printf ( "a, A: Draw Axes.\n"); 
      printf ( "b, B: Draw Box.\n"); 
      printf ( "g, G: Change background color.\n"); 
      printf ( "x, X: Rotate about x-axis.\n"); 
      printf ( "y, Y: Rotate about y-axis.\n"); 
      printf ( "z, Z: Rotate about z-axis.\n"); 
      printf ( "w, W: Toggle wireframe view.\n");
      printf ( "i, I: Return object to initial position.\n");
      printf ( "n, N: Toggle normal display.\n");
      printf ( "o, O: Increment object display: Torus -> Cylinder -> Cone -> Sphere -> Paraboloid -> Hyperbolic Paraboloid -> Hyperboloid.\n");
      printf ( "1,2,3,4,5,6,7: Display the ith object.\n");
      printf ( "t, T: Apply texture.\n");
      printf ( "p, P: Procedural x Image Texture.\n");
      printf ( "r, R: Euler angles x Arcball.\n");
      printf ( "s, S: Toggle spin.\n");
      printf ( "h, H: Display help.\n");
      printf ( "Esc: Exit.\n");
      break;
   case 27:
      ilDeleteImages(1, &ilImage);
      printf("\n");
      exit(0);
      break;
   }
}
 
void mouseFunc(int state, int button, int _x , int _y) {
 
   if (!useArcball) return;
 
   if ( button == GLUT_LEFT_BUTTON )
       arcball.startRotation(_x,_y);
   else
       arcball.stopRotation();
 
 
   glutPostRedisplay();
 }
 
void mouseDrag(int _x, int _y) {
   if (!useArcball) return;
   arcball.updateRotation(_x,_y);
   glutPostRedisplay();
}
 
int main(int argc, char **argv) {
   char image[256];
   glutInitWindowSize(512, 512);
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   glutCreateWindow(argv[0]);
   memset(image, '\0', sizeof(image));
   strncpy(image,"velazquez_texture_256.jpg", sizeof(image));
   if ( argc > 5 ) {
      sscanf(argv[1], "%lf", &R1);
      sscanf(argv[2], "%lf", &R2);
      sscanf(argv[3], "%lf", &R3);
      sscanf(argv[4], "%d", &nR1);
      sscanf(argv[5], "%d", &nR2);
      if ( argc > 6 ) strncpy(image, argv[6], sizeof(image));
   } else {
      printf ( "R1 = %lf\n", R1 );
      printf ( "R2 = %lf\n", R2 );
      printf ( "R3 = %lf\n", R3 );
      printf ( "nR1 = %d\n", nR1 );
      printf ( "nR2 = %d\n", nR2 );
      printf ( "Texture = %s\n", image );
   }       
 
   ilInit();
   // load the file image with DevIL
   if ( (ilImage=loadImage(image)) == -1 ) {
        printf ("Can't load image file %s using DevIL \n", image);
        return -1;
    }
 
   init();
   arcball = Arcball();
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMouseFunc(mouseFunc);
   glutMotionFunc(mouseDrag);
   glutTimerFunc(delay, _timer, 0);
   glutDisplayFunc(display);
   display();
   glutMainLoop();
   return 0;
}