#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/glut.h>

#endif

// angle of rotation for the camera direction

float angle = 0.0f;

// actual vector representing the camera's direction

float lx=0.0f,lz=-1.0f, ly = 0.0f;

// XZ position of the camera

float x=0.0f, z=5.0f, y = 1.75f;

// the key states. These variables will be zero

//when no key is being presses

float deltaAngle = 0.0f;

float deltaMove = ;

int xOrigin = -;

// width and height of the window

int h,w;

// variables to compute frames per second

int frame;

long time, timebase;

char s[];

// variables to hold window identifiers

int mainWindow, subWindow1,subWindow2,subWindow3;

//border between subwindows

int border = ;

void setProjection(int w1, int h1)

{

    float ratio;

    // Prevent a divide by zero, when window is too short

    // (you cant make a window of zero width).

    ratio = 1.0f * w1 / h1;

    // Reset the coordinate system before modifying

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    // Set the viewport to be the entire window

        glViewport(, , w1, h1);

    // Set the clipping volume

    gluPerspective(,ratio,0.1,);

    glMatrixMode(GL_MODELVIEW);

}

void changeSize(int w1,int h1) {

    if(h1 == )

        h1 = ;

    // we're keeping these values cause we'll need them latter

    w = w1;

    h = h1;

    // set subwindow 1 as the active window

    glutSetWindow(subWindow1);

    // resize and reposition the sub window

    glutPositionWindow(border,border);

    glutReshapeWindow(w-*border, h/ - border*/);

    setProjection(w-*border, h/ - border*/);

    // set subwindow 2 as the active window

    glutSetWindow(subWindow2);

    // resize and reposition the sub window

    glutPositionWindow(border,(h+border)/);

    glutReshapeWindow(w/-border*/, h/ - border*/);

    setProjection(w/-border*/,h/ - border*/);

    // set subwindow 3 as the active window

    glutSetWindow(subWindow3);

    // resize and reposition the sub window

    glutPositionWindow((w+border)/,(h+border)/);

    glutReshapeWindow(w/-border*/,h/ - border*/);

    setProjection(w/-border*/,h/ - border*/);

}

void drawSnowMan() {

    glColor3f(1.0f, 1.0f, 1.0f);

// Draw Body

    glTranslatef(0.0f ,0.75f, 0.0f);

    glutSolidSphere(0.75f,,);

// Draw Head

    glTranslatef(0.0f, 1.0f, 0.0f);

    glutSolidSphere(0.25f,,);

// Draw Eyes

    glPushMatrix();

    glColor3f(0.0f,0.0f,0.0f);

    glTranslatef(0.05f, 0.10f, 0.18f);

    glutSolidSphere(0.05f,,);

    glTranslatef(-0.1f, 0.0f, 0.0f);

    glutSolidSphere(0.05f,,);

    glPopMatrix();

// Draw Nose

    glColor3f(1.0f, 0.5f, 0.5f);

    glRotatef(0.0f,1.0f, 0.0f, 0.0f);

    glutSolidCone(0.08f,0.5f,,);

    glColor3f(1.0f, 1.0f, 1.0f);

}

void renderBitmapString(

        float x,

        float y,

        float z,

        void *font,

        char *string) {

    char *c;

    glRasterPos3f(x, y,z);

    for (c=string; *c != '\0'; c++) {

        glutBitmapCharacter(font, *c);

    }

}

void restorePerspectiveProjection() {

    glMatrixMode(GL_PROJECTION);

    // restore previous projection matrix

    glPopMatrix();

    // get back to modelview mode

    glMatrixMode(GL_MODELVIEW);

}

void setOrthographicProjection() {

    // switch to projection mode

    glMatrixMode(GL_PROJECTION);

    // save previous matrix which contains the

    //settings for the perspective projection

    glPushMatrix();

    // reset matrix

    glLoadIdentity();

    // set a 2D orthographic projection

    gluOrtho2D(, w, h, );

    // switch back to modelview mode

    glMatrixMode(GL_MODELVIEW);

}

void computePos(float deltaMove) {

    x += deltaMove * lx * 0.1f;

    z += deltaMove * lz * 0.1f;

}

// Common Render Items for all subwindows

void renderScene2() {

// Draw ground

    glColor3f(0.9f, 0.9f, 0.9f);

    glBegin(GL_QUADS);

        glVertex3f(-100.0f, 0.0f, -100.0f);

        glVertex3f(-100.0f, 0.0f,  100.0f);

        glVertex3f( 100.0f, 0.0f,  100.0f);

        glVertex3f( 100.0f, 0.0f, -100.0f);

    glEnd();

// Draw 36 SnowMen

    for(int i = -; i < ; i++)

        for(int j=-; j < ; j++)

        {

            glPushMatrix();

            glTranslatef(i*10.0f, 0.0f, j * 10.0f);

            drawSnowMan();

            glPopMatrix();

        }

}

// Display func for main window

void renderScene() {

    glutSetWindow(mainWindow);

    glClear(GL_COLOR_BUFFER_BIT);

    glutSwapBuffers();

}

// Display func for sub window 1

