// Alexandri Zavodny
// CSE 40166: Computer Graphics, Fall 2010
// Example: Arcball Camera around a teapot


#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <vector>

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include "point.h"

using namespace std;

// GLOBAL VARIABLES ////////////////////////////////////////////////////////////

static size_t windowWidth = 640;
static size_t windowHeight = 480;
static float aspectRatio;

GLint leftMouseButton, rightMouseButton;    //status of the mouse buttons
int mouseX = 0, mouseY = 0;                 //last known X and Y of the mouse
bool sphereOn = false;                      //show the camera radius sphere


//note to students reading this code:
//  yes, I should really be more object-oriented with this code.
//  a lot of this would be simplified and better encapsulated inside
//  of a Camera class. don't let your code get this ugly!
enum cameraList { CAMERA_INNER = 0, CAMERA_OUTER = 1 };
enum cameraList currentCamera = CAMERA_OUTER;

vector<Point> cameraTPRs;                   //will contain the position of each
                                            //camera in spherical coordinates
vector<Point> cameraXYZs;                   //will contain the position of each
                                            //camera in cartesian coordinates

// recomputeOrientation() //////////////////////////////////////////////////////
//
// This function updates the camera's position in cartesian coordinates based 
//  on its position in spherical coordinates. Should be called every time 
//  either camera's spherical coordinates are updated.
//
////////////////////////////////////////////////////////////////////////////////
void recomputeOrientation(Point &xyz, Point &tpr)
{
    xyz.x = tpr.z *  sinf(tpr.x)*sinf(tpr.y);
    xyz.z = tpr.z * -cosf(tpr.x)*sinf(tpr.y);
    xyz.y = tpr.z * -cosf(tpr.y);
    glutPostRedisplay();
}

// resizeWindow() //////////////////////////////////////////////////////////////
//
//  GLUT callback for window resizing. Resets GL_PROJECTION matrix and viewport.
//
////////////////////////////////////////////////////////////////////////////////
void resizeWindow(int w, int h)
{
    aspectRatio = w / (float)h;

    windowWidth = w;
    windowHeight = h;

    //update the viewport to fill the window
    glViewport(0, 0, w, h);

    //update the projection matrix with the new window properties
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0,aspectRatio,0.1,100000);

    glutPostRedisplay();
}



// mouseCallback() /////////////////////////////////////////////////////////////
//
//  GLUT callback for mouse clicks. We save the state of the mouse button
//      when this is called so that we can check the status of the mouse
//      buttons inside the motion callback (whether they are up or down).
//
////////////////////////////////////////////////////////////////////////////////
void mouseCallback(int button, int state, int thisX, int thisY)
{
    //update the left and right mouse button states, if applicable
    if(button == GLUT_LEFT_BUTTON)
        leftMouseButton = state;
    else if(button == GLUT_RIGHT_BUTTON)
        rightMouseButton = state;
    
    //and update the last seen X and Y coordinates of the mouse
    mouseX = thisX;
    mouseY = thisY;
}

// mouseMotion() ///////////////////////////////////////////////////////////////
//
//  GLUT callback for mouse movement. We update the current camera's spherical
//      coordinates based on how much the user has moved the mouse in the
//      X or Y directions (in screen space) and whether they have held down
//      the left or right mouse buttons. If the user hasn't held down any
//      buttons, the function just updates the last seen mouse X and Y coords.
//
////////////////////////////////////////////////////////////////////////////////
void mouseMotion(int x, int y)
{
    if(leftMouseButton == GLUT_DOWN)
    {
        Point *curTPR = &cameraTPRs.at(currentCamera);      //just for conciseness below
        curTPR->x += (x - mouseX)*0.005;
        curTPR->y += (y - mouseY)*0.005;

        // make sure that phi stays within the range (0, M_PI)
        if(curTPR->y <= 0)
            curTPR->y = 0+0.001;
        if(curTPR->y >= M_PI)
            curTPR->y = M_PI-0.001;
        
        //update camera (x,y,z) based on (radius,theta,phi)
        recomputeOrientation(cameraXYZs.at(currentCamera), cameraTPRs.at(currentCamera));
    } else if(rightMouseButton == GLUT_DOWN) {
        double totalChangeSq = (x - mouseX) + (y - mouseY);
        
        Point *curTPR = &cameraTPRs.at(currentCamera);      //just for conciseness below
        curTPR->z += totalChangeSq*0.01;
        
        //limit the camera radius to some reasonable values so the user can't get lost
        if(curTPR->z < 2.0) 
            curTPR->z = 2.0;
        if(curTPR->z > 10.0*(currentCamera+1)) 
            curTPR->z = 10.0*(currentCamera+1);

        //update camera (x,y,z) based on (radius,theta,phi)
        recomputeOrientation(cameraXYZs.at(currentCamera), cameraTPRs.at(currentCamera));
    }
    mouseX = x;
    mouseY = y;
}



