// Geom.cpp : Defines the entry point for the console application.
//

#include <Gl/glut.h>
#include <math.h>

class Chopper
{
private:


    float rotorDegreesToRotate;                     // The contionus amount of degrees that the rotor should roate to  get a smooth animation.
    float rotorRotationSpeed;                       // The speed that the rotor should rotate at, directly affecting the above variable
    float chopperXAxisSpeed;                        // defines the positive, and negative speed that the chopper moves in the X-
    float chopperYAxisSpeed;                        // and Y-axis,
    float chopperRotation;                          // The current Rotation of the chopper, affecting steering and speed
    float chopperCurrentHeight;

    bool chopperEngineOn;                           // Determines wether the engine of the chopper is turned on or off.
    bool chopperInAir;                              // Determines wether the chopper is in the air, thus wether or not the player can control the aircraft.

public:
    Chopper();

    void chopperMainBody(float xAcceleration, float yAcceleration);
    void chopperRotor(float rotorSpeed, bool EngineOn);
    void chopperLiftoff();

    float chopperLiftoffSequense();

    int rotorDegreeCheck();
    bool chopperIsFlying();

};

class ChopperMovement
{
private:
    bool accelerateForward;
    bool accelerateBackward;
    bool accelerateLeft;
    bool accelerateRight;

public:
    ChopperMovement();

    void accelerationInputKey(unsigned char keyPress);

    bool keyPressedControl();

};

int w = 800, h = 800;//Bredde og høyde på vindu

//Egendefinerte funksjoner



void initOpenGL(); //Setter parametre

void display(); //Kalles av systemet. Kaller geom().
void reshape(int bredde, int hoyde); //Kalles av systemet
void keyboard(unsigned char key, int x, int y);
void idle(); //Kalles av systemet

const float MAX_ROTOR_SPEED = 0.5f;
const float MAX_FLYING_HEIGHT = 3.0f;
const float CHOPPER_TAKEOFF_LIMIT = 0.1f;
const float CHOPPER_TAKEOFF_HEIGHTGAIN_RATE = 0.00005f;
const float ROTOR_ACCELERATION_RATE = 0.000025f;                                                    // CONSTANTS!!!!!!!!!
const float FULL_ROTATION = 360.0f;


const float CHOPPER_X_LENGTH = 0.5;
const float CHOPPER_Y_LENGTH = 1.5;

const float ROTOR_BLADE_LENGTH = 2;
const float ROTOR_BLADE_WIDTH = 0.075;


Chopper chopper1337;
ChopperMovement chopper1337Movement;

int main(int argc, char* argv[])
{
    //Disse 5 funksjonene må være tilstede
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(w, h);
    glutInitWindowPosition(100, 150);
    glutCreateWindow("Geometri-demo");

    //Callback-funksjoner
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutIdleFunc(idle);
    //Setter startparametre
    initOpenGL();
    //Denne funksjonen må stå til slutt i main()
    glutMainLoop();
    return 0;
}

void initOpenGL()
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);//Hvit bakgrunn
    //Funksjonene under setter koordinatene til systemet vi vil tegne i
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //Koordinatsystem med -sizex <= x <= sizex, -sizey <= y <= sizey
    gluOrtho2D(-12.0f, 12.0f, -12.0f, 12.0f);
    //Gjøre klar for å transformere tegninger
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

//////////CALLBACKS//////////////////////////////

float alpha = 0;
void display()          // This displays the objects to the screen
{
    glClear(GL_COLOR_BUFFER_BIT);//Blanker skjermbuffer




    if (chopper1337.chopperIsFlying())
    {
        glLoadIdentity();
        glScalef(chopper1337.chopperLiftoffSequense(), chopper1337.chopperLiftoffSequense(), 0.0f);
    }

    if (chopper1337Movement.keyPressedControl())
        glTranslatef(0.0f, 0.0005f, 0.0);

    chopper1337.chopperMainBody(0.0,0.0);

    glPushMatrix();
        glRotatef(chopper1337.rotorDegreeCheck(), 0.0f, 0.0f, 1.0f);
        chopper1337.chopperRotor(0.0,true);
    glPopMatrix();



    glutSwapBuffers();//Bytter buffer
}

