#include "testApp.h"

GLfloat lightOnePosition[] = {40.0, 40, 100.0, 0.0};
GLfloat lightOneColor[] = {0.99, 0.99, 0.99, 0.5};

GLfloat lightTwoPosition[] = {-40.0, 40, 100.0, 0.0};
GLfloat lightTwoColor[] = {0.99, 0.99, 0.99, 0.5};

//--------------------------------------------------------------
void testApp::setup(){
	ofBackground(0,0,0);

	///ofSetVerticalSync(true);

    //some model / light stuff
    glEnable (GL_DEPTH_TEST);
    glShadeModel (GL_SMOOTH);

    /* initialize lighting */
    glLightfv (GL_LIGHT0, GL_POSITION, lightOnePosition);
    glLightfv (GL_LIGHT0, GL_DIFFUSE, lightOneColor);
    glEnable (GL_LIGHT0);
    glLightfv (GL_LIGHT1, GL_POSITION, lightTwoPosition);
    glLightfv (GL_LIGHT1, GL_DIFFUSE, lightTwoColor);
    glEnable (GL_LIGHT1);
    glEnable (GL_LIGHTING);
    glColorMaterial (GL_FRONT_AND_BACK, GL_DIFFUSE);
    glEnable (GL_COLOR_MATERIAL);

    //load the bottle model - the 3ds and the texture file need to be in the same folder
    bottle.loadModel("bottle.3DS", 1);
    board.loadModel("box.3DS", 1);
    bottle.setRotation(0, 180, 1, 0, 0);
    board.setRotation(0, 180, 1, 0, 0);

    //you can create as many rotations as you want
    //choose which axis you want it to effect
    //you can update these rotations later on
    //bottleModel.setRotation(0, -90, 1, 0, 0);
    //bottleModel.setRotation(1, 270, 0, 0, 1);
    //bottleModel.setScale(0.9, 0.9, 0.9);
    bottle.setPosition(ofGetWidth()/2, ofGetHeight()/2, -50);
    board.setPosition(ofGetWidth()/2, ofGetHeight()/2, -50);

    //ofDisableArbTex();

   texture.loadMovie("gradblend01.mov");
   texture.play();

   mode=NOTHING;

   views=new viewpoint[1];

   //todo: read this from xml
   views[0].setup(ofGetWidth(),ofGetHeight(),0,0);

   activeView=0;


}

//--------------------------------------------------------------
void testApp::update(){
    board.setRotation(1, 270 + ofGetElapsedTimef() * 60, 0, 1, 0);
    texture.idleMovie();
}

//--------------------------------------------------------------
void testApp::draw(){
    //ofPushView();
    //glMatrixMode(GL_PROJECTION);
    //glLoadIdentity();
    //gluPerspective(fov,aspect,near,far);
   // glTranslatef(0,0,-1000);
    //glMatrixMode(GL_MODELVIEW);
   // glLoadMatrixf(ofMatrix4x4::getInverseOf(getGlobalTransformMatrix()).getPtr());

    //glEnable(GL_LIGHTING);
    //ofRectangle vp=ofRectangle(0,0,ofGetWidth(),ofGetHeight());
    //camera.setFov(fov);


    views[0].begin();

        ofSetColor(255, 255, 255, 255);
        ofFill();

        switch(mode) {
            case CALIBRATE:

                glPushMatrix();
                glTranslatef(ofGetWidth(),(ofGetHeight())+100,0);
                //board.draw();

                int cx,cz;

                glFrontFace(GL_CW);
                glBegin(GL_QUADS);
                    for (int i=0;i<8;i++) {
                        for (int j=0;j<4;j++) {
                            cx=((i%2)*16)+(j*32)-56;
                            cz=(i*16)-56;
                            glVertex3f(cx+8, 0, cz-8);
                            glVertex3f(cx+8, 0, cz+8);
                            glVertex3f(cx-8, 0, cz+8);
                            glVertex3f(cx-8, 0, cz-8);

                        }
                    }
                glEnd();


/*
                glBegin(GL_QUADS);
                    glVertex3f(-100, 0,-100);
                    glVertex3f(100, 0,-100);
                    glVertex3f(100, 0,100);
                    glVertex3f(-100, 0,100);
                glEnd();
                */
                glPopMatrix();
                //glFrontFace(GL_CCW);
                bottle.draw();

                break;
            case DISPLAY:

                board.draw();
                bindTexture(texture);
                bottle.draw();
                unbindTexture(texture);
                break;
        }
		//glPopMatrix();
    views[0].end();




    /*

    glPopMatrix();

    views[0].renderFBO.draw(0,0);

    glPushMatrix();

    */

    if (mode!=NOTHING){


         bindTexture(views[0].renderFBO);
         glPushMatrix();
            //draw a grid
            //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
            ofNoFill();

            ofSetLineWidth(1.0);
            //ofSetColor(I_fade1,I_fade1,I_fade1);
            int gridX=50;
            int gridY=50;
            int xStep=ofGetWidth()/2;
            int yStep=ofGetHeight()/2;
            ofTranslate(ofGetWidth()/2,ofGetHeight()/2);

            for (float i = -1; i < 1.001; i+=(2.0f/gridY)){
                glBegin(GL_QUAD_STRIP);
                ofPoint p0;
                ofPoint p1;
                    for (float j = -1; j < 1.001; j+=(2.0f/gridX)){
                        p0=distort(ofPoint(j,i-(2.0f/gridY)),views[0].distortFactor);
                        p1=distort(ofPoint(j,i),views[0].distortFactor);
                        glTexCoord2f((j+1)*0.5,((i-(2.0f/gridY))+1)*0.5);
                        glVertex3f(p0.x*xStep,p0.y*yStep,-0.1);
                        glTexCoord2f((j+1)*0.5,(i+1)*0.5);
                        glVertex3f(p1.x*xStep,p1.y*yStep,-0.1);
                    }
                glEnd();
            }

            ofFill();


        //renderFBO.getTextureReference().unbind();
        unbindTexture(views[0].renderFBO);
        glPopMatrix();
    }


    ofSetHexColor(0xFFFFFF);
    ofDrawBitmapString("fps: "+ofToString(ofGetFrameRate(), 2), 10, 15);


 // add polygons here
    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );


}

//--------------------------------------------------------------
void testApp::keyPressed(int key){
    views[activeView].keyPressed(key);
    switch (key) {
       case '1':
            mode=CALIBRATE;
            break;
       case '2':
            mode=DISPLAY;
            break;
       case '3':
            mode=NOTHING;
            break;
    }

}

//--------------------------------------------------------------
void testApp::keyReleased(int key){
    views[activeView].keyReleased(key);
}

//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){

}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::windowResized(int w, int h){

}

//--------------------------------------------------------------
void testApp::gotMessage(ofMessage msg){

}

//--------------------------------------------------------------
void testApp::dragEvent(ofDragInfo dragInfo){

}