// initScene() /////////////////////////////////////////////////////////////////
//
//  A basic scene initialization function; should be called once after the
//      OpenGL context has been created. Doesn't need to be called further.
//
////////////////////////////////////////////////////////////////////////////////
void initScene() 
{
    glEnable(GL_DEPTH_TEST);

    float lightCol[4] = { 1, 1, 1, 1};
    float ambientCol[4] = {0.3, 0.3, 0.3, 1.0};
    float lPosition[4] = { 10, 10, 10, 1 };
    glLightfv(GL_LIGHT0,GL_POSITION,lPosition);
    glLightfv(GL_LIGHT0,GL_DIFFUSE,lightCol);
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambientCol);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    glEnable(GL_POINT_SMOOTH);

    glShadeModel(GL_SMOOTH);
    //glShadeModel(GL_FLAT);
    
    glutPostRedisplay();
}


// drawSceneElements() /////////////////////////////////////////////////////////
//
//  Because we'll be drawing the scene twice from different viewpoints,
//      we encapsulate the code to draw the scene here, so that we can just
//      call this function twice once the projection and modelview matrices
//      have been set appropriately.
//
////////////////////////////////////////////////////////////////////////////////
void drawSceneElements(void) 
{
    glDisable(GL_LIGHTING);
    //draw a simple grid under the teapot
    glColor3f(1,1,1);
    for(int dir = 0; dir < 2; dir++)
    {
        for(int i = -5; i < 6; i++)
        {
            glBegin(GL_LINE_STRIP);
            for(int j = -5; j < 6; j++)
                glVertex3f(dir<1?i:j, -0.73f, dir<1?j:i);
            glEnd();
        }
    }

    //and then draw the teapot itself!
    glEnable(GL_LIGHTING);

    //see documentation for glutSolidTeapot; glutSolidTeapot must be called with 
    //a different winding set. there is a known 'bug' that results in the 
    //winding of the teapot to be backwards.
    glFrontFace(GL_CW);
    glutSolidTeapot(1.0f);
    glFrontFace(GL_CCW);

}


