MbsShape3D.hh

Go to the documentation of this file.

 
#ifdef OPEN_GL
 
#ifndef _MBS_SHAPE_3D_HH_
#define _MBS_SHAPE_3D_HH_
 
#ifndef degreesToRadians
    #define degreesToRadians(x) x*(3.141592f/180.0f)
#endif
 
#ifndef GLM_FORCE_RADIANS
    #define GLM_FORCE_RADIANS
#endif
 
#include <glm.hpp>
#include <string>
#include <vector>
 
#include "MbsShapeRenderer.hh"
 
#include "Mbs3DTypes.hh"
 
 
namespace OpenGLMbs{
 
// forward declaration
class MbsWorld3D;
class MbsLight;
class MbsViewPoint;
 
class MbsShape3D
{
    public:
        MbsShape3D(MbsWorld3D *world_3d,
            float transparency = 1.0,
            glm::vec3 const& trans_pos   = glm::vec3(0.0f),
            glm::vec3 const& trans_scale = glm::vec3(1.0, 1.0, 1.0),
            glm::vec3 const& trans_rot   = glm::vec3(0.0f),
            float shiny_mat = 250.f,
            glm::vec3 const& specular_mat = glm::vec3(1.0f, 1.0f, 1.0f),
            const char* name = "none");
        virtual ~MbsShape3D();
 
        void SetModelMat(glm::mat4 const& model_mat)
        {
            this->model_mat = model_mat;
 
            M_inv_trans = glm::transpose(glm::inverse(glm::mat3(model_mat)));
 
            shRenderer->SetModelMat(model_mat);
        }
 
        void Update();
 
        // call the shape renderer associated to this shape
        void Render(MbsViewPoint *viewpoint);
        void Render();
 
        void ShadowDepth(int index){shRenderer->ShadowDepth(index);}
 
        void SetShinyMat(float val) { shiny_mat = val; }
 
        void SetSpecularMat(glm::vec3 const& vec) { specular_mat = vec; }
 
        MbsShapeRenderer* GetShapeRenderer(){ return shRenderer; }
 
    protected:
        char* name; 
 
        std::vector<glm::vec3> temp_vertices; 
        std::vector<glm::vec3> temp_colors;   
        std::vector<glm::vec3> temp_normals;  
        std::vector<glm::vec3> temp_line_vertices; 
        std::vector<glm::vec3> temp_line_colors;   
 
        std::vector<glm::vec3> vertices; 
        std::vector<glm::vec3> colors;   
        std::vector<glm::vec3> normals;  
        std::vector<glm::vec3> line_vertices; 
        std::vector<glm::vec3> line_colors;   
 
        std::vector<unsigned int> indexes; 
        std::vector<unsigned int> line_indexes; 
 
        glm::mat4 proj_mat;     
        glm::mat4 view_mat;     
        glm::mat4 model_mat;    
        glm::mat4 MVP;          
        glm::mat3 M_inv_trans;  
 
        glm::vec3 trans_pos;   
        glm::vec3 trans_scale; 
        glm::vec3 trans_rot;   
 
        MbsWorld3D *world_3d; 
 
        float transparency; 
 
        float shiny_mat;        
        glm::vec3 specular_mat; 
 
        int nb_triangles; 
        int nb_vertices;  
 
        // function prototypes
        void Init();
        void SetNbTriangles(int nb_triangles);
        void NormalsCompute();
        void ApplyTransform();
        void VBOIndexing();
        void VBOLineIndexing();
        void BasicLoad(GLdouble *tmp_vert, GLfloat *tmp_coord, int nb_tri, int nb_vert, glm::vec3 const& color);
 
        void ColorHeight(std::vector<glm::vec3> const& vertices, std::vector<glm::vec3> &colors,
            int axis, bool inv_color, bool bound_flag, float min_range, float max_range, const char* name);
 
        glm::mat4 TransMat(float x, float y, float z)
        {
            return glm::mat4(
                1.0f, 0.0f, 0.0f, 0.0f,
                0.0f, 1.0f, 0.0f, 0.0f,
                0.0f, 0.0f, 1.0f, 0.0f,
                   x,    y,    z, 1.0f
                );
        }
 
        glm::mat4 ScaleMat(float x, float y, float z)
        {
            return glm::mat4(
                 x  , 0.0f, 0.0f, 0.0f,
                0.0f,  y  , 0.0f, 0.0f,
                0.0f, 0.0f,  z  , 0.0f,
                0.0f, 0.0f, 0.0f, 1.0f
                );
        }
 
        glm::mat4 RotMatX(float angle_rad)
        {
            float cos_a, sin_a;
 
            cos_a = cos(angle_rad);
            sin_a = sin(angle_rad);
 
            return glm::mat4(
                1.0f,  0.0f , 0.0f , 0.0f,
                0.0f,  cos_a, sin_a, 0.0f,
                0.0f, -sin_a, cos_a, 0.0f,
                0.0f,  0.0f , 0.0f , 1.0f
                );
        }
 
        glm::mat4 RotMatY(float angle_rad)
        {
            float cos_a, sin_a;
 
            cos_a = cos(angle_rad);
            sin_a = sin(angle_rad);
 
            return glm::mat4(
                cos_a, 0.0f, -sin_a, 0.0f,
                0.0f , 1.0f,  0.0f , 0.0f,
                sin_a, 0.0f,  cos_a, 0.0f,
                0.0f , 0.0f,  0.0f , 1.0f
                );
        }
 
        glm::mat4 RotMatZ(float angle_rad)
        {
            float cos_a, sin_a;
 
            cos_a = cos(angle_rad);
            sin_a = sin(angle_rad);
 
            return glm::mat4(
                 cos_a, sin_a, 0.0f, 0.0f,
                -sin_a, cos_a, 0.0f, 0.0f,
                 0.0f , 0.0f , 1.0f, 0.0f,
                 0.0f , 0.0f , 0.0f, 1.0f
                );
        }
 
        MbsShapeRenderer* shRenderer;
 
};
 
}
#endif
#endif