#include "Pipline.h"


Pipeline::Pipeline()
{
    m_scale = glm::fvec3(1.f, 1.f, 1.f);
    m_worldPos = glm::fvec3(0.f, 0.f, 0.f);
    m_rotateInfo = glm::fvec3(0.f, 0.f, 0.f);
}


Pipeline::~Pipeline()
{
}


void Pipeline::Scale(float ScaleX, float ScaleY, float ScaleZ)
{
    m_scale.x = ScaleX;
    m_scale.y = ScaleY;
    m_scale.z = ScaleZ;
}


void Pipeline::WorldPos(float x, float y, float z)
{
    m_worldPos.x = x;
    m_worldPos.y = y;
    m_worldPos.z = z;
}


void Pipeline::Rotate(float RotateX, float RotateY, float RotateZ)
{
    m_rotateInfo.x = RotateX;
    m_rotateInfo.y = RotateY;
    m_rotateInfo.z = RotateZ;
}


void Pipeline::SetPerpsectiveProj(float FOV, float Width, float Height, float zNear, float zFar)
{
    m_persProjInfo.FOV = FOV;
    m_persProjInfo.Width = Width;
    m_persProjInfo.Height = Height;
    m_persProjInfo.zNear = zNear;
    m_persProjInfo.zFar = zFar;
}


void Pipeline::SetPerpsectiveProj(const PersProjInfo &p)
{
    m_persProjInfo = p;
}


void Pipeline::SetCamera(const glm::vec3 &Pos, const glm::vec3 &Target, const glm::vec3 &Up)
{
    m_camera.Pos = Pos;
    m_camera.Target = Target;
    m_camera.Up = Up;
}


const Mat4f &Pipeline::GetVPTrans()
{
    Mat4f CameraTranslationTrans, CameraRotateTrans, PersProjTrans;

    CameraTranslationTrans.InitTranslationTransform(-m_camera.Pos.x, -m_camera.Pos.y, -m_camera.Pos.z);
    CameraRotateTrans.InitCameraTransform(m_camera.Target, m_camera.Up);
    PersProjTrans.InitPersProjTransform(m_persProjInfo.FOV, m_persProjInfo.Width, m_persProjInfo.Height, m_persProjInfo.zNear, m_persProjInfo.zFar);

    m_VPTransformation = PersProjTrans * CameraRotateTrans * CameraTranslationTrans;

    return m_VPTransformation;
}


const Mat4f &Pipeline::GetWorldTrans()
{
    Mat4f ScaleTrans, RotateTrans, TranslationTrans;

    ScaleTrans.InitScaleTransform(m_scale.x, m_scale.y, m_scale.z);
    RotateTrans.InitRotateTransform(m_rotateInfo.x, m_rotateInfo.y, m_rotateInfo.z);
    TranslationTrans.InitTranslationTransform(m_worldPos.x, m_worldPos.y, m_worldPos.z);

    m_WorldTransformation = TranslationTrans * RotateTrans * ScaleTrans;
    return m_WorldTransformation;
}


const Mat4f &Pipeline::GetWVPTrans()
{
    GetWorldTrans();
    GetVPTrans();

    m_WVPtransformation = m_VPTransformation * m_WorldTransformation;
    return m_WVPtransformation;
}