Transformation.cpp

Go to the documentation of this file.

#include "Transformation.hpp"


Transformation::Transformation()
    : m_scale(1)
    , m_position(0,0,0)
    , m_rotation(0,0,0)
    , m_matrix(1.0f)
    , m_matrixInverse(1.0f)
    , m_matrixInvalid(true)
    , m_matrixInverseInvalid(true)
{
}

void Transformation::setPosition(vec3 const & position)
{
    m_position = position; 
    checkLimits();
    m_matrixInvalid = true;
}
void Transformation::setRotation(vec3 const & rotation)
{
    m_rotation = rotation;
    checkLimits();
    m_matrixInvalid = true;
}
void Transformation::setScale(float const & scale)
{
    m_scale = scale;
    checkLimits();
    m_matrixInvalid = true;
}
void Transformation::recalc()
{
    if (m_matrixInvalid)
    {
        m_matrix = glm::translate(mat4(1.0f), m_position)
                * glm::rotate(mat4(1.0f), m_rotation.z, vec3(0,0,1))
                * glm::rotate(mat4(1.0f), m_rotation.y, vec3(0,1,0))
                * glm::rotate(mat4(1.0f), m_rotation.x, vec3(1,0,0))
                * glm::scale(mat4(1.0f),vec3(m_scale));

        m_matrixInvalid = false;
        m_matrixInverseInvalid = true;
    }
}
void Transformation::recalcInverse()
{
    recalc();

    if (m_matrixInverseInvalid)
    {
        m_matrixInverse = glm::inverse(m_matrix);
        m_matrixInverseInvalid = false;
    }
}
mat4 const & Transformation::getMatrix()
{
    recalc();
    return m_matrix;
}
mat4 const & Transformation::getMatrixInverse()
{
    recalcInverse();
    return m_matrixInverse;
}

void Transformation::move(vec3 const & delta)
{
    m_position += delta;
    checkLimits();
    m_matrixInvalid = true;
}
void Transformation::rotate(vec3 const & delta)
{
    m_rotation += delta;
    checkLimits();
    m_matrixInvalid = true;
}

vec3 const & Transformation::getLookVector()
{
    auto& mat = mat3(glm::transpose(getMatrixInverse()));
    return glm::normalize(mat[2]);
}

vec3 const & Transformation::getSideVector()
{
    auto& mat = mat3(glm::transpose(getMatrixInverse()));
    return glm::normalize(mat[0]);
}
bool const Transformation::needsRecalc()
{
    return m_matrixInvalid;
}
void Transformation::limitRotationX(float from, float to)
{
    m_limits.push_back([this, from, to]
                       ()
                       {
                           m_rotation.x = glm::clamp(m_rotation.x, from, to);
                       });
}
void Transformation::limitRotationY(float from, float to)
{
    m_limits.push_back([this, from, to]
                       ()
                       {
                           m_rotation.y = glm::clamp(m_rotation.y, from, to);
                       });
}
void Transformation::limitRotationZ(float from, float to)
{
    m_limits.push_back([this, from, to]
                       ()
                       {
                           m_rotation.z = glm::clamp(m_rotation.z, from, to);
                       });
}
void Transformation::checkLimits()
{
    for (auto& limit : m_limits)
        limit();
}