ShaderController.cpp

Go to the documentation of this file.

#include "ShaderController.h"

using namespace vis2;

ShaderController::ShaderController(Shader* _shader_program, unsigned int _shader_type)
    :   shader_Ptr (_shader_program), shader_type (_shader_type),
        shader_InVars_setup_done(false), shader_Uniforms_update_done(false),
        vec_diffuse_color(glm::vec3(0.0f, 0.0f, 0.0f)),
        vec_light_pos_0(glm::vec3(0.0f, 0.0f, 0.0f)), vec_light_col_0(glm::vec3(0.0f, 0.0f, 0.0f)),
        vec_light_pos_1(glm::vec3(0.0f, 0.0f, 0.0f)), vec_light_col_1(glm::vec3(0.0f, 0.0f, 0.0f)),
        vec_viewer_pos(glm::vec3(0.0f, 0.0f, 0.0f)), vec_viewer_lookAt(glm::vec3(0.0f, 0.0f, 1.0f)),
        near_plane(1.0f), far_plane(10.0f), 
        use_gauss(1), gauss_kernel_size(3), blur_distance(0),
        masking_color(glm::vec3(0.0f, 0.0f, 0.0f)), exculde_color(glm::vec3(0.0f, 0.0f, 0.0f)),
        masking_tolerance(0.0f), use_prev_pass(0),
        window_w(800.0f), window_h(600.0f),
        depth_peel_bcgrd_col(glm::vec3(0.0f, 0.0f, 0.0f)),
        blend_all_neighb_color(glm::vec3(1.0f, 1.0f, 1.0f))
{
    // initialize the texture loading flags
    for (unsigned int i = 0; i < VIS2_NR_TEXTURE_SLOTS; i++)
    {
        texture_loaded[i] = false;
    }
    // initialize the blending ceofficients for the depth peel (default alpha 0.5)
    depth_peel_blend[0] = 0.5000f;
    depth_peel_blend[1] = 0.2500f;
    depth_peel_blend[2] = 0.1250f;
    depth_peel_blend[3] = 0.1250f;
}

ShaderController::~ShaderController()
{
    // the textures here are destroyed from the caller -> nothing to do
}

int ShaderController::setupShaderInVars(    GLuint _position_buffer_handle,
                                            GLuint _normal_buffer_handle,
                                            GLuint _uv_buffer_handle,
                                            GLuint _index_buffer_handle)
{
    if (!this->shader_Ptr)
        return VIS2_SHADER_INVARS_SETUP_INCOMPLETE;

    try
    {
        // ------------------------- BIND VBOs to VAO ----------------------------------- //
        // create and bind vao
        glGenVertexArrays(1,&vao_handle);
        glBindVertexArray(vao_handle);

        // bind positions
        glBindBuffer(GL_ARRAY_BUFFER,_position_buffer_handle); 
        GLint shader_in_position_handle = glGetAttribLocation(shader_Ptr->program_handle,"position"); 
        glEnableVertexAttribArray(shader_in_position_handle); 
        glVertexAttribPointer(shader_in_position_handle, 3, GL_FLOAT, GL_FALSE, 0, 0); 

        // bind normals
        if (shader_type == VIS2_SHADER_TYPE_BASIC ||
            shader_type == VIS2_SHADER_TYPE_BASIC_TEXTURED ||
            shader_type == VIS2_SHADER_TYPE_PHONG_TEXTURED ||
            shader_type == VIS2_SHADER_TYPE_DEPTH_PEEL)
        {
            glBindBuffer(GL_ARRAY_BUFFER,_normal_buffer_handle);
            GLint shader_in_normal_handle = glGetAttribLocation(shader_Ptr->program_handle,"normal");
            glEnableVertexAttribArray(shader_in_normal_handle);
            glVertexAttribPointer(shader_in_normal_handle, 3, GL_FLOAT, GL_FALSE, 0, 0);
        }

        // bind texture coordinates
        if (shader_type != VIS2_SHADER_TYPE_BASIC && shader_type != VIS2_SHADER_TYPE_SOLID_COLOR)
        {
            glBindBuffer(GL_ARRAY_BUFFER,_uv_buffer_handle);
            GLint shader_in_uv_handle = glGetAttribLocation(shader_Ptr->program_handle,"uv");
            glEnableVertexAttribArray(shader_in_uv_handle);
            glVertexAttribPointer(shader_in_uv_handle, 2, GL_FLOAT, GL_FALSE, 0, 0);
        }

        // bind indices
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _index_buffer_handle);

        // ------------------------- DEACTIVATE ALL BUFFERS ----------------------------- //
        glBindVertexArray(0); // deactivate vao
        glBindBuffer(GL_ARRAY_BUFFER, 0); // deactivate vbo
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // deactivate vbo

        // ---------------------------------- END --------------------------------------- //
        this->shader_InVars_setup_done = true;
        return VIS2_SHADER_INVARS_SETUP_SUCCESS;
    }
    catch( std::exception & e)
    {
        std::cout << "Error during setup of VAO for shader type " << shader_type << ": " << e.what() << std::endl;
        return VIS2_SHADER_INVARS_SETUP_FAIL;
    }


}

