// Added the following so that the changes necessary on different
// platforms can be expressed in one place, rather than in 100+ demo
// files.

#ifdef MAC
#include <GLUT/glut.h>
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#endif

// ================================================================
// Errors.  This function is defined in src/tw.cc

// The following function checks whether OpenGL has ignored an error, and
// prints it.  Call it regularly.

void twErrorCheck(char* file, int line);

// The following macro makes it easier to figure out what line noticed the
// error.  Remember that the error could have been caused by any OpenGL
// call since the previous error check.

#define twError() twErrorCheck(__FILE__,__LINE__)

// ================================================================
// tw-utils.cc

/* The following function tries to convert a simple filename such as
   "al.obj" into something that can be opened.  It searches down the
   TWLOADPATH environment variable, which defaults to:

   .:$TWHOMEDIR/textures:$TWHOMEDIR/objects

   until it finds a file that exists.

   It's often a good idea to set TWLOADPATH to
   
   .:$TWHOMEDIR/textures:$TWHOMEDIR/objects:$TWHOMEDIR/f05:$TWHOMEDIR/f06

   If verbose is true, the function reports each load directory it searches.
*/

char* twPathname(const char* filename, bool verbose);

// ================================================================
// tw-messages.cc

const int TW_ALL_MESSAGES  = -1;
const int TW_NO_MESSAGES   = 0;
const int TW_GEOMETRY      = 0x1;
const int TW_BOUNDING_BOX  = 0x2;
const int TW_WINDOW        = 0x4;
const int TW_CAMERA        = 0x8;
const int TW_COLOR         = 0x10;
const int TW_MATERIAL      = 0x20;
const int TW_LIGHTING      = 0x40;
const int TW_FONTS         = 0x80;

// The same syntax and function as printf, only it can be turned on/off
// using twSetMessages.
void twMessage(int messageKind, char* format, ...);

// To turn messages on and off, call this function with some bitwise
// combination of the constants above.
void twSetMessages(int);

// ================================================================

/* The following color names are defined in TW.  You can switch to one of
   these colors using the twColorName function, giving one of the symbols
   below as the argument.  The actual colors are defined in tw-color.cc */

enum twColorName {TW_BLACK,
                  TW_WHITE,
                  TW_YELLOW,
                  TW_ORANGE,
                  TW_MAGENTA,
                  TW_RED,
                  TW_SILVER,
                  TW_GRAY,
                  TW_OLIVE,
                  TW_PURPLE,
                  TW_MAROON,
                  TW_CYAN,
                  TW_TEAL,
                  TW_GREEN,
                  TW_BLUE,
                  TW_DARK_BLUE,
                  TW_LIGHT_BLUE,
                  TW_PINK,
                  TW_BROWN,
                  TW_NUM_COLORS};


// reshaping stuff
typedef enum {LETTERBOX, DISTORT, CLIP} frustumMode_t;

const GLdouble DEFAULT_FOVY = 90.0;

// ================================================================
// Vertices, Points and Vectors
// defined in tw-geometry.cc

// This datatype is just a three place array of floats, so we decided to
// call them triples.  They can be used for points, vectors, colors and
// other things, depending on context.
typedef GLfloat twTriple[3];

void twTripleInit(twTriple v, GLfloat x, GLfloat y, GLfloat z) ;

// prints a vertex to stdout. The first argument can be used to label the
// vertex.
void twTriplePrint(char* name, twTriple v) ;

// copies a vertex components to another vertex.  V is copied to W
void twTripleCopy(twTriple w, twTriple v) ;

// returns the dot product of vector v and vector w.
GLfloat twDot(twTriple v, twTriple w) ;

// returns the cosine of the angle between vector v and vector w.
// does not assume that they are normalized
GLfloat twCosAngle(twTriple v, twTriple w) ;

// returns the length of the vector v
GLfloat twVectorLength(twTriple v) ;

// creates vector v as a scalar multiple of w, multiplying each component
// by k.  It's safe to have v be the same object as w.
GLfloat twVectorScale(twTriple v, twTriple w, GLfloat k) ;

// modifies the vector to be of unit length.  Returns with v unmodified if
// v is the zero vector.
void twVectorNormalize(twTriple v) ;

// computes u=v x w, the cross product of vectors v and w, in that order
void twCrossProduct(twTriple u, twTriple v, twTriple w) ;

// computes v=A-B, the vector from point B to point A
void twVector(twTriple v, twTriple A, twTriple B) ;

// Computes B=A+v, the point that is the sum of point A and vector v
void twPoint(twTriple B, twTriple A, twTriple v) ;

