Renderable.cpp

Go to the documentation of this file.

 /*
 * Renderable.cpp
 *
 *  Created on: 26.08.2008
 *      Author: Thomas Wiemann
 */

#include "lvr2/display/Renderable.hpp"

namespace lvr2
{

Renderable::Renderable()
{
        m_name =            "<NO NAME>";
        m_listIndex         = -1;
        m_activeListIndex   = -1;
        m_axesListIndex     = -1;
        m_visible           = true;

        m_rotationSpeed     = 0.02f;
        m_translationSpeed  = 10.0f;
        m_scaleFactor       = 1.0f;

        m_lineWidth         = 1.0;
        m_pointSize         = 1.0;

        m_showAxes  = false;
        m_active    = true;
        m_selected  = false;

        m_xAxis     = Vec(1.0f, 0.0f, 0.0f);
        m_yAxis     = Vec(0.0f, 1.0f, 0.0f);
        m_z_Axis    = Vec(0.0f, 0.0f, 1.0f);

        m_boundingBox = 0;

        m_model.reset();

        computeMatrix();
        //compileAxesList();

}

Renderable::Renderable(Matrix4<Vec> m, string n)
{
        m_transformation    = m;
        m_name              = n;
        m_listIndex         = -1;
        m_axesListIndex     = -1;
        m_visible           = true;
        m_rotationSpeed     = 0.02f;
        m_translationSpeed  = 10.0f;

    m_scaleFactor       = 1.0f;
    m_boundingBox       = 0;

    m_lineWidth         = 1.0;
    m_pointSize         = 1.0;

    m_model.reset();
        m_boundingBox = 0;

        m_showAxes          = false;
        m_active            = false;

        setTransformationMatrix(m);
        computeMatrix();
        compileAxesList();
}

Renderable::Renderable(const Renderable& other)
{
        m_transformation        = other.m_transformation;
        m_name                  = other.m_name;
        m_listIndex             = other.m_listIndex;
        m_axesListIndex         = other.m_axesListIndex;
        m_visible               = other.m_visible;
        m_rotationSpeed         = other.m_translationSpeed;
        m_translationSpeed      = other.m_rotationSpeed;

        m_showAxes              = other.m_showAxes;
        m_active                = other.m_active;

        m_xAxis                 = other.m_xAxis;
        m_yAxis                 = other.m_yAxis;
        m_z_Axis                = other.m_z_Axis;

        m_scaleFactor           = other.m_scaleFactor;

        m_boundingBox           = new BoundingBox<Vec>(*other.m_boundingBox);

    m_lineWidth         = 1.0;
    m_pointSize         = 1.0;

        m_model = other.m_model;

        computeMatrix();
        compileAxesList();
}

Renderable::Renderable(string n)
{
        m_name                  = n;
        m_visible               = true;
        m_listIndex             = -1;
        m_axesListIndex         = -1;
        m_activeListIndex       = -1;
        m_visible               = true;
        m_rotationSpeed         = 0.02f;
        m_translationSpeed      = 10.0f;

        m_showAxes              = false;
        m_active                = false;

    m_lineWidth         = 1.0;
    m_pointSize         = 1.0;

        m_xAxis     = Vec(1.0f, 0.0f, 0.0f);
        m_yAxis     = Vec(0.0f, 1.0f, 0.0f);
        m_z_Axis    = Vec(0.0f, 0.0f, 1.0f);

        m_scaleFactor           = 1.0f;

        m_boundingBox           = 0;

        m_model.reset();

        computeMatrix();
        //compileAxesList();

}

void Renderable::scale(float d)
{

        m_scaleFactor = d;

        float m0  = m_transformation[0 ] * d;
        float m5  = m_transformation[5 ] * d;
        float m10 = m_transformation[10] * d;

        m_transformation.set(0 , m0 );
        m_transformation.set(5 , m5 );
        m_transformation.set(10, m10);
}

void Renderable::yaw(bool invert)
{
        float speed;
        invert ? speed = m_rotationSpeed : speed = -m_rotationSpeed;

        Quaternion<Vec> q;
        q.fromAxis(m_xAxis, speed);
        m_yAxis = q * m_yAxis;
        m_z_Axis = q * m_z_Axis;
        computeMatrix();
}

void Renderable::pitch(bool invert)
{
        float speed;
        invert ? speed = m_rotationSpeed : speed = -m_rotationSpeed;

        Quaternion<Vec> q;
        q.fromAxis(m_yAxis, speed);
        m_xAxis = q * m_xAxis;
        m_z_Axis = q * m_z_Axis;

        computeMatrix();
}

void Renderable::roll(bool invert)
{
        float speed;
        invert ? speed = m_rotationSpeed : speed = -m_rotationSpeed;

        Quaternion<Vec> q;
        q.fromAxis(m_z_Axis, speed);
        m_xAxis = q * m_xAxis;
        m_yAxis = q * m_yAxis;

        computeMatrix();
}

void Renderable::rotX(bool invert)
{

        float speed;
        invert ? speed = m_rotationSpeed : speed = -m_rotationSpeed;

        Quaternion<Vec> q;
        q.fromAxis(Vec(1.0, 0.0, 0.0), speed);

        m_xAxis = q * m_xAxis;
        m_yAxis = q * m_yAxis;
        m_z_Axis = q * m_z_Axis;

        computeMatrix();

}

void Renderable::rotY(bool invert)
{
        float speed;
        invert ? speed = m_rotationSpeed : speed = -m_rotationSpeed;

        Quaternion<Vec> q;
        q.fromAxis(Vec(0.0, 1.0, 0.0), speed);

        m_xAxis = q * m_xAxis;
        m_yAxis = q * m_yAxis;
        m_z_Axis = q * m_z_Axis;

        computeMatrix();

}

void Renderable::rotZ(bool invert)
{
        float speed;
        invert ? speed = m_rotationSpeed : speed = -m_rotationSpeed;

        Quaternion<Vec> q;
        q.fromAxis(Vec(0.0, 0.0, 1.0), speed);

        m_xAxis = q * m_xAxis;
        m_yAxis = q * m_yAxis;
        m_z_Axis = q * m_z_Axis;

        computeMatrix();

}

void Renderable::accel(bool invert)
{

        Normal<typename Vec::CoordType> direction(m_z_Axis);
        if(invert) direction = direction * -1;
        m_position = m_position + direction * m_translationSpeed;

        computeMatrix();
}

void Renderable::lift(bool invert)
{
        Normal<typename Vec::CoordType> direction(m_yAxis);
        if(invert) direction = direction * -1;
        m_position = m_position + direction * m_translationSpeed;

        computeMatrix();
}

void Renderable::strafe(bool invert)
{

        Normal<typename Vec::CoordType> direction(m_xAxis);
        if(invert) direction = direction * -1;
        m_position = m_position + direction * m_translationSpeed;
        
        computeMatrix();
}

Renderable::~Renderable() {
    if (m_boundingBox)
        delete m_boundingBox;
}

void Renderable::computeMatrix(){

        Matrix4<Vec> m;

        m.set(1 , m_xAxis.y);
        m.set(2 , m_xAxis.z);

        m.set(4 , m_yAxis.x);
        m.set(6 , m_yAxis.z);

        m.set(8 , m_z_Axis.x);
        m.set(9 , m_z_Axis.y);

        m.set(12, m_position.x);
        m.set(13, m_position.y);
        m.set(14, m_position.z);

        if(m_scaleFactor == 1.0)
        {
                m.set(0 , m_xAxis.x);
                m.set(5 , m_yAxis.y);
                m.set(10, m_z_Axis.z);
        }
        else
        {
                m.set(0 , m_scaleFactor * m_xAxis.x);
                m.set(5 , m_scaleFactor * m_yAxis.y);
                m.set(10, m_scaleFactor * m_z_Axis.z);
        }

        m_transformation = m;
}

void Renderable::compileAxesList(){

        m_axesListIndex = glGenLists(1);
        glNewList(m_axesListIndex, GL_COMPILE);

        glDisable(GL_LIGHTING);
        glBegin(GL_LINES);
        glColor3f(1.0, 0.0, 0.0);
        glVertex3f(-1000000, 0.0, 0.0);
        //glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(+1000000, 0.0, 0.0);

        glColor3f(0.0, 1.0, 0.0);
        glVertex3f(0.0, -1000000, 0.0);
        //glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(0.0, +1000000, 0.0);

        glColor3f(0.0, 0.0, 1.0);
        glVertex3f(0.0, 0.0, -100000);
        //glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(0.0, 0.0, +100000);

        glEnd();
        glEnable(GL_LIGHTING);
        //glEnd();

        glEndList();

}

void Renderable::setTransformationMatrix(Matrix4<Vec> m)
{

        m_transformation = m;
        m_xAxis = Normal<typename Vec::CoordType>(m[0 ], m[1 ], m[2 ]);
        m_yAxis = Normal<typename Vec::CoordType>(m[4 ], m[5 ], m[6 ]);
        m_z_Axis = Normal<typename Vec::CoordType>(m[8 ], m[9 ], m[10]);

        m_position.x = m[12];
        m_position.y = m[13];
        m_position.z = m[14];

}

void Renderable::transform(){

}


} // namespace lvr2