void ShaderController::assignTexture(Texture* _texture, const unsigned int _slot)
{
    if (!_texture)
        return;

    if (_slot >= 0 && _slot < VIS2_NR_TEXTURE_SLOTS)
    {
        this->texture_slots[_slot] = _texture;
        this->texture_loaded[_slot] = true;
    }
}

void ShaderController::setLightSource(const glm::vec3 _light_pos, const glm::vec3 _light_col, const unsigned int _slot)
{
    switch(_slot)
    {
    case VIS2_LIGHT_0:
        {
            this->vec_light_pos_0 = _light_pos;
            this->vec_light_col_0 = _light_col;
        }
        break;
    case VIS2_LIGHT_1:
        {
            this->vec_light_pos_1 = _light_pos;
            this->vec_light_col_1 = _light_col;
        }
        break;
    default:
        break;
    }
}

void ShaderController::setViewData(const glm::vec3 _viewer_pos, const glm::vec3 _viewer_lookAt)
{
    this->vec_viewer_pos = _viewer_pos;
    this->vec_viewer_lookAt = _viewer_lookAt;
}

void ShaderController::setNearFar(float _near, float _far)
{
    this->near_plane = _near;
    this->far_plane = _far;
}


void ShaderController::setBlurParams(   const int _use_gaussian,
                                        const int _gauss_kernel_size,
                                        const int _blur_dist)
{
    this->use_gauss = _use_gaussian;
    if (_gauss_kernel_size == 3 || _gauss_kernel_size == 5 || _gauss_kernel_size == 7 || _gauss_kernel_size == 9)
        this->gauss_kernel_size = _gauss_kernel_size;
    this->blur_distance = _blur_dist;
}

void ShaderController::setMaskingParams(    const glm::vec3 _masking_color,
                                            const glm::vec3 _exclude_color,
                                            const float _masking_tolerance,
                                            const int _use_prev_pass)
{
    this->masking_tolerance = _masking_tolerance;
    this->exculde_color = _exclude_color;
    this->masking_color = _masking_color;
    this->use_prev_pass = _use_prev_pass;
}

void ShaderController::setPeelingParams( float _window_w, float _window_h)
{
    this->window_w = _window_w;
    this->window_h = _window_h;
}

void ShaderController::setPeelingBlendParams(const float _alpha, const glm::vec3 _bcgrd_col)
{
    if (_alpha >= 0.0f && _alpha <= 1.0f)
    {
        // blending coefficients = ( A, (1-A)A, (1-A)(1-A)A, (1-A)(1-A)(1-A) )

        this->depth_peel_blend[0] = _alpha;
        this->depth_peel_blend[1] = (1.0f - _alpha);
        this->depth_peel_blend[2] = (1.0f - _alpha) * this->depth_peel_blend[1];
        this->depth_peel_blend[3] = (1.0f - _alpha) * this->depth_peel_blend[2];

        this->depth_peel_blend[1] *= _alpha;
        this->depth_peel_blend[2] *= _alpha;
    }
    this->depth_peel_bcgrd_col = _bcgrd_col;
}

void ShaderController::setBlendAllParams( const glm::vec3 & _neighb_shading_col)
{
    this->blend_all_neighb_color = _neighb_shading_col;
}