// Computes Q=P+Vt, a point on the line defined by P and V
void twPointOnLine(twTriple Q, twTriple P, twTriple V, GLfloat t);

// computes the squared distance between points A and B
GLfloat twPointDistance2(twTriple A, twTriple B) ;

// computes the distance between points A and B
GLfloat twPointDistance(twTriple A, twTriple B) ;

// Find the plane normal, N, given three points on the plane, C, D, and
// E. The vectors are v=D-C and w=E-C and the normal is computed as v x w.
// If you give C,D,E in counterclockwise order, the normal will point out
// from the front of the plane.

GLfloat twPlaneNormal(twTriple N, twTriple C, twTriple D, twTriple E);

// Returns true if a normal intersection, false otherwise.  See the
// documentation in doc.tex.  P and V define the line; Q and N define the
// plane.  Computed values are IP (the intersection point) and t, the
// parameter of the intersection point
bool twLinePlaneIntersection( twTriple P, twTriple V,
                              twTriple Q, twTriple N,
                              GLfloat& t, twTriple IP);

// Computes the parameters, s and t, of point I lying in the plane defined
// by point P and vectors U and V.  The caller has to interpret the
// parameters to determine if I is contained in the triangle (0<t && 0<s
// && s+t<1) or in the parallelogram (0<t<1 && 0<s<1).  For documentation
// on the computation, see doc.tex.  Returns false if the computation is
// invalid, such as the triangle being degenerate (u or v is zero, or they
// are colinear).
bool twPointInTriangle( twTriple I,
                        twTriple P, twTriple U, twTriple V,
                        GLfloat& s, GLfloat& t);

// Computes r, s, and t, where r is the parameter of point IP=P+r*lineV
// with the plane defined by triangle A,B,C.  Also computes IP.  Returns
// true if the computation is valid (that is, A,B,C define a plane and
// P+r*lineV intersects the plane).
bool twLineTriangleIntersection( twTriple P, twTriple lineV,
                                 twTriple A, twTriple B, twTriple C,
                                 twTriple IP,
                                 GLfloat& r, GLfloat& s, GLfloat& t);


// M must be an array of 16 floats.  It is filled with a rotation matrix
// of the given angle (in degrees) around the given axis (x,y,z).  This is
// just the OpenGL code underlying glRotatef, so the arguments are the
// same as for that function.  Normalizes the vector.  If the vector is
// zero length, returns immediately without modifying M.  From the GL
// reference manual for glRotate.

