#include "Object2D.h"

Object2D::Object2D(){
    m_updateProjection = true;
    m_updateModelview = true;

    m_size = vec2();
    m_position = vec2();
    m_direction = vec2();
    m_scale = vec2(1);
    m_rotationPoint = vec2();
    m_speed = 0;
    m_rotation = 0;
    m_flip = false;

    m_moveForward = false;
    m_moveBackward = false;
    m_moveLeft = false;
    m_moveRight = false;

    m_viewport[0] = 0;
    m_viewport[1] = 0;
    m_viewport[2] = 0;
    m_viewport[3] = 0;
}

Object2D::~Object2D(){
    delete &m_projection;
    delete &m_modelview;
    delete &m_size;
    delete &m_position;
    delete &m_direction;
    delete &m_scale;
    delete &m_rotationPoint;
}

void Object2D::setViewport(int x0, int y0, int x1, int y1){
    m_viewport[0] = x0;
    m_viewport[1] = y0;
    m_viewport[2] = x1;
    m_viewport[3] = y1;

    m_updateProjection = true;
}

void Object2D::setViewport(int width, int height){
    setViewport(0, 0, width, height);
}

void Object2D::setSize(vec2 v){
    m_size = v;
}

void Object2D::setSize(float x, float y){
    setSize(vec2(x, y));
}

void Object2D::setXSize(float f){
    setSize(vec2(f, m_size.y));
}

void Object2D::setYSize(float f){
    setSize(vec2(m_size.x, f));
}

void Object2D::addSize(vec2 v){
    m_size += v;
}

void Object2D::addSize(float x, float y){
    addSize(vec2(x, y));
}

void Object2D::addXSize(float f){
    addSize(vec2(f, 0));
}

void Object2D::addYSize(float f){
    addSize(vec2(0, f));
}

void Object2D::setPosition(vec2 v){
    m_position = v;
    m_updateModelview = true;
}

void Object2D::setPosition(float x, float y){
    setPosition(vec2(x, y));
}

void Object2D::addPosition(vec2 v){
    m_position += v;
    m_updateModelview = true;
}

void Object2D::addPosition(float x, float y){
    addPosition(vec2(x, y));
}

void Object2D::setX(float f){
    setPosition(vec2(f, m_position.y));
}

void Object2D::setY(float f){
    setPosition(vec2(m_position.x, f));
}

void Object2D::addX(float f){
    addPosition(vec2(f, 0));
}

void Object2D::addY(float f){
    addPosition(vec2(0, f));
}

void Object2D::setScale(vec2 v){
    m_scale = v;
    m_updateModelview = true;
}

void Object2D::setScale(float x, float y){
    setScale(vec2(x, y));
}

void Object2D::addScale(vec2 v){
    m_scale += v;
    m_updateModelview = true;
}

void Object2D::addSclae(float x, float y){
    addScale(vec2(x, y));
}

void Object2D::setXScale(float f){
    setScale(vec2(f, m_scale.y));
}

void Object2D::setYScale(float f){
    setScale(vec2(m_scale.x, f));
}

void Object2D::addXScale(float f){
    addScale(vec2(f, 0));
}

void Object2D::addYScale(float f){
    addScale(vec2(0, f));
}

void Object2D::setDirection(vec2 v){
    m_direction = v;
    m_direction.normalize();
    m_updateModelview = true;
}

void Object2D::setDirection(float x, float y){
    setDirection(vec2(x, y));
}

void Object2D::addDirection(vec2 v){
    m_direction += v;
    m_direction.normalize();
    m_updateModelview = true;
}

void Object2D::addDirection(float x, float y){
    addDirection(vec2(x, y));
}

void Object2D::setXDirection(float f){
    setDirection(vec2(f, m_direction.x));
}

void Object2D::setYDirection(float f){
    setDirection(vec2(m_direction.y, f));
}

void Object2D::addXDirection(float f){
    addDirection(vec2(f, 0));
}

void Object2D::addYDirection(float f){
    addDirection(vec2(0, f));
}

void Object2D::setSpeed(float f){
    m_speed = f;
}

void Object2D::addSpeed(float f){
    m_speed += f;
}