int ShaderController::updateShaderUniforms( glm::mat4 & _projectionMatrix,
                                            glm::mat4 & _modelMatrix,
                                            const glm::vec3 & _obj_color,
                                            const glm::vec3 & _contour_color)
{
    
    // check if shader was activated first!
    if (!shader_Ptr || !shader_Ptr->shaderInUse())
        return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;
    
    try
    {
        // ------------------------- PASS UNIFORMS TO SHADER ---------------------------- //

        // MATRICES: geometry-related
        glUniformMatrix4fv( glGetUniformLocation(shader_Ptr->program_handle,"projectionMatrix"),
                            1,
                            GL_FALSE,
                            glm::value_ptr(_projectionMatrix));
        glUniformMatrix4fv( glGetUniformLocation(this->shader_Ptr->program_handle, "modelMatrix"),
                            1,
                            GL_FALSE,
                            glm::value_ptr(_modelMatrix));

        // VECTORS: environment-related
        if (shader_type == VIS2_SHADER_TYPE_PHONG_TEXTURED || shader_type == VIS2_SHADER_TYPE_DEPTH_PEEL)
        {
            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "lightPos_0"),
                        this->vec_light_pos_0.x, this->vec_light_pos_0.y, this->vec_light_pos_0.z);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "lightPos_1"),
                        this->vec_light_pos_1.x, this->vec_light_pos_1.y, this->vec_light_pos_1.z);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "viewerPos"),
                        this->vec_viewer_pos.x, this->vec_viewer_pos.y, this->vec_viewer_pos.z);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "viewerLookAt"),
                        this->vec_viewer_lookAt.x, this->vec_viewer_lookAt.y, this->vec_viewer_lookAt.z);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "lightCol_0"),
                        this->vec_light_col_0.x, this->vec_light_col_0.y, this->vec_light_col_0.z);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "lightCol_1"),
                        this->vec_light_col_1.x, this->vec_light_col_1.y, this->vec_light_col_1.z);

            glUniform1f(glGetUniformLocation(this->shader_Ptr->program_handle, "near"), this->near_plane);
            glUniform1f(glGetUniformLocation(this->shader_Ptr->program_handle, "far"), this->far_plane);

        }

        // OBJECT ATTRIBUTES:
        if (shader_type == VIS2_SHADER_TYPE_SOLID_COLOR)
        {
            // objectColor
            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "objectColor"),
                        _obj_color.x, _obj_color.y, _obj_color.z);

        }

        // DIFFUSE TEXTURES (for shaders needing at least one):
        if (shader_type != VIS2_SHADER_TYPE_BASIC && shader_type != VIS2_SHADER_TYPE_SOLID_COLOR)
        {       
            if (!texture_loaded[VIS2_TEXTURE_DIFFUSE_SLOT])
                return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;

            int tex_unit = VIS2_TEXTURE_DIFFUSE_SLOT;
            texture_slots[VIS2_TEXTURE_DIFFUSE_SLOT]->textureBind(tex_unit);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"diffColorTexture"), tex_unit);
        }

        // TEXTURE FILTERS:
        if (shader_type >= VIS2_SHADER_TYPE_EDGE_DETECT_H && shader_type <= VIS2_SHADER_TYPE_MASK)
        {
            glm::vec2 pixel_size = glm::vec2(1.0 / this->texture_slots[VIS2_TEXTURE_DIFFUSE_SLOT]->getTextureWidth(),
                                             1.0 / this->texture_slots[VIS2_TEXTURE_DIFFUSE_SLOT]->getTextureHeight());
            glUniform2f(glGetUniformLocation(this->shader_Ptr->program_handle, "pixelSize"), pixel_size.x, pixel_size.y);
        }

        // EDGE DETECTION:
        if (shader_type == VIS2_SHADER_TYPE_EDGE_DETECT_H || shader_type == VIS2_SHADER_TYPE_EDGE_DETECT_V)
        {
            // HORIZONTAL + VERTICAL PASS
            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "edgeColor"),
                        _contour_color.x, _contour_color.y, _contour_color.z);

            // VERTICAL PASS            
            if (shader_type == VIS2_SHADER_TYPE_EDGE_DETECT_V)
            {
                if (!texture_loaded[VIS2_TEXTURE_1])
                    return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;

                texture_slots[VIS2_TEXTURE_1]->textureBind(VIS2_TEXTURE_1);
                glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"edgeHrzTexture"), VIS2_TEXTURE_1);
                
            }
        }

        // GAUSSIAN BLUR KERNEL SIZES:
        if (shader_type == VIS2_SHADER_TYPE_BLUR_H || shader_type == VIS2_SHADER_TYPE_BLUR_V)
        {           
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"useGauss"), this->use_gauss);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"kernelSize"), this->gauss_kernel_size);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"blurDist"), this->blur_distance);
        }

        // MASKING PARAMETERS:
        if (shader_type == VIS2_SHADER_TYPE_MASK)
        {
            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "maskingColor"),
                        this->masking_color.x, this->masking_color.y, this->masking_color.z);
            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "excludedColor"),
                        this->exculde_color.x, this->exculde_color.y, this->exculde_color.z);
            glUniform1f(glGetUniformLocation(this->shader_Ptr->program_handle, "toleranceMasking"), this->masking_tolerance);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"usePrevPass"), this->use_prev_pass);

            if (this->use_prev_pass == 1 && !texture_loaded[VIS2_TEXTURE_1])
                return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;

            texture_slots[VIS2_TEXTURE_1]->textureBind(VIS2_TEXTURE_1);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"maskPrevPass"), VIS2_TEXTURE_1);
        }

        // DEPTH PEELING PARAMETERS:
        if (shader_type == VIS2_SHADER_TYPE_DEPTH_PEEL)
        {
            // fragment coordinates are not normalized !!!
            glUniform2f(glGetUniformLocation(this->shader_Ptr->program_handle,"windowSize"), this->window_w, this->window_h);
            
            if (!texture_loaded[VIS2_TEXTURE_1])
                return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;

            texture_slots[VIS2_TEXTURE_1]->textureBind(VIS2_TEXTURE_1);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"depthPrevPassTexture"), VIS2_TEXTURE_1);
        }

        // DEPTH PEELING BLEND PARAMETERS:
        if (shader_type == VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND)
        {
            if (!texture_loaded[VIS2_TEXTURE_1] || !texture_loaded[VIS2_TEXTURE_2])
                return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;

            texture_slots[VIS2_TEXTURE_1]->textureBind(VIS2_TEXTURE_1);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"diffLayer1"), VIS2_TEXTURE_1);
            texture_slots[VIS2_TEXTURE_2]->textureBind(VIS2_TEXTURE_2);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"diffLayer2"), VIS2_TEXTURE_2);

            glUniform4f(glGetUniformLocation(this->shader_Ptr->program_handle, "blendCoeff"),
                        this->depth_peel_blend[0], this->depth_peel_blend[1], this->depth_peel_blend[2], this->depth_peel_blend[3]);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "backgroundColor"),
                        this->depth_peel_bcgrd_col.r, this->depth_peel_bcgrd_col.g, this->depth_peel_bcgrd_col.b);
        }

        // BLENDING PARAMETERS:
        if (shader_type == VIS2_SHADER_TYPE_COMPLEX_BLEND)
        {
            if (!texture_loaded[VIS2_TEXTURE_1] || !texture_loaded[VIS2_TEXTURE_2] ||
                !texture_loaded[VIS2_TEXTURE_3] || !texture_loaded[VIS2_TEXTURE_4])
                return VIS2_SHADER_UNIFORMS_SETUP_INCOMPLETE;

            texture_slots[VIS2_TEXTURE_1]->textureBind(VIS2_TEXTURE_1);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"diffContentTexture"), VIS2_TEXTURE_1);
            texture_slots[VIS2_TEXTURE_2]->textureBind(VIS2_TEXTURE_2);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"maskSelectedTexture"), VIS2_TEXTURE_2);
            texture_slots[VIS2_TEXTURE_3]->textureBind(VIS2_TEXTURE_3);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"maskNeighborsTexture"), VIS2_TEXTURE_3);
            texture_slots[VIS2_TEXTURE_4]->textureBind(VIS2_TEXTURE_4);
            glUniform1i(glGetUniformLocation(this->shader_Ptr->program_handle,"edgesContentTexture"), VIS2_TEXTURE_4);

            glUniform3f(glGetUniformLocation(this->shader_Ptr->program_handle, "neighborColor"),
                this->blend_all_neighb_color.r, this->blend_all_neighb_color.g, this->blend_all_neighb_color.b);
        }
        

        // ---------------------------------- END --------------------------------------- //
        this->shader_Uniforms_update_done = true;
        return VIS2_SHADER_UNIFORMS_SETUP_SUCCESS;
    }
    catch( std::exception & e)
    {
        std::cout << "Error during setup of uniforms for shader type " << shader_type << ": " << e.what() << std::endl;
        return VIS2_SHADER_UNIFORMS_SETUP_FAIL;
    }

}