// drawInnerCamera() ///////////////////////////////////////////////////////////
//
//  Draws a representation of the inner camera in space. This should only be
//      called when rendering the scene from the POV of the outer camera,
//      so that we can visualize where the inner camera is positioned
//      and what it is looking at.
//
////////////////////////////////////////////////////////////////////////////////
void drawInnerCamera()
{
    Point icpos = cameraXYZs.at(CAMERA_INNER);

    glPushAttrib(GL_LIGHTING_BIT);
    glDisable(GL_LIGHTING);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslatef(icpos.x, icpos.y, icpos.z);
    glRotatef(-cameraTPRs.at(CAMERA_INNER).x*180.0/M_PI, 0, 1, 0);
    glRotatef(cameraTPRs.at(CAMERA_INNER).y*180.0/M_PI, 1, 0, 0);
    glScalef(1,2,0.75);


    glColor3f(0,1,0);
    glutWireCube(1.0f);

    //draw the reels on top of the camera...
    for(int currentReel = 0; currentReel < 2; currentReel++)
    {
        float radius    = 0.25f;
        int resolution  = 32;
        Point reelCenter = Point(0, -0.25 + (currentReel==0?0:0.5), -0.5);
        glBegin(GL_LINES);
            Point s = reelCenter - Point(0,0.25,0);
            glVertex3f(s.x, s.y, s.z);
            for(int i = 0; i < resolution; i++)
            {
                float ex    = -cosf( i / (float)resolution * M_PI);
                float why   =  sinf( i / (float)resolution * M_PI);
                Point p = Point(0, ex*radius, -why*radius*3) + reelCenter;
                glVertex3f(p.x, p.y, p.z);  //end of this line...
                glVertex3f(p.x, p.y, p.z);  //and start of the next
            }
            Point f = reelCenter + Point(0,0.25,0);
            glVertex3f(f.x, f.y, f.z);
        glEnd();
    }

    //and just draw the lens shield manually because 
    //i don't want to think about shear matrices.
    //clockwise looking from behind the camera:
    float lensOff = 0.3f;
    float lensOut = 0.2f;
    Point v0    =   Point( 0.5,  0.5, -0.5);
    Point v1    =   Point(-0.5,  0.5, -0.5);
    Point v2    =   Point(-0.5,  0.5,  0.5);
    Point v3    =   Point( 0.5,  0.5,  0.5);

    Point l0    =   v0 + Point( lensOut,0,0) + Point(0,lensOut,0) + Point(0,0,-lensOff);
    Point l1    =   v1 + Point(-lensOut,0,0) + Point(0,lensOut,0) + Point(0,0,-lensOff);
    Point l2    =   v2 + Point(-lensOut,0,0) + Point(0,lensOut,0) + Point(0,0,lensOff);
    Point l3    =   v3 + Point( lensOut,0,0) + Point(0,lensOut,0) + Point(0,0,lensOff);

    
    glBegin(GL_LINE_STRIP);
        l0.glVertex();
        l1.glVertex();
        l2.glVertex();
        l3.glVertex();
        l0.glVertex();
    glEnd();

    //and connect the two
    glBegin(GL_LINES);
        v0.glVertex();  l0.glVertex();
        v1.glVertex();  l1.glVertex();
        v2.glVertex();  l2.glVertex();
        v3.glVertex();  l3.glVertex();
    glEnd();


    if(sphereOn)
    {
        //draw a point at the center of the camera
        glColor3f(1,0,0);
        glPointSize(10);
        glBegin(GL_POINTS);
            Point(0,0,0).glVertex();
        glEnd();
        glPopMatrix();

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_CULL_FACE);
        glCullFace(GL_BACK);
        glColor4f(1,1,1,0.3);
        glutSolidSphere(cameraTPRs.at(CAMERA_INNER).z, 32, 32);
        glDisable(GL_CULL_FACE);
        glDisable(GL_BLEND);
    } else {
        glPopMatrix();
    }


    /*
    //draw a wireframe box around where the camera is located
    Point center    = cameraXYZs.at(CAMERA_INNER);
    Point up        = Point(0,1,0);
    Point dir       = -1.0f * center;
    dir.normalize();
    Point right     = cross(dir, up);
    right.normalize();
    Point camUp     = cross(dir, -1.0f * right);
    camUp.normalize();

    //so the 8 corners of the box are as follows...
    //clockwise around the top, starting from front-right:
    Point v0 = center + dir*0.7 + camUp*0.4 + right*0.4;
    Point v1 = center - dir*0.7 + camUp*0.4 + right*0.4;
    Point v2 = center - dir*0.7 + camUp*0.4 - right*0.4;
    Point v3 = center + dir*0.7 + camUp*0.4 - right*0.4;
    //aaaand the lower four:
    Point v4 = center + dir*0.7 - camUp*0.4 + right*0.4;
    Point v5 = center - dir*0.7 - camUp*0.4 + right*0.4;
    Point v6 = center - dir*0.7 - camUp*0.4 - right*0.4;
    Point v7 = center + dir*0.7 - camUp*0.4 - right*0.4;

    //and the points on the shield-y unit out front..
    float fOff = 0.2;       //heh heh.
    float fOut = 0.4;
    Point f0 = v0 + dir*fOut + camUp*fOff + right*fOff;
    Point f1 = v4 + dir*fOut - camUp*fOff + right*fOff;
    Point f2 = v7 + dir*fOut - camUp*fOff - right*fOff;
    Point f3 = v3 + dir*fOut + camUp*fOff - right*fOff;

    glColor3f(0,1,0);
    glBegin(GL_LINE_STRIP);
        glVertex3f(v0.x, v0.y, v0.z);
        glVertex3f(v1.x, v1.y, v1.z);
        glVertex3f(v2.x, v2.y, v2.z);
        glVertex3f(v3.x, v3.y, v3.z);
        glVertex3f(v0.x, v0.y, v0.z);
        glVertex3f(v4.x, v4.y, v4.z);
        glVertex3f(v5.x, v5.y, v5.z);
        glVertex3f(v6.x, v6.y, v6.z);
        glVertex3f(v7.x, v7.y, v7.z);
        glVertex3f(v4.x, v4.y, v4.z);
    glEnd();

    //just a couple of lines that got missed here...
    glBegin(GL_LINES);
        glVertex3f(v1.x, v1.y, v1.z);   glVertex3f(v5.x, v5.y, v5.z);
        glVertex3f(v2.x, v2.y, v2.z);   glVertex3f(v6.x, v6.y, v6.z);
        glVertex3f(v3.x, v3.y, v3.z);   glVertex3f(v7.x, v7.y, v7.z);
    glEnd();

    glBegin(GL_LINE_STRIP);
        glVertex3f(v0.x, v0.y, v0.z);
        glVertex3f(f0.x, f0.y, f0.z);
        glVertex3f(f1.x, f1.y, f1.z);
        glVertex3f(f2.x, f2.y, f2.z);
        glVertex3f(f3.x, f3.y, f3.z);
        glVertex3f(v3.x, v3.y, v3.z);
    glEnd();

    //just a couple of lines that got missed here...
    glBegin(GL_LINES);
        glVertex3f(f0.x, f0.y, f0.z);   glVertex3f(f3.x, f3.y, f3.z);
        glVertex3f(v4.x, v4.y, v4.z);   glVertex3f(f1.x, f1.y, f1.z);
        glVertex3f(v7.x, v7.y, v7.z);   glVertex3f(f2.x, f2.y, f2.z);
    glEnd();
    
    //and then draw the cutesy camera reels up on top...
    //
    //    ___   ___
    //   /   \ /   \
    //  _\___/_\___/ /|
    //  |           | |
    //  |___________| |
    //               \|
    //

    for(int currentReel = 0; currentReel < 2; currentReel++)
    {
        float radius    = 0.7f;
        int resolution  = 32;
        Point reelCenter = center + (currentReel==0?-1:1)*dir*0.35 + camUp*0.4;
        glBegin(GL_LINES);
            Point s = reelCenter - dir*radius*0.5f;
            glVertex3f(s.x, s.y, s.z);
            for(int i = 0; i < resolution; i++)
            {
                float ex    = -cosf( i / (float)resolution * M_PI);
                float why   =  sinf( i / (float)resolution * M_PI);
                Point p = reelCenter + ex*dir*radius*0.5f + why*camUp*radius*0.8f;
                glVertex3f(p.x, p.y, p.z);  //end of this line...
                glVertex3f(p.x, p.y, p.z);  //and start of the next
            }
            Point f = reelCenter + dir*radius*0.5f;
            glVertex3f(f.x, f.y, f.z);
        glEnd();
    }
    */
    

    glPopAttrib();
}