void twRotationMatrix(GLfloat* M, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

// Computes the product of matrix M (a 4x4 matrix in column major order)
// and a vector v (4x1).  The last element of v is typically 1.0 for a
// point and 0.0 for a vector.
void mult4(GLfloat* dest, GLfloat* M, GLfloat* v);

// Computes the product of matrix M (a 4x4 matrix in column major order)
// and a vector v (3x1).  The last row and column of M are ignored.  See
// mult4.
void mult3(GLfloat* dest, GLfloat* M, GLfloat* v); 
void mult3d(GLfloat* dest, GLdouble* M, GLfloat* v); 

// Prints a 4x4 column-major matrix, plus a name
void twPrintMatrix4x4(char* name, GLdouble M[16]) ;    

// ================================================================
// functions in tw-camera.cc

// gets the modelview matrix and stores it into the given matrix.
void twGetModelView(GLdouble MV[16]) ;

// gets the projection matrix and stores it into the given matrix.
void twGetProjection(GLdouble P[16]) ;

// gets the viewport array and stores it into the given array
void twGetViewport(GLint V[4]) ;

// computes the window projection of the vertex v and stores it in winx,
// winy and winz.  That is, it computes where on the screen the point v
// will project to.
void twProject(twTriple w, twTriple v);

// computes v, a world vertex coordinate corresponding to window location w
void twUnProject(twTriple v, twTriple w) ;

// Stores into M a rotation matrix of angle degrees around vector (x,y,z).
// Normalizes the vector.  If the vector is zero length, returns
// immediately without modifying M.  From the GL reference manual for
// glRotate.
void rotationMatrix(GLfloat* M, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) ;
        
// Rotates the viewpoint (changing the VRP, VPN and VUP so that it still
// looks at the center, but from a different place) by the given angle
// around the given rotation vector.  Returns if angle is zero.
void twRotateViewpoint(GLfloat angle, twTriple r) ;    

// Rotates the view plane normal (VPN), keeping the VRP fixed, so that we
// are tilting or panning the camera. Rotates by the given angle around
// the given rotation vector.  Returns if angle is zero.  Leaves VUP
// unchanged.  If the VPN would end up outside the original frustum, it is
// limited to that angle.  This is done by limiting rotation to 45 degrees
// from the original VPN (the vector from the VRP to the Center).
void twRotateVPN(GLfloat angle, twTriple r) ;    

// Rotates the viewpoint by an angle defined by two window locations:
// (Ax,Ay) and (Bx,By).  The y coordinate of the window locations should
// already have been subtracted from the window height.  This function
// retrieves the modelview matrix and sets originalView to false
void twTrackballOrientation_old(int Ax, int Ay, int Bx, int By) ;    

// Rotates the viewpoint by an angle defined by two window locations:
// (Ax,Ay) and (Bx,By).  The y coordinate of the window locations should
// already have been subtracted from the window height.  This function
// retrieves the modelview matrix and sets originalView to false
void twTrackballOrientation(int Ax, int Ay, int Bx, int By) ;    

// Modify the VPN so that the (x,y) pixel coordinates are in the center of
// the screen.  Ultimately calls RotateVPN.
void twOrientVPN(GLint x, GLint y);
    
// ================================================================

/* The following function computes RGB values from HSV values.  Hue is
   specified as an angle in degrees from pure red (zero).  */

void twHSV2RGB( twTriple hsv, twTriple rgb );

/* This function is a shortcut covering most cases of material.  The
   ambient and diffuse are the same, and the specular is a shade of gray.
   You can also control the shininess. Note that function also handles
   color when you have lighting turned off. */

void twColor(twTriple, GLfloat specular, GLfloat shininess);

/* This function is similar.  It takes separate RGB components instead of
   a twTriple, and it combines the specular and shininess.  Strange, but
   this seems to work: unshiny objects have a black specular component and
   shiny objects have a white specular component. This function should
   probably be obsolescent though; you should use the preceding one
   instead. */

void twColor(GLfloat r, GLfloat g, GLfloat b, GLfloat specular_shininess);

/* Allows the user to specify the current color by a symbolic name, such
   as TW_RED. Use the color names listed at the top of this file. This is
   usable with material and lighting but it sets the specularity and
   shininess to zero.*/

void twColorName(int i);

// draws a quad in current color at min y of BB
void twGround();

// draws quads in current color on the other sides of BB
void twSky();

/* ================================================================
   Lighting functions from tw-lighting.cc */

/* Specifies a gray light, with different levels of ambient, diffuse and
   specular light.  The lightId arg is one of the GL light identifiers:
   GL_LIGHT0 through GL_LIGHT7. The light is at location pos, which should
   be a four-place array with the last component being 0 for directional
   lights and 1 for positional lights.  The ambient, diffuse and specular
   values are all scalars, because all three colors get the same value.
   This function allows, for example, the ambient to relatively small
   while the diffuse and specular are relatively large (but not
   equal).  This function also enables the light (turns it on). */

void twGrayLight(GLint lightId, GLfloat* pos, GLfloat ambient, GLfloat diffuse, GLfloat specular);

/* This is just like twGrayLight, but it adds the direction, cutoff angle,
   and spot_exponent.  Like twGrayLight, it enables the light. */

void twGraySpotlight(GLint lightId, GLfloat* pos, GLfloat ambient, GLfloat diffuse, GLfloat specular,
                     GLfloat* direction, GLfloat cutoff, GLfloat spot_exponent);

// sets the global ambient to a gray light of the specified intensity.
void twAmbient(GLfloat intensity);

// ================================================================
// Definitions of new tw objects, from tw-objects.cc

/* Draws unit barn with colors specified for the ends (front and back),
sides and roof.  These use twColor, so it also works with lighting.  The
default specularity and shininess are 0.1 and 10, respectively for all
surfaces.  The lower left front of the barn is anchored at (0,0,0); drawn
in +x,+y,-z direction.  The height of the side of the barn is 0.7.
Normals are also defined for all surfaces.  */

void twSolidBarn(twTriple endColor, twTriple sideColor, twTriple roofColor, GLfloat specular=0.1, GLfloat shininess = 10);

/* Like the solid barn, but wire.  Draws the lines parallel to x in
   xColor, y in yColor and z in zColor.  Diagonals of the roof are drawn
   in xColor. */

void twWireBarn(twTriple xColor, twTriple yColor, twTriple zColor);

/* Creates a disk of given radius with the specified number of slices.
   This is just a wrapper for gluDisk, so it lies in the z=0 plane, with
   the center of the disk at the origin, and the normal vector is +z. Only
   uses one loop, so the subdivision really is like a pizza. */

void twDisk(GLfloat radius, GLint slices);

/* Creates a cylinder with the given radii for the base and the top, and
   the given height.  The cylinder is drawn solid (as opposed to wire
   frame) and has normal vectors generated. The cylinder does not have
   ends; for that, use twTube.

   The cylinder has the base in the z=0 plane and extends along the
   positive z axis.  This function is a wrapper for gluCylinder, so see
   the man page of that for more info. You probably want to use 1 for
   "stacks," since there's no curvature along the axis of the cylinder. */

void twCylinder(GLfloat base, GLfloat top, GLfloat height,
                GLint slices, GLint stacks);

/* Like twCylinder, but draws the ends as well, using twDisk. */

void twTube(GLfloat base, GLfloat top, GLfloat height,
            GLint slices, GLint stacks);

/* Like twCylinder, but draws the cylinder with closed ends; drawn from
center in x and z; oriented so that it is drawn downward from y = 0.  This
function is obsolescent; use twTube instead. */

void twSolidCylinder(GLfloat base,GLfloat top,GLfloat height,
                     GLint slices,GLint stacks);

// Draws a bear within a 1*1*1 box, with reference point at lower left front
void twTeddyBear();

// ================================================================
// From tw-bounding-box.cc 

/* Tells TW what the maximum extent of your scene is.  TW uses this to
   compute the camera parameters NEAR and FAR. */

void twBoundingBox(GLfloat minx, GLfloat maxx,
                   GLfloat miny, GLfloat maxy,
                   GLfloat minz, GLfloat maxz);

/* takes array va with n vertices and computes the bounding box,
the center of the bounding box, radius, near, and far */
void twVertexArray(twTriple va[], int n);

/* Draws the bounding box for the scene, using red for lines parallel to
   x, green for lines parallel to y and blue for lines parallel to z.  */

void twDrawBoundingBox() ;

// ================================================================

/* creates pointers to the tw values of near and far */
void twNearFarSet(GLfloat& myNear, GLfloat& myFar);

/* creates pointer to the tw value of field of view */
void twFovySet(GLfloat& myFovy);

// Rotates the viewpoint (changing the VRP and VPN so that it still looks
// at the center, but from a different place) by the given angle around
// the given rotation vector.  Returns if angle is zero.  Angle is
// specified in degrees.
void twRotateViewpoint(GLfloat angle, twTriple r);

/* a wrapper for gluPerspective, using the computed fovy, ar, near and far */
void twCameraShape();

/* determines eye and at points for gluLookAt */
void twCameraPosition();

// Sets the frustum mode to LETTERBOX, DISTORT, or CLIP.  Default is LETTERBOX
void twFrustumMode(frustumMode_t mode);

/* sets up camera with 90 degree fovy, aspect ratio of 1, 
near and far.  Also calls twCameraPosition() */
void twCamera();

// view the scene from each of the three principal axes.  twZview is the
// default original orientation.

void twXview();
void twYview();
void twZview();

void twHelp(unsigned char key, int x, int y);

/* Function to spin default amount around current axis */
void twSpin();
   
// Function to zoom in (change field of view) by given angle
void twZoom(GLfloat degrees);

// Callback to begin zooming in.
void twStartZooming(unsigned char key, int x, int y);

// Just like glIdleFunc
void twIdleFunc(void (*func)(void));

// Advance to the next frame of an animation
void twNextFrame(); 

/* Halts idle function, stops animation, original image reproduced */
void twReset (unsigned char key, int x, int y);

typedef void (*twKeyFunc)(unsigned char key, int x, int y);

void twKeyCallback(char key, twKeyFunc fun, char* doc) ;

/* Callback method for keyboard */
// why would anyone need this?
// void twKeyboardCallback (unsigned char key, int x, int y);

/* Initializes tw key settings */
void twKeyInit();

/* Draws x axis in red, y axis in green and z axis in blue*/
void twAxes() ;

/* Sets up window size */ 
void twInitWindowSize(GLint xsize, GLint ysize);

/* Switches to X11's full-screen mode, so that the graphics window is the
   entire screen.  Reverse this with twWindow(). */

void twFullScreen() ;

/* Returns from X11 full-screen mode (see twFullScreen) to an X11 window.
   Note that this doesn't always work, for reasons I don't understand. */

void twWindow() ;

/* This function is the default TW mouse-click callback.  A left click
   records the current mouse location when the button goes down,
   facilitating the motion function.  A middle click points the camera in
   the specified direction.  A right click does nothing, because menus are
   usually attached to the right button.  
*/

void twMouseFunction(int button, int state, int x, int y);

/* This function is the default TW mouse-motion callback.  The scene is
   rotated so that we are still looking at the center, but from a
   different direction.  */

void twMotionFunction(int x, int y);

/* This function is the default TW reshape callback.  The actual behavior
   depends on the frustum-mode and the window shape. */

void twReshapeFunction(int w,int h);


/* The first form allows you to set the clear color (background color) to
   the given RGB values.  The second clears the background to a default
   value, currently 75% gray. */

void twDisplayInit(GLclampf bgR, GLclampf bgG, GLclampf bgB);
void twDisplayInit();

/* Enables depth test, calls the reshape callback function, calls
twKeyInit(), and calls the keyboard callback function */
void twMainInit();

/* ================================================================
   surfaces, from tw-surfaces.cc */

/* ================================================================
   TEXTURES, from tw-textures.cc */

/* Draws a 1*1 unit square with triangle_strips, dividing x and z into w
   and h segments.  The square is drawn in the y=0 plane, and both x and z
   range from 0 to 1. The normal vector points in the positive y
   direction.  Use scaling to stretch this over larger areas.  This
   function allows for lighting effects on flat regions that otherwise
   wouldn't have enough polygons.
*/

void twDrawUnitSquare(float w, float h);

// Calling this function computes and sends the US Flag texture down the
// pipeline.  If you plan to use it more than once, it would be better to
// use texture-binding.

void twUSflag();

//  The API here is that the twTex2D function substitutes for the glTex2D
//  function.  File type PPM.  You have to do everything else.  This
//  function is obsolete; use twTex2D instead.

void twTex2D(char *filename, bool verbose);

/*  Again, this function substitutes for the glTex2D function.  It reads
    in a PPM file using the netpbm (libppm) library, so it is certain to
    be more robust than the preceding function. This function is limited
    to reading in PPM images where the width and height are powers of two;
    this is a constraint of OpenGL, not the netppm library. Returns zero
    on success and 1 on failure to open file, 2 on cols not a power of 2,
    and 3 on rows not a power of two. */

int twPPM_Tex2D(char *filename, bool verbose);

/* This function is more general than the preceding function, because it
   allows images whose width and height are not powers of two.  Instead, a
   larger array whose dimensions satisfy that constraint is allocated, and
   the extra pixels are filled with 50% gray.  The texture coordinates of
   the lower right corner (the width and heigth of the original image in
   texture space) are computed in the reference parameters. Returns zero
   on success and 1 on failure to open file. */

int twPPM_Tex2D(char *filename, bool verbose, GLfloat& width, GLfloat& height);

/* Loads the filename and binds it to a given textureNumber.  It uses the
   less general form of twTex2D and returns the same value.  Defines
   GL_LINEAR (interpolation of texture values) and GL_REPEAT and
   GL_MODULATE, so it's intended to be used with lighting. */
   
int twLoadTexture(int textureNumber, char* filename);

// ================================================================
// Frames 

/* This function saves the current framebuffer as a PPM file.  You supply
   the dimensions of the framebuffer, the filename and whether to be
   verbose when writing the file.
*/

void twSaveFrame(int width, int height, char *fname, bool verbose);

// ================================================================
// In tw-geometry.cc

/* Fragments. A fragment is a triangle (or parallelogram) defined by three
   points. */

typedef twTriple twFragment[3];

/* Computes the intersection point of the nearest fragment (in the array
   of length n given by "fragments") along ray defined by point P and
   vector V.  Returns false if there is no intersection.  First arg is an
   array of triples of vertices.  Currently every fragment is a
   parallelogram. */

bool twNearestFragment(twFragment* fragments, int n,
                       twTriple P, twTriple V,
                       twTriple IP, GLfloat& r);

// ================================================================
// Fonts, from tw-fonts.cc

/* Change the font to use for writing characters to the frame buffer.  If
   this function is not used, the default font is  The current options are:

"helvetica", 12
"helvetica", 18
"times roman", 10
"times roman", 24
"8x13", ignored
"9x15", ignored

*/

void twSetFont(char* name, int size);

/* Prints into the framebuffer a string at the position corresponding to
   object position (x,y) or (x,y,z).  That is, the point is handled like
   glVertex() and is transformed by the MODELVIEW and PROJECTION matrices.
   The string is produced as if by printf, using the given format string
   and additional args as necessary. */

void twDrawString(GLuint x, GLuint y, char* format, ...);

void twDrawString(GLfloat x, GLfloat y, GLfloat z, char* format, ...);