void idle()
{
    glutPostRedisplay();
}

void reshape(int bredde, int hoyde)
{
    //Kalles av systemet ved endring av vindu
    glViewport(0, hoyde - h, w, h);
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key) {


        case 27 : exit(0); break;
        case 87 : chopper1337Movement.accelerationInputKey(key); break;
    }
    glutPostRedisplay();
}

/////////////////////////Graphics Objects////////////////////////

Chopper::Chopper()
{

    rotorRotationSpeed = 0.0f;
    rotorDegreesToRotate = 0.0f;
    chopperCurrentHeight = 1.0f;
}

void Chopper :: chopperMainBody(float xAxisAcceleration, float yAxisAcceleration)
{
    glColor3f(1.0f,1.0f,1.0f);
    glBegin(GL_TRIANGLES);
        glVertex2f(-CHOPPER_X_LENGTH/2, 0.0f);
        glVertex2f(CHOPPER_X_LENGTH/2, 0.0f);
        glVertex2f(0.0f, CHOPPER_Y_LENGTH/2);
        glVertex2f(-CHOPPER_X_LENGTH/2, 0.0f);
        glVertex2f(CHOPPER_X_LENGTH/2, 0.0f);
        glVertex2f(0.0f, -CHOPPER_Y_LENGTH/2);

    glEnd();

}

void Chopper :: chopperRotor(float RotorSpeed, bool EngineStatus)
{
    glColor3f(0.33f,0.33f,0.33f);
    glBegin(GL_QUADS);
        glVertex2f(-ROTOR_BLADE_LENGTH/2, -ROTOR_BLADE_WIDTH/2);
        glVertex2f(ROTOR_BLADE_LENGTH/2, -ROTOR_BLADE_WIDTH/2); // draws horisontal rotor-blade
        glVertex2f(ROTOR_BLADE_LENGTH/2, ROTOR_BLADE_WIDTH/2);
        glVertex2f(-ROTOR_BLADE_LENGTH/2, ROTOR_BLADE_WIDTH/2);

        glVertex2f(-ROTOR_BLADE_WIDTH/2, -ROTOR_BLADE_LENGTH/2);
        glVertex2f(ROTOR_BLADE_WIDTH/2, -ROTOR_BLADE_LENGTH/2); // draws vertical rotor-blade
        glVertex2f(ROTOR_BLADE_WIDTH/2, ROTOR_BLADE_LENGTH/2);
        glVertex2f(-ROTOR_BLADE_WIDTH/2, ROTOR_BLADE_LENGTH/2);
    glEnd();
}

void Chopper :: chopperLiftoff()
{
    chopperInAir = true;
}

float Chopper ::chopperLiftoffSequense()
{
    if (chopperCurrentHeight < MAX_FLYING_HEIGHT)
    {
        chopperCurrentHeight += CHOPPER_TAKEOFF_HEIGHTGAIN_RATE;
        return chopperCurrentHeight;
    }
    else
        return chopperCurrentHeight;

}

bool Chopper :: chopperIsFlying()
{
    return chopperInAir;                                    // returns wether the chopper is in the air or not.
}

int Chopper ::rotorDegreeCheck()
{
    rotorDegreesToRotate += rotorRotationSpeed;

    if (rotorRotationSpeed < MAX_ROTOR_SPEED)               // the acceleration rate grows as the chopper engine starts up.
        rotorRotationSpeed += ROTOR_ACCELERATION_RATE;      // peaking at the set max

    if (rotorDegreesToRotate >= FULL_ROTATION)  // This ensures that the degrees total does not grow larger the longer the program runs
        rotorDegreesToRotate -= FULL_ROTATION;  // ensuring that the variable does not become to large.

    if (rotorRotationSpeed > (MAX_ROTOR_SPEED - CHOPPER_TAKEOFF_LIMIT))
        chopperLiftoff();

    return rotorDegreesToRotate;
}



ChopperMovement::ChopperMovement()
{
    accelerateForward = false;
    accelerateBackward = false;
    accelerateLeft= false;
    accelerateRight = false;

}

void ChopperMovement::accelerationInputKey(unsigned char accelerationKey)
{

    accelerateForward = true;

}

bool ChopperMovement::keyPressedControl()
{
    return accelerateForward;
}