diguyOglUniformBuffer.h

Go to the documentation of this file.

#pragma once


// needed for function prototypes
#include <GL/glew.h>
#include <GL/gl.h>

#include <glm/glm.hpp>

#include <diguyUniformBufferUpdater.h>

enum diguyOglBufferIndexes
{
        DIGUY_UBO_TRANSFORM_INDEX,
        DIGUY_UBO_MATERIAL_INDEX,
        DIGUY_UBO_PER_FRAME_INDEX,
};


struct diguyOglUboMaterial
{
        glm::vec4 ambient;
        glm::vec4 diffuse;
        glm::vec4 emissivity;
        glm::vec4 specular;
        float shininess;
};

struct diguyOglUboFog
{
        diguyOglUboFog() {
                mode = 0.0f;
                start = 0.0f;
                end = 100.0f;
                density = .0001f;
        }
        // note 4 floats which is fine for alignment
        float mode;
        float start;
        float end;
        float density;
        glm::vec4 color;
};

struct diguyOglUboLight
{
        diguyOglUboLight() : diffuse(1.0f, 1.0f, 1.0f, 1.0f){
                falloff_r = 0.0f;
                falloff_rsq = 0.0f;
                spot_angle = 0.0f;
                spot_exponent = 0.0f;
        }
        glm::vec4 position;
        glm::vec4 direction;
        glm::vec4 ambient;
        glm::vec4 diffuse;
        glm::vec4 specular;
        float  falloff_r;
        float  falloff_rsq;
        float  spot_angle;
        float  spot_exponent;
};

const int DIGUY_OGL_MAX_NUM_LIGHTS = 8;

struct diguyOglPerFrameUniformBuffer
{
        diguyOglPerFrameUniformBuffer() : 
                global_ambient(.2, .2, .2, 0),
                num_active_lights(1)
        {
                lights[0].direction[0] = .7f;
                lights[0].direction[1] = .7f;
                lights[0].direction[2] = .7f;
        }

        glm::vec4 global_ambient;
        glm::vec4 eye_position;

        diguyOglUboLight lights[DIGUY_OGL_MAX_NUM_LIGHTS];
        
        diguyOglUboFog fog;
        
        diguyShadowMapParams shadow_params;
        
        int num_active_lights;

};

struct diguyOglMaterialUniformBuffer
{
        diguyOglUboMaterial material;
};

struct diguyOglTransformUniformBuffer
{
        glm::mat4 ufrm_ProjectionMatrix;        // needed by instancing
        glm::mat4 ufrm_ViewMatrix;
        glm::mat4 ufrm_ModelMatrix;
        glm::mat4 ufrm_ModelViewMatrix;
        glm::mat4 ufrm_ModelViewProjectionMatrix;
        glm::mat4 ufrm_TextureMatrix;
        
        // size problem? need to fix the padding
        // this isn't actually used currently
        glm::mat3 ufrm_NormalMatrix;

};

class diguyOglUniformBufferUpdater : public diguyUniformBufferUpdater
{
public:
        diguyOglUniformBufferUpdater();
        virtual ~diguyOglUniformBufferUpdater();

        diguyOglPerFrameUniformBuffer m_per_frame_ubo;
        
        diguyOglTransformUniformBuffer m_transform_stack_ubo;

        diguyOglMaterialUniformBuffer m_material_ubo;
        
        GLhandleARB m_uniform_transform_buffer_object;
        GLhandleARB m_uniform_material_buffer_object;
        GLhandleARB m_uniform_per_frame_buffer_object;

        virtual void initialize();

        virtual void update();
        
        virtual void set_model_matrix(const float * matrix);
        virtual void set_view_matrix(const float * matrix);
        virtual void get_view_matrix(float * matrix, int transpose);

        virtual void set_projection_matrix(const float * matrix);
        virtual void set_texture_matrix(const float * matrix);
        virtual void set_material(const diguyGraphicsMaterial * material);
        virtual void set_material_color(float r, float g, float b, float a);
        virtual void set_material_spec(float r, float g, float b, float shine);

        virtual void set_fog(const  diguyViewFog * fog);

        virtual void set_global_ambient_light(float r, float g, float b);
        virtual void set_eye_position(float x, float y, float z);

        virtual void set_use_global_ambient_material(int val){ m_use_global_ambient_material = val; }
        virtual int get_use_global_ambient_material(){ return m_use_global_ambient_material; }

        virtual void set_global_ambient_material(float r, float g, float b);
        virtual void get_global_ambient_material(float *r, float *g, float *b);

        virtual void set_light(int index, const diguyLightRenderDesc * light);
        virtual void set_num_active_lights(int num_lights);
        virtual void set_shadow_map_params(const diguyShadowMapParams * shadow_params);

private:
        int m_per_frame_uniforms_needs_update;
        int m_transform_stack_needs_update;

        const diguyGraphicsMaterial * m_last_material;
        int m_use_global_ambient_material;
        glm::vec4 m_global_ambient_material;
};