OglShapeRenderer.hh

Go to the documentation of this file.

 
#ifndef _OGL_SHAPE_RENDERER_HH_
#define _OGL_SHAPE_RENDERER_HH_
 
#include "MbsShapeRenderer.hh"
#include "OglWorldRenderer.hh"
 
#include <glm.hpp>
#include <vector>
 
#include "Shader.hh"
 
 
namespace OpenGLMbs{
 
 
// forward declaration
class MbsWorld3D;
class MbsLight;
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
class ShaderLight
{
    public:
        ShaderLight()
        {
            Clear();
        }
 
        glm::vec4 pos;         
        glm::vec3 color;       
        glm::vec3 attenuation; 
        float ambientCoef;     
 
        // specific to cones
        float coneCosAngle; 
        glm::vec3 coneDir;  
 
        // shadow
        float shadowBias; 
 
        MbsLight *light; 
 
        void Clear()
        {
            pos         = glm::vec4(0.0f);
            color       = glm::vec3(0.0f);
            coneDir     = glm::vec3(0.0f);
            attenuation = glm::vec3(0.0f);
 
            ambientCoef  = 0.0f;
            coneCosAngle = 0.0f;
 
            shadowBias = 0.0f;
 
            light = NULL;
        }
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
 
class OglShapeRenderer : public MbsShapeRenderer
{
    public:
 
        OglShapeRenderer(std::string vertex_file, std::string fragment_file, MbsWorld3D* w, OglWorldRenderer *world_rend);
        virtual ~OglShapeRenderer();
 
        virtual void Init(std::vector<glm::vec3> vertices,
                  std::vector<glm::vec3> colors,
                  std::vector<glm::vec3> normals,
                  std::vector<unsigned int> indexes);
 
        virtual void Update(glm::mat4 model_mat,
                    glm::mat4 MVP,
                    glm::mat3 M_inv_trans,
                    MbsWorld3D *world_3d,
                    float shiny_mat,
                    glm::vec3 const& specular_mat,
                    float transparency);
 
        virtual void ShadowDepth(int index);
 
        virtual void SetModelMat(glm::mat4 const& model_mat)
        {
            this->model_mat = model_mat;
        }
 
    protected:
 
        glm::mat4 model_mat;    
 
        int nb_indexes; 
 
        MbsWorld3D *world_3d; 
        OglWorldRenderer *world_rend; 
 
        std::vector<ShaderLight> sh_lights; 
 
        int shader_flag; 
 
        Shader shader; 
        Shader *depth_shader; 
 
        std::vector<GLuint> lightPosID;    
        std::vector<GLuint> lightColID;    
        std::vector<GLuint> lightAttID;    
        std::vector<GLuint> lightAmbID;    
        std::vector<GLuint> lightConAngID; 
        std::vector<GLuint> lightConDirID; 
 
        GLuint mvpID;       
        GLuint modelMatID;  
        GLuint MInvTransID; 
 
        glm::mat4 biasMatrix; 
 
        std::vector<glm::mat4> mvpDepth;     
        std::vector<glm::mat4> depthBiasMVP; 
 
        std::string depth_vert_sh; 
        std::string depth_frag_sh; 
 
        //float transparency; //!< transparancy
 
        //float shiny_mat;        //!< shiny material
        //glm::vec3 specular_mat; //!< specular material
 
        bool light_init; 
 
        GLuint VAO_id; 
        GLuint VBO_vertex_id;  
        GLuint VBO_color_id;   
        GLuint VBO_normal_id;  
        GLuint VBO_indexes_id; 
 
        GLuint transID;      
        GLuint nbLightsID;   
        GLuint cameraID;     
        GLuint shininessID;  
        GLuint specularID;   
 
        // shadow mapping
        std::vector<GLuint> depthBiasID;   
        std::vector<GLuint> shadowMapID;   
        std::vector<GLuint> shadowBiasID;  
        std::vector<GLuint> spreadID;      
 
        std::vector<GLuint> mvpDepthID;   
 
        std::vector<GLuint> frameBuffer;  
        std::vector<GLuint> depthTexture; 
 
        std::vector<int> depth_semi_x_width; 
        std::vector<int> depth_semi_y_width; 
 
        std::vector<float> depth_ratio_width; 
 
        // Lights function
        void LightsInit(float shiny_mat, glm::vec3 const& specular_mat, float transparency);
        void LightsUpdate();
 
        // utilities
        std::string StringLoc(const char* fieldName, size_t index);
        std::string StringLoc(const char* fieldName, const char* propertyName, size_t index);
 
        void MVPDepth(int index);
 
 
};
 
} // close namespace
 
#endif //_OGL_SHAPE_RENDERER_HH_