// renderCallback() ////////////////////////////////////////////////////////////
//
//  GLUT callback for scene rendering. Sets up the modelview matrix, renders
//      a teapot to the back buffer, and switches the back buffer with the
//      front buffer (what the user sees).
//
////////////////////////////////////////////////////////////////////////////////
void renderCallback(void) 
{
    Point outerXYZ = cameraXYZs.at(CAMERA_OUTER);
    Point innerXYZ = cameraXYZs.at(CAMERA_INNER);

    //clear the render buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    float borderWidth = 3;
    //start with the code from the outer camera, which covers the whole screen!
    glViewport(0, 0, windowWidth, windowHeight);
    glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);    glPushMatrix(); glLoadIdentity();   gluOrtho2D(0,1,0,1);
    glMatrixMode(GL_MODELVIEW); glLoadIdentity();
    if(currentCamera == CAMERA_OUTER)
        glColor3f(1,0,0);
    else 
        glColor3f(1,1,1);

    glBegin(GL_QUADS);
        glVertex2f(0,0); glVertex2f(0,1); glVertex2f(1,1); glVertex2f(1,0);
    glEnd();
    glViewport(borderWidth, borderWidth, windowWidth-borderWidth*2, windowHeight-borderWidth*2);
    glColor3f(0,0,0);
    glBegin(GL_QUADS);
        glVertex2f(0,0); glVertex2f(0,1); glVertex2f(1,1); glVertex2f(1,0);
    glEnd();

    glMatrixMode(GL_PROJECTION);    glPopMatrix();
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    
    //update the modelview matrix based on the camera's position
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(outerXYZ.x, outerXYZ.y, outerXYZ.z,
                0, 0, 0,
                0, 1, 0);

    drawSceneElements();
    drawInnerCamera();