void Object2D::setRotationPoint(int i){
    switch(i){
        case OBJECT2D_BOTTOM_LEFT:
            m_rotationPoint = vec2();

            break;
        case OBJECT2D_BOTTOM_RIGHT:
            m_rotationPoint = vec2(m_size.x, 0);

            break;
        case OBJECT2D_TOP_LEFT:
            m_rotationPoint = vec2(0, m_size.y);

            break;
        case OBJECT2D_TOP_RIGHT:
            m_rotationPoint = vec2(m_size.x, m_size.y);

            break;
        case OBJECT2D_CENTER:
            m_rotationPoint = vec2(m_size.x/2, m_size.y/2);

            break;
        default:
            m_rotationPoint = vec2();
    }
}

void Object2D::setRotationPoint(vec2 v){
    m_rotationPoint = v;
    m_updateModelview = true;
}

void Object2D::setRotationPoint(float x, float y){
    setRotationPoint(vec2(x, y));
}

void Object2D::setXRotationPoint(float f){
    setRotationPoint(vec2(f, m_rotationPoint.y));
}

void Object2D::setYRotationPoint(float f){
    setRotationPoint(vec2(m_rotationPoint.x, f));
}

void Object2D::addRotationPoint(vec2 v){
    m_rotationPoint += v;
}

void Object2D::addXRotationPoint(float f){
    addRotationPoint(vec2(f, 0));
}

void Object2D::addYRotationPoint(float f){
    addRotationPoint(vec2(0, f));
}

void Object2D::setRotation(float f){
    m_rotation = f;
    m_updateModelview = true;
}

void Object2D::addRotation(float f){
    m_rotation += f;
    m_updateModelview = true;
}

void Object2D::flip(){
    if(m_flip){
        m_flip = false;
    }
    else{
        m_flip = true;
    }

    m_updateModelview = true;
}

mat4 Object2D::getProjection(mat4 m){
    m.ortho(m_viewport[0], m_viewport[2], m_viewport[1], m_viewport[3], -1, 1);

    m_projection = m;
    m_updateProjection = false;

    return m;
}

mat4 Object2D::getProjection(){
    if(m_updateProjection){
        mat4 m;
        m.setIdentity();

        return getProjection(m);
    }

    return m_projection;
}

mat4 Object2D::getUpdatedProjection(){
    m_updateProjection = true;
    return getProjection();
}

mat4 Object2D::getModelview(mat4 m){
    m.translate(m_position.x+m_rotationPoint.x, m_position.y+m_rotationPoint.y, 0);
    m.rotate(m_rotation, 0, 0, 1);
    m.translate(-m_rotationPoint.x, -m_rotationPoint.y, 0);
    m.scale(m_scale.x, m_scale.y, 0);

    if(m_flip){
        m.rotate(180, 0, 1, 0); // braucht glDisable(GL_CULL_FACE)
    }

    m_modelview = m;
    m_updateModelview = false;

    return m;
}

mat4 Object2D::getModelview(){
    if(m_updateModelview){
        mat4 m;
        m.setIdentity();

        return getModelview(m);
    }

    return m_modelview;
}

mat4 Object2D::getUpdatedModelview(){
    m_updateModelview = true;
    return getModelview();
}

vec2 Object2D::getSize(){
    return m_size;
}

float Object2D::getSizeX(){
    return m_size.x;
}

float Object2D::getSizeY(){
    return m_size.y;
}

int Object2D::getWidth(){
    return int(m_size.x);
}

int Object2D::getHeight(){
    return int(m_size.y);
}

vec2 Object2D::getPosition(){
    return m_position;
}

float Object2D::getX(){
    return m_position.x;
}

float Object2D::getY(){
    return m_position.y;
}

vec2 Object2D::getDirection(){
    return m_direction;
}

float Object2D::getXDirection(){
    return m_direction.x;
}

float Object2D::getYDirection(){
    return m_direction.y;
}

vec2 Object2D::getScale(){
    return m_scale;
}

float Object2D::getXScale(){
    return m_scale.x;
}

float Object2D::getYScale(){
    return m_scale.y;
}

vec2 Object2D::getRotationPoint(){
    return m_rotationPoint;
}

float Object2D::getXRotationPoint(){
    return m_rotationPoint.x;
}

float Object2D::getYRotationPoint(){
    return m_rotationPoint.y;
}

float Object2D::getRotation(){
    return m_rotation;
}

float Object2D::getSpeed(){
    return m_speed;
}

bool Object2D::isFlipped(){
    return m_flip;
}