Renderable.hpp

Go to the documentation of this file.

 
 /*
 * Renderable.h
 *
 *  Created on: 26.08.2008
 *      Author: Thomas Wiemann
 *
 */
 
#ifndef RENDERABLE_H_
#define RENDERABLE_H_
 
#if _MSC_VER
#include <Windows.h>
#endif
 
 
#ifndef __APPLE__
#include <GL/gl.h>
#include <GL/glut.h>
#else
#include <OpenGL/gl.h>
#include <GLUT/glut.h>
#endif
 
#include <string>
using namespace std;
 
#include "lvr2/geometry/BaseVector.hpp"
#include "lvr2/geometry/Matrix4.hpp"
#include "lvr2/geometry/Quaternion.hpp"
#include "lvr2/geometry/BoundingBox.hpp"
 
#include "lvr2/io/Model.hpp"
 
namespace lvr2
{
 
class Renderable {
 
public:
 
    using Vec = BaseVector<float>;
 
        Renderable();
        Renderable(const Renderable &other);
        Renderable(string name);
        Renderable(Matrix4<Vec> m, string name);
 
 
        virtual ~Renderable();
        virtual void render() = 0;
 
        void setTransformationMatrix(Matrix4<Vec> m);
 
        virtual void setName(string s){m_name = s;};
        void setVisible(bool s){m_visible = s;};
        void setRotationSpeed(float s){m_rotationSpeed = s;};
        void setTranslationSpeed(float s){m_translationSpeed = s;};
        void setActive(bool a){m_active = a;};
        void setSelected(bool s) {m_selected = s;};
 
        bool isActive(){return m_active;}
        bool isSelected() { return m_selected;}
 
        void toggle(){m_active = !m_active;}
 
        void moveX(bool invert = 0)
                {invert ? m_position.x -= m_translationSpeed: m_position.x += m_translationSpeed; computeMatrix();};
 
        void moveY(bool invert = 0)
                {invert ? m_position.y -= m_translationSpeed: m_position.y += m_translationSpeed; computeMatrix();};
 
        void moveZ(bool invert = 0)
                {invert ? m_position.z -= m_translationSpeed: m_position.z += m_translationSpeed; computeMatrix();};
 
        void rotX(bool invert = 0);
        void rotY(bool invert = 0);
        void rotZ(bool invert = 0);
 
        void yaw(bool invert = 0);
        void pitch(bool invert = 0);
        void roll(bool invert = 0);
 
        void accel(bool invert = 0);
        void lift(bool invert = 0);
        void strafe(bool invert = 0);
 
        void scale(float s);
 
        void showAxes(bool on){ m_showAxes = on;};
 
        void compileAxesList();
 
        string Name() {return m_name;};
        Matrix4<Vec> getTransformation(){return m_transformation;};
 
        BoundingBox<Vec>* boundingBox() { return m_boundingBox;};
 
        virtual ModelPtr model()
    {
        return m_model;
    }
 
        void setPointSize(float size)   { m_pointSize = size;}
        void setLineWidth(float width)  { m_lineWidth = width;}
 
        float lineWidth() { return m_lineWidth;}
        float pointSize() { return m_pointSize;}
 
protected:
 
        virtual void    transform();
        void            computeMatrix();
 
        bool                         m_visible;
        bool                         m_showAxes;
        bool                         m_active;
        bool                         m_selected;
 
 
        int                          m_listIndex;
        int                          m_activeListIndex;
        int                          m_axesListIndex;
 
        float                        m_rotationSpeed;
        float                        m_translationSpeed;
        float                        m_scaleFactor;
 
    string                       m_name;
 
        Normal<typename Vec::CoordType>                          m_xAxis;
        Normal<typename Vec::CoordType>                  m_yAxis;
        Normal<typename Vec::CoordType>                  m_z_Axis;
 
        Vec                              m_position;
 
    Matrix4<Vec>                 m_transformation;
    BoundingBox<Vec>*            m_boundingBox;
 
    ModelPtr                     m_model;
 
    float                        m_lineWidth;
    float                        m_pointSize;
};
 
} // namespace lvr2
 
#endif /* RENDERABLE_H_ */