///     draw border and background for preview box in upper corner  //////////////////////

    //next, do the code for the inner camera, which only sets in the top-right
    //corner!
    glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);

    //step 1: set the projection matrix using gluOrtho2D -- but save it first!
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluOrtho2D(0,1,0,1);

    //step 2: clear the modelview matrix
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    //step 3: set the viewport matrix a little larger than needed...
    glViewport(2*windowWidth/3.0-borderWidth, 2*windowHeight/3.0-borderWidth, 
                windowWidth/3.0+borderWidth, windowHeight/3.0+borderWidth);
    //step 3a: and fill it with a white rectangle!
    if(currentCamera == CAMERA_OUTER)
        glColor3f(1,1,1);
    else
        glColor3f(1,0,0);
    glBegin(GL_QUADS);
        glVertex2f(0,0); glVertex2f(0,1); glVertex2f(1,1); glVertex2f(1,0);
    glEnd();

    //step 4: trim the viewport window to the size we want it...
    glViewport(2*windowWidth/3.0, 2*windowHeight/3.0, 
                windowWidth/3.0, windowHeight/3.0);
    //step 4a: and color it black! the padding we gave it before is now a border.
    glColor3f(0,0,0);
    glBegin(GL_QUADS);
        glVertex2f(0,0); glVertex2f(0,1); glVertex2f(1,1); glVertex2f(1,0);
    glEnd();

    //before rendering the scene in the corner, pop the old projection matrix back
    //and re-enable lighting!
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);

///     begin drawing scene in upper corner //////////////////////////////////////////////

    glViewport(2*windowWidth/3.0, 2*windowHeight/3.0, 
                windowWidth/3.0, windowHeight/3.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(innerXYZ.x, innerXYZ.y, innerXYZ.z,   //camera is located at (x,y,z)
                0, 0, 0,                            //camera is looking at (0,0,0)
                0.0f,1.0f,0.0f);                    //up vector is (0,1,0) (positive Y)

    glClear(GL_DEPTH_BUFFER_BIT);                   //ensure that the overlay is always on top!


    drawSceneElements();

    //push the back buffer to the screen
    glutSwapBuffers();
}


// normalKeys() ////////////////////////////////////////////////////////////////
//
//  GLUT keyboard callback.
//
////////////////////////////////////////////////////////////////////////////////
void normalKeys(unsigned char key, int x, int y) 
{
    if(key == 'q' || key == 'Q')
        exit(0);

    if(key == 'c' || key == 'C')
    {
        if(currentCamera == CAMERA_INNER)   currentCamera = CAMERA_OUTER;
        else                                currentCamera = CAMERA_INNER;
        glutPostRedisplay();
    }

    if(key == 's' || key == 'S')
    {
        sphereOn = !sphereOn;
        glutPostRedisplay();
    }
}




// main() //////////////////////////////////////////////////////////////////////
//
//  Program entry point. Does not process command line arguments.
//
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    //create a double-buffered GLUT window at (50,50) with predefined windowsize
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowPosition(50,50);
    glutInitWindowSize(windowWidth,windowHeight);
    glutCreateWindow("double cameras... woahhhhh double cameras");

    //give the camera a 'pretty' starting point!
    cameraTPRs.push_back( Point(2.80, 2.0, 7.0) );
    cameraXYZs.push_back( Point(0,0,0) );
    recomputeOrientation(cameraXYZs.at(0), cameraTPRs.at(0));

    cameraTPRs.push_back( Point(1.50, 2.0, 14.0) );
    cameraXYZs.push_back( Point(0,0,0) );
    recomputeOrientation(cameraXYZs.at(1), cameraTPRs.at(1));

    //register callback functions...
    glutKeyboardFunc(normalKeys);
    glutDisplayFunc(renderCallback);
    glutReshapeFunc(resizeWindow);
    glutMouseFunc(mouseCallback);
    glutMotionFunc(mouseMotion);

    //do some basic OpenGL setup
    initScene();

    //and enter the GLUT loop, never to exit.
    glutMainLoop();

    return(0);
}