void renderScenesw1() {

    glutSetWindow(subWindow1);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    gluLookAt(x, y, z,

          x + lx,y + ly,z + lz,

          0.0f,1.0f,0.0f);

    renderScene2();

    // display fps in the top window

     frame++;

    time=glutGet(GLUT_ELAPSED_TIME);

    if (time - timebase > ) {

        sprintf(s,"Lighthouse3D - FPS:%4.2f",

            frame*1000.0/(time-timebase));

        timebase = time;

        frame = ;

    }

    setOrthographicProjection();

    glPushMatrix();

    glLoadIdentity();

    renderBitmapString(,,,GLUT_BITMAP_HELVETICA_12,s);

    glPopMatrix();

    restorePerspectiveProjection();

    glutSwapBuffers();

}

// Display func for sub window 2

void renderScenesw2() {

    glutSetWindow(subWindow2);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    gluLookAt(x, y+, z,

          x ,y - ,z,

          lx,,lz);

    // Draw red cone at the location of the main camera

    glPushMatrix();

    glColor3f(1.0,0.0,0.0);

    glTranslatef(x,y,z);

    glRotatef(-(angle+deltaAngle)*180.0/3.14,0.0,1.0,0.0);

    glutSolidCone(0.2,0.8f,,);

    glPopMatrix();

    renderScene2();

    glutSwapBuffers();

}

// Display func for sub window 3

void renderScenesw3() {

    glutSetWindow(subWindow3);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    gluLookAt(x-lz* , y, z+lx*,

          x ,y ,z ,

          0.0f,1.0f,0.0f);

    // Draw red cone at the location of the main camera

    glPushMatrix();

    glColor3f(1.0,0.0,0.0);

    glTranslatef(x,y,z);

    glRotatef(-(angle+deltaAngle)*180.0/3.14,0.0,1.0,0.0);

    glutSolidCone(0.2,0.8f,,);

    glPopMatrix();

    renderScene2();

    glutSwapBuffers();

}

// Global render func

void renderSceneAll() {

    // check for keyboard movement

    if (deltaMove) {

        computePos(deltaMove);

        glutSetWindow(mainWindow);

        glutPostRedisplay();

    }

    renderScene();

    renderScenesw1();

    renderScenesw2();

    renderScenesw3();

}

// -----------------------------------

//             KEYBOARD

// -----------------------------------

void processNormalKeys(unsigned char key, int xx, int yy) {

    if (key == ) {

        glutDestroyWindow(mainWindow);

        exit();

    }

}

void pressKey(int key, int xx, int yy) {

    switch (key) {

        case GLUT_KEY_UP : deltaMove = 0.5f; break;

        case GLUT_KEY_DOWN : deltaMove = -0.5f; break;

    }

    glutSetWindow(mainWindow);

    glutPostRedisplay();

}

void releaseKey(int key, int x, int y) {

    switch (key) {

        case GLUT_KEY_UP :

        case GLUT_KEY_DOWN : deltaMove = ;break;

    }

}

// -----------------------------------

//             MOUSE

// -----------------------------------

void mouseMove(int x, int y) {

    // this will only be true when the left button is down

    if (xOrigin >= ) {

        // update deltaAngle

        deltaAngle = (x - xOrigin) * 0.001f;

        // update camera's direction

        lx = sin(angle + deltaAngle);

        lz = -cos(angle + deltaAngle);

        glutSetWindow(mainWindow);

        glutPostRedisplay();

    }

}

void mouseButton(int button, int state, int x, int y) {

    // only start motion if the left button is pressed

    if (button == GLUT_LEFT_BUTTON) {

        // when the button is released

        if (state == GLUT_UP) {

            angle += deltaAngle;

            deltaAngle = 0.0f;

            xOrigin = -;

        }

        else  {// state = GLUT_DOWN

            xOrigin = x;

        }

    }

}

// -----------------------------------

//             MAIN and INIT

// -----------------------------------

void init() {

    glClearColor(0.0, 0.0, 0.0, 0.0);

    glEnable(GL_DEPTH_TEST);

    glEnable(GL_CULL_FACE);

    // register callbacks

    glutIgnoreKeyRepeat();

    glutKeyboardFunc(processNormalKeys);

    glutSpecialFunc(pressKey);

    glutSpecialUpFunc(releaseKey);

    glutMouseFunc(mouseButton);

    glutMotionFunc(mouseMove);

}

int main(int argc, char **argv) {

    // init GLUT and create main window

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

    glutInitWindowPosition(,);

    glutInitWindowSize(,);

    mainWindow = glutCreateWindow("Lighthouse3D - GLUT Tutorial");

    // callbacks for main window

    glutDisplayFunc(renderSceneAll);

    glutReshapeFunc(changeSize);

    // Removing the idle function to save CPU and GPU

    //glutIdleFunc(renderSceneAll);

    init();

    // sub windows

    subWindow1 = glutCreateSubWindow(mainWindow, border,border,w-*border, h/ - border*/);

    glutDisplayFunc(renderScenesw1);

    init();

    subWindow2 = glutCreateSubWindow(mainWindow, border,(h+border)/,w/-border*/, h/ - border*/);

    glutDisplayFunc(renderScenesw2);

    init();

    subWindow3 = glutCreateSubWindow(mainWindow, (w+border)/,(h+border)/,w/-border*/,h/ - border*/);

    glutDisplayFunc(renderScenesw3);

    init();

    // enter GLUT event processing cycle

    glutMainLoop();

    return ;

}