LoaderScene.cpp

Go to the documentation of this file.

#include <fstream>
#include <string>
#include <sstream>
#include "LoaderScene.h"

using namespace vis2;

LoaderScene::LoaderScene(const std::string & _scene_path, const unsigned int _screen_w, const unsigned int _screen_h)
    :   scene_path(_scene_path),
        screen_width(_screen_w), screen_height(_screen_h), backgr_col(glm::vec3(1.0f, 1.0f, 1.0f)), // viewport vars
        view_pos(glm::vec4(0.0f, 0.0f, -1.0f, 1.0f)), view_pos_lookAt(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)), // view vectors
        light_pos_0_init(glm::vec4(-10.0f,  10.0f, -10.0f, 1.0f)), light_col_0(glm::vec3(1.0f, 1.0f, 1.0f)), // light 0 init 
        light_pos_1_init(glm::vec4( 10.0f, -10.0f,  10.0f, 1.0f)), light_col_1(glm::vec3(1.0f, 1.0f, 1.0f)), // light 1 init
        col_edges(glm::vec3(0.0f, 0.0f, 0.0f)), // initial edge color
        mM_obj(glm::rotate(glm::mat4(1.0f), -90.0f, glm::vec3(1.0f, 0.0f, 0.0f))), // initial model matrix
        counter_shell_obj(0), counter_content_obj(0), counter_separator_obj(0),// object counters
        FBOs_ready(false) // readiness for post-processing
{
    // check file extension
    if (_scene_path.size() > 4 && !_scene_path.substr(_scene_path.size()-4).compare(".txt")) {
        
        // initialize loading status for shaders and shader controllers
        for (unsigned int i = 0; i < VIS2_MAX_NR_SHADER_TYPES; i++)
        {
            shader_loaded[i] = false;
        }
        // initialize loading status for geometry objects
        for (unsigned int i = 0; i < VIS2_SCENE_MAX_NR_SHELL_OBJ; i++)
        {
            shells_loaded[i] = false;
        }
        for (unsigned int i = 0; i < VIS2_SCENE_MAX_NR_CONTENT_OBJ; i++)
        {
            contents_loaded[i] = false;
        }
        for (unsigned int i = 0; i < VIS2_SCENE_MAX_NR_SEPARATOR_OBJ; i++)
        {
            separators_loaded[i] = false;
        }
        // initialize neighborhood service
        neighb_rec_Ptr = new vis2::NeighborhoodRecord();
    }
    else
    {
        std::cout << "The valid file extension for a scene file is \"txt\"!" << std::endl;
        system("PAUSE");
        exit(-1);
    }
}

LoaderScene::~LoaderScene()
{
    // delete shaders and shader controllers
    for (unsigned int i = 0; i < VIS2_MAX_NR_SHADER_TYPES; i++)
    {
        if (shader_loaded[i])
        {
            delete shaders[i];
            delete shader_ctrls[i];
        }
    }

    // delete drawable objects
    for (unsigned int i = 0; i < counter_shell_obj; i++)
    {
        if (shells_loaded[i])
        {
            delete loaders_shell[i];
            delete textures_shell[i];
            delete shells[i];
        }
    }
    for (unsigned int i = 0; i < counter_content_obj; i++)
    {
        if (contents_loaded[i])
        {
            delete loaders_content[i];
            delete textures_content[i];
            delete contents[i];
        }
    }
    for (unsigned int i = 0; i < counter_separator_obj; i++)
    {
        if (separators_loaded[i])
        {
            delete loaders_separator[i];
            delete textures_separator[i];
            delete separators[i];
        }
    }

    // delete neighborhood service
    delete neighb_rec_Ptr;

    // delete FBOs
    delete fbo_0;
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_EDF; i++)
    {
        delete fbos_EDF[i];
    }
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_SMF; i++)
    {
        delete fbos_SMF[i];
    }
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_DPS; i++)
    {
        delete fbos_DPS[i];
    }
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_DPSB; i++)
    {
        delete fbos_DPSB[i];
    }

    // delete FBO quads
    if (FBOs_ready)
    {       
        if (shaderEDFLoaded())
        {
            for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_EDF; i++)
            {
                delete quads_EDF[i];
            }
        }
        if (shaderSMFLoaded())
        {
            for (unsigned int i = 0; i < VIS2_SCENE_NR_QUADS_SMF; i++)
            {
                delete quads_SMF[i];
            }
        }
        if (shaderDPSBLoaded()) delete quad_DPSB_Ptr;
        if (shader_loaded[VIS2_SHADER_TYPE_COMPLEX_BLEND]) delete quad_final_Ptr;
        if (shader_loaded[VIS2_SHADER_TYPE_BASIC_TEXTURED]) delete quad_debug_Ptr;
    }

}


int LoaderScene::loadScene()
{
    
    std::cout << "Loading Scene File from ...\"" << scene_path << "\"." << std::endl;
    std::FILE *f;

    // ------------------------------- SHADERS ----------------------------------- //
    
    // open file
    fopen_s(&f,scene_path.c_str(),"r");
    if(!f)
    {
        std::cout << "Failed to open file \"" << scene_path << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    // read and save content
    parseShaders(f);

    // close file
    if (f)
        std::fclose(f);

    // ------------------------------- ENVIRONMENT ------------------------------- //

    fopen_s(&f,scene_path.c_str(),"r");
    if(!f)
    {
        std::cout << "Failed to open file \"" << scene_path << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    parseEnvironment(f);

    if (f)
        std::fclose(f);

    // pass the environment variables to the shader controllers that need them
    if (shader_loaded[VIS2_SHADER_TYPE_PHONG_TEXTURED])
    {
    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->setLightSource(glm::vec3(light_pos_0_init.x, light_pos_0_init.y, light_pos_0_init.z),
                                                                        light_col_0, VIS2_LIGHT_0);
    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->setLightSource(glm::vec3(light_pos_1_init.x, light_pos_1_init.y, light_pos_1_init.z),
                                                                        light_col_1, VIS2_LIGHT_1);
    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->setViewData( glm::vec3(view_pos.x, view_pos.y, view_pos.z),
                                                        glm::vec3(view_pos_lookAt.x, view_pos_lookAt.y, view_pos_lookAt.z));
    }
    if (shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL])
    {
    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->setLightSource(glm::vec3(light_pos_0_init.x, light_pos_0_init.y, light_pos_0_init.z),
                                                                        light_col_0, VIS2_LIGHT_0);
    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->setLightSource(glm::vec3(light_pos_1_init.x, light_pos_1_init.y, light_pos_1_init.z),
                                                                        light_col_1, VIS2_LIGHT_1);
    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->setViewData( glm::vec3(view_pos.x, view_pos.y, view_pos.z),
                                                        glm::vec3(view_pos_lookAt.x, view_pos_lookAt.y, view_pos_lookAt.z));
    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->setPeelingParams(float(this->screen_width), float(this->screen_height));
    }
    if (shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND])
    {
        shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND]->setPeelingBlendParams(0.7f, this->backgr_col);
    }
    if (shader_loaded[VIS2_SHADER_TYPE_COMPLEX_BLEND])
    {
        shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND]->setBlendAllParams(glm::vec3(1.0f, 1.0f, 1.0f));
    }

    // --------------------------------- GEOMETRY -------------------------------- //
    fopen_s(&f,scene_path.c_str(),"r");
    if(!f)
    {
        std::cout << "Failed to open file \"" << scene_path << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    parseGeometry(f);

    if (f)
        std::fclose(f);

    // --------------------------------- NEIGHBORS ------------------------------- //
    fopen_s(&f,scene_path.c_str(),"r");
    if(!f)
    {
        std::cout << "Failed to open file \"" << scene_path << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    parseNeighbors(f);

    if (f)
        std::fclose(f);

    // --------------------- PREPARE FOR RENDERING ------------------------------- //

    setupDrawing();

    return 0;
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ------------------------------ UPDATE -------------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderScene::updateScene(glm::mat4 & _modelMatrix)
{
    // update lights
    this->light_pos_0 = _modelMatrix * light_pos_0_init;
    this->light_pos_1 = _modelMatrix * light_pos_1_init;

    // update geometry
    for (unsigned int i = 0; i < counter_shell_obj; i++)
    {
        if (shells_loaded[i])
            shells[i]->updateModelMatrix(_modelMatrix * shells_mM[i]);
    }
    for (unsigned int i = 0; i < counter_content_obj; i++)
    {
        if (contents_loaded[i])
            contents[i]->updateModelMatrix(_modelMatrix * contents_mM[i]);
    }
    for (unsigned int i = 0; i < counter_separator_obj; i++)
    {
        if (separators_loaded[i])
            separators[i]->updateModelMatrix(_modelMatrix * separators_mM[i]);
    }
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% -------------------------------- DRAW -------------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderScene::drawScene( bool _mouse_right_click, float _mouse_x, float _mouse_y,
                             bool _b_with_pp, bool _b_debug_mode, unsigned int _debug_pass)
{
    unsigned int counter_neighb_sel = 0;
    // %%%%%%%%%%%%%%%%%%%%%%%%%% DRAW TO TEXTURE %%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
    if (FBOs_ready && _b_with_pp)
    {
        // ======== 0. PASS -> for object SELECTION =========================== //
        glDisable(GL_CULL_FACE);
        fbo_0->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 1.0f);
        // draw contents
        for (unsigned int i = 0; i < counter_content_obj; i++)
        {
            if (contents_loaded[i])
                contents[i]->draw(projectionMatrix, VIS2_SHADER_COLORID_SLOT);
        } 
        // get user selection
        if (_mouse_right_click)
        {
            GLfloat selectedCol[4];
            glReadPixels(int(_mouse_x * screen_width),int(_mouse_y * screen_height),1,1,GL_RGBA, GL_FLOAT, selectedCol);
            selected_col = glm::vec3(selectedCol[0], selectedCol[1], selectedCol[2]);
        }
        fbo_0->releaseFramebufferObject();
        glEnable(GL_CULL_FACE);

        // ============= 1A. PASS -> detection of HORIZONTAL EDGES ============ //
        fbos_EDF[0]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_EDGE_DETECT_H]->assignTexture(fbo_0->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        quads_EDF[0]->draw(orthoMatrix, col_edges);
        fbos_EDF[0]->releaseFramebufferObject();

        // ============== 1B. PASS -> detection of VERTICAL EDGES ============= //
        fbos_EDF[1]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_EDGE_DETECT_V]->assignTexture(fbo_0->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_EDGE_DETECT_V]->assignTexture(fbos_EDF[0]->getFBOColorTexture(), VIS2_TEXTURE_1);
        quads_EDF[1]->draw(orthoMatrix, col_edges);
        fbos_EDF[1]->releaseFramebufferObject();

        // ============== 1C. PASS -> HORIZONTAL FILTERING of edges ============ //
        fbos_EDF[2]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_H]->assignTexture(fbos_EDF[1]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_H]->setBlurParams(1,3,11); // Gaussian blur
        quads_EDF[2]->draw(orthoMatrix);
        fbos_EDF[2]->releaseFramebufferObject();

        // ============== 1D. PASS -> VERTICAL FILTERING of edges ============== //
        fbos_EDF[3]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_V]->assignTexture(fbos_EDF[2]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_V]->setBlurParams(1,3,11); // Gaussian blur
        quads_EDF[3]->draw(orthoMatrix);
        fbos_EDF[3]->releaseFramebufferObject();

        // ============== 2A. PASS -> MASKING of SELECTION ===================== //
        fbos_SMF[0]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_MASK]->assignTexture(fbo_0->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_MASK]->assignTexture(fbo_0->getFBOColorTexture(), VIS2_TEXTURE_1);
        shader_ctrls[VIS2_SHADER_TYPE_MASK]->setMaskingParams(selected_col, backgr_col, 0.03f, 0); // no prev pass texture
        quads_SMF[0]->draw(orthoMatrix);
        fbos_SMF[0]->releaseFramebufferObject();

        // ============== 2B. PASS -> MASKING of NEIGHBORS ===================== //
        glm::vec3 selected_col_id = getSelectedColorId(selected_col, 0.03f); // correct small irregularities in the picked color
        if (selected_col_id.r != backgr_col.r || selected_col_id.g != backgr_col.g || selected_col_id.b != backgr_col.b)
        {
            for (unsigned int i = 0; i < counter_content_obj; i++)
            {
                // look for neighbors
                if (contents_loaded[i])
                {
                    glm::vec3 tmp_col = contents[i]->getIdColor();
                    if (neighb_rec_Ptr->isNeighborOf(selected_col_id, tmp_col) && counter_neighb_sel <= VIS2_SCENE_MAX_NR_MASKED_NEIGHB)
                    {
                        counter_neighb_sel++;
                        if (counter_neighb_sel == 1)
                        {
                            fbos_SMF[1]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
                            shader_ctrls[VIS2_SHADER_TYPE_MASK]->setMaskingParams(tmp_col, backgr_col, 0.03f, 0); // NO prev pass texture
                            quads_SMF[0]->draw(orthoMatrix);
                            fbos_SMF[1]->releaseFramebufferObject();
                        }
                        else
                        {
                            fbos_SMF[counter_neighb_sel]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
                            shader_ctrls[VIS2_SHADER_TYPE_MASK]->assignTexture(fbos_SMF[counter_neighb_sel - 1]->getFBOColorTexture(), VIS2_TEXTURE_1);
                            shader_ctrls[VIS2_SHADER_TYPE_MASK]->setMaskingParams(tmp_col, backgr_col, 0.03f, 1); // USE prev pass texture
                            quads_SMF[0]->draw(orthoMatrix);
                            fbos_SMF[counter_neighb_sel]->releaseFramebufferObject();
                        }
                    }
                }

            }
        }
        // ============== 2C. PASS -> BLURRING OF SELECTION MASK HORIZONTAL ==== //
        fbos_SMF[VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 1]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_H]->assignTexture(fbos_SMF[0]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_H]->setBlurParams(0,3,11); // distance blur
        quads_SMF[1]->draw(orthoMatrix);
        fbos_SMF[VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 1]->releaseFramebufferObject();

        // ============== 2D. PASS -> BLURRING OF SELECTION MASK VERTICAL ===== //
        fbos_SMF[VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 2]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_V]->assignTexture(fbos_SMF[VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 1]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_BLUR_V]->setBlurParams(0,3,11); // distance blur
        quads_SMF[2]->draw(orthoMatrix);
        fbos_SMF[VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 2]->releaseFramebufferObject();

        glDisable(GL_CULL_FACE);
        // ============== 3A. PASS -> RENDER SHELL OBJECTS WITH PHONG ========= //
        fbos_DPS[0]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        if (shader_loaded[VIS2_SHADER_TYPE_PHONG_TEXTURED])
        {
            for (unsigned int i = 0; i < counter_shell_obj; i++)
            {
                if (shells_loaded[i])
                {
                    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->assignTexture(textures_shell[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                    shells[i]->draw(projectionMatrix, VIS2_SHADER_DIFFUSE_SLOT);
                }
            }
        }
        fbos_DPS[0]->releaseFramebufferObject();

        // ============== 3B. PASS -> PEEL 1. LAYER SHELL OBJECTS ============= //
        fbos_DPS[1]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        if (shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL])
        {
            for (unsigned int i = 0; i < counter_shell_obj; i++)
            {
                if (shells_loaded[i])
                {
                    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->assignTexture(textures_shell[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->assignTexture(fbos_DPS[0]->getFBODepthTexture(), VIS2_TEXTURE_1);
                    shells[i]->draw(projectionMatrix, VIS2_SHADER_TRANSP_SLOT);
                }
            }
        }
        fbos_DPS[1]->releaseFramebufferObject();
        
        // ============== 3C. PASS -> PEEL 2. LAYER SHELL OBJECTS ============= //
        fbos_DPS[2]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        if (shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL])
        {
            for (unsigned int i = 0; i < counter_shell_obj; i++)
            {
                if (shells_loaded[i])
                {
                    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->assignTexture(textures_shell[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                    shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->assignTexture(fbos_DPS[1]->getFBODepthTexture(), VIS2_TEXTURE_1);
                    shells[i]->draw(projectionMatrix, VIS2_SHADER_TRANSP_SLOT);
                }
            }
        }
        fbos_DPS[2]->releaseFramebufferObject();
        glEnable(GL_CULL_FACE);

        // ============== 4A. PASS -> BLEND ALL PEELED LAYERS of the shell ==== //
        fbos_DPSB[0]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
        shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND]->assignTexture(fbos_DPS[0]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND]->assignTexture(fbos_DPS[1]->getFBOColorTexture(), VIS2_TEXTURE_1);
        shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND]->assignTexture(fbos_DPS[2]->getFBOColorTexture(), VIS2_TEXTURE_2);
        quad_DPSB_Ptr->draw(orthoMatrix);
        fbos_DPSB[0]->releaseFramebufferObject();

        // ============== 4B. PASS -> render the SELECTED object PHONG ======== //
        unsigned int counter_selected_obj = 0;
        for (unsigned int i = 0; i < counter_content_obj; i++)
        {
            if (contents_loaded[i])
            {
                glm::vec3 tmp_col = contents[i]->getIdColor();
                if (tmp_col.r == selected_col_id.r && tmp_col.g == selected_col_id.g && tmp_col.b == selected_col_id.b)
                {
                    counter_selected_obj++;
                    // bind buffer after 1. found object
                    if (counter_selected_obj == 1)
                        fbos_DPSB[1]->bindFramebufferObject(backgr_col.r, backgr_col.g, backgr_col.b, 0.0f);
                    // render
                    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->assignTexture(textures_content[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                    contents[i]->draw(projectionMatrix, VIS2_SHADER_DIFFUSE_SLOT);
                }
            }
        }
        // render also the separators of the same color id as the selected object(s)
        if (counter_selected_obj > 0)
        {
            for (unsigned int i = 0; i < counter_separator_obj; i++)
            {
                if (separators_loaded[i])
                {
                    glm::vec3 tmp_col = separators[i]->getIdColor();
                    if (tmp_col.r == selected_col_id.r && tmp_col.g == selected_col_id.g && tmp_col.b == selected_col_id.b)
                    {
                        shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->assignTexture(textures_separator[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                        separators[i]->draw(projectionMatrix, VIS2_SHADER_DIFFUSE_SLOT);
                    }
                }
            }
        }
        if (counter_selected_obj > 0)
            fbos_DPSB[1]->releaseFramebufferObject();

        // ============== 5A. PASS -> BLEND ALL TO BACKBUFFER ================= //
        shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND]->assignTexture(fbos_DPSB[0]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
        shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND]->assignTexture(fbos_DPSB[1]->getFBOColorTexture(), VIS2_TEXTURE_1);
        shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND]->assignTexture(fbos_SMF[VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 2]->getFBOColorTexture(), VIS2_TEXTURE_2);
        shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND]->assignTexture(fbos_SMF[counter_neighb_sel]->getFBOColorTexture(), VIS2_TEXTURE_3);
        shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND]->assignTexture(fbos_EDF[2]->getFBOColorTexture(), VIS2_TEXTURE_4);
        quad_final_Ptr->draw(orthoMatrix);

    }
    // %%%%%%%%%%%%%%%%%%%%% DRAW GEOMETRY TO BACKBUFFER %%%%%%%%%%%%%%%%%%%%%% //
    else
    {
        // assign textures to the shader controllers and render
        if (shader_loaded[VIS2_SHADER_TYPE_PHONG_TEXTURED])
        {
            for (unsigned int i = 0; i < counter_content_obj; i++)
            {
                if (contents_loaded[i])
                {
                    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->assignTexture(textures_content[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                    contents[i]->draw(projectionMatrix, VIS2_SHADER_DIFFUSE_SLOT);
                }
            }
        
            for (unsigned int i = 0; i < counter_shell_obj; i++)
            {
                if (shells_loaded[i])
                {
                    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->assignTexture(textures_shell[i], VIS2_TEXTURE_DIFFUSE_SLOT);
                    shells[i]->draw(projectionMatrix, VIS2_SHADER_DIFFUSE_SLOT);
                }
            }

        }
    }

    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% DEBUG %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
    if (FBOs_ready && _b_with_pp && _b_debug_mode)
    {
        // draw the quad for texture visualization
        switch(_debug_pass)
        {
        case 0:
            shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED]->assignTexture(fbo_0->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
            break;
        case 1:
            shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED]->assignTexture(fbos_EDF[VIS2_SCENE_NR_FBOS_EDF-1]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
            break;
        case 2:
            shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED]->assignTexture(fbos_SMF[counter_neighb_sel]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
            break;
        case 3:
            shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED]->assignTexture(fbos_DPS[VIS2_SCENE_NR_FBOS_DPS-1]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
            break;
        case 4:
            shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED]->assignTexture(fbos_DPSB[0]->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
            break;
        default:
            shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED]->assignTexture(fbo_0->getFBOColorTexture(), VIS2_TEXTURE_DIFFUSE_SLOT);
            break;
        }
        quad_debug_Ptr->draw(orthoMatrix);
    }

}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% --------------------------- PARSE SHADERS ---------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderScene::parseShaders(std::FILE* _f)
{
    std::ifstream file_stream(_f);
    std::string file_line;
    while (!file_stream.eof())
    {
        std::getline(file_stream, file_line);
        // ------------------------ EXTRACT SHADERS ----------------------- //
        // Example SHADER:
        // #<object type>   : #shader
        // <shader type>    : 8 (see ShaderController.h)
        // <vertex shader>  : _resources/Shader/text_filter_vert.glsl
        // <geometry shader>: _resources/Shader/text_filter_geom.glsl OR NONE
        // <fragment shader>: _resources/Shader/solid_color_mask_frag.glsl
        if (!file_line.substr(0,7).compare("#shader"))
        {               
            std::string shader_type;        
            std::string vertex_shader_path;
            std::string geometry_shader_path;
            std::string fragment_shader_path;

            std::getline(file_stream, shader_type);
            std::getline(file_stream, vertex_shader_path);
            std::getline(file_stream, geometry_shader_path);
            std::getline(file_stream, fragment_shader_path);

            string2Shader(shader_type, vertex_shader_path, geometry_shader_path, fragment_shader_path);
        }
    }

}


void LoaderScene::string2Shader(    const std::string & _shader_type,
                                    const std::string & _vertex_shader_path,
                                    const std::string & _geometry_shader_path,
                                    const std::string & _fragment_shader_path)
{
    if (_shader_type.empty() ||
        _vertex_shader_path.empty()   || _vertex_shader_path.size() < 5 ||
        _geometry_shader_path.empty() || _geometry_shader_path.size() < 4 ||
        _fragment_shader_path.empty() || _fragment_shader_path.size() < 5)
        return;

    // extract type
    unsigned int type;
    std::stringstream type_ss(_shader_type);
    if ((type_ss>>type).fail())
        return;

    // create shader and its controller
    if (type >= 0 && type < VIS2_MAX_NR_SHADER_TYPES)
    {
        shaders[type] = new vis2::Shader(_vertex_shader_path, _fragment_shader_path);
        shader_ctrls[type] = new vis2::ShaderController(shaders[type], type);
        shader_loaded[type] = true;
        std::cout << "SHADER TYPE " << type << " loaded." << std::endl;
    }
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ------------------------- PARSE ENVIRONMENT -------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderScene::parseEnvironment( std::FILE* _f)
{
    unsigned int counter_lights = 0;
    
    // file->stream
    std::ifstream file_stream(_f);
    std::string file_line;
    while (!file_stream.eof())
    {
        std::getline(file_stream, file_line);
        if (!file_line.substr(0,13).compare("#backgr_color"))
        {
            std::string str_color;      
            std::getline(file_stream, str_color);
            this->backgr_col = string2Vec3(str_color);
        }
        else if (!file_line.substr(0,11).compare("#viewer_pos"))
        {
            std::string str_pos;        
            std::getline(file_stream, str_pos);
            glm::vec3 pos_inhomog = string2Vec3(str_pos);
            this->view_pos = glm::vec4(pos_inhomog.x, pos_inhomog.y, pos_inhomog.z, 1.0f);
        }
        else if (!file_line.substr(0,15).compare("#viewer_look_at"))
        {
            std::string str_look_at;        
            std::getline(file_stream, str_look_at);
            glm::vec3 look_at_inhomog = string2Vec3(str_look_at);
            this->view_pos_lookAt = glm::vec4(look_at_inhomog.x, look_at_inhomog.y, look_at_inhomog.z, 1.0f);
        }
        else if (!file_line.substr(0,6).compare("#light"))
        {
            // scip the third light ...
            if (counter_lights > 1)
                continue;
            // otherwise parse
            std::string str_pos;
            std::string str_col;
            std::getline(file_stream, str_pos);
            std::getline(file_stream, str_col);
            if (counter_lights == 0)
            {
                glm::vec3 light_0_pos_inhomog = string2Vec3(str_pos);
                this->light_pos_0_init = glm::vec4(light_0_pos_inhomog.x, light_0_pos_inhomog.y, light_0_pos_inhomog.z, 1.0f);
                this->light_col_0 = string2Vec3(str_col);
            }
            else
            {
                glm::vec3 light_1_pos_inhomog = string2Vec3(str_pos);
                this->light_pos_1_init = glm::vec4(light_1_pos_inhomog.x, light_1_pos_inhomog.y, light_1_pos_inhomog.z, 1.0f);
                this->light_col_1 = string2Vec3(str_col);
            }
            counter_lights++;
        }
        else if (!file_line.substr(0,11).compare("#edge_color"))
        {
            std::string str_color;      
            std::getline(file_stream, str_color);
            this->col_edges = string2Vec3(str_color);
        }
    }
}

glm::vec3 LoaderScene::string2Vec3(const std::string & _line)
{
    // prepare a container for the floats
    glm::vec3 values = glm::vec3(0.0f, 0.0f, 0.0f);
    
    // open a string stream
    std::stringstream line_ss(_line);

    // split the string along the SPACE delimiter
    std::string str_item;
    unsigned int counter = 0;
    while(std::getline(line_ss,str_item,' ') && counter < 3)
    {       
        float num;
        std::stringstream item_ss(str_item);
        if (!(item_ss>>num).fail())
        {
            values[counter] = num;
            counter++;
        }
    }

    return values;
}

float LoaderScene::string2Float(const std::string & _line)
{
    float result = 0.0f;

    float num;
    std::stringstream line_ss(_line);
    if (!(line_ss>>num).fail())
        result = num;

    return result;
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% --------------------------- PARSE GEOMETRY --------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //


void LoaderScene::parseGeometry( std::FILE* _f)
{
    // file->stream
    std::ifstream file_stream(_f);
    std::string file_line;
    while (!file_stream.eof())
    {
        std::getline(file_stream, file_line);
        // ------------------------ EXTRACT GEOMETRY ---------------------- //
        // Example GEOMETRY:
        // #<object type>   : #shell OR #content
        // <name>           : shell
        // <geometry>       : _resources/Models/simple/shell.obj
        // <diff texture>   : _resources/Textures/simple/shell.jpg
        // <scale>          : 0.1
        // <color>          : 0.4 0.0 0.0
        if (!file_line.substr(0,6).compare("#shell"))
        {               
            std::string object_name;        
            std::string geometry_path;
            std::string diff_texture_path;
            std::string scale;
            std::string object_color;

            std::getline(file_stream, object_name);
            std::getline(file_stream, geometry_path);
            std::getline(file_stream, diff_texture_path);
            std::getline(file_stream, scale);
            std::getline(file_stream, object_color);

            string2Geometry( VIS2_SCENE_OBJECT_TYPE_SHELL, object_name, geometry_path, diff_texture_path, scale, object_color);
        }
        else if (!file_line.substr(0,8).compare("#content"))
        {
            std::string object_name;        
            std::string geometry_path;
            std::string diff_texture_path;
            std::string scale;
            std::string object_color;

            std::getline(file_stream, object_name);
            std::getline(file_stream, geometry_path);
            std::getline(file_stream, diff_texture_path);
            std::getline(file_stream, scale);
            std::getline(file_stream, object_color);

            string2Geometry( VIS2_SCENE_OBJECT_TYPE_CONTENT, object_name, geometry_path, diff_texture_path, scale, object_color);
        }
        else if (!file_line.substr(0,10).compare("#separator"))
        {
            std::string object_name;        
            std::string geometry_path;
            std::string diff_texture_path;
            std::string scale;
            std::string object_color;

            std::getline(file_stream, object_name);
            std::getline(file_stream, geometry_path);
            std::getline(file_stream, diff_texture_path);
            std::getline(file_stream, scale);
            std::getline(file_stream, object_color);

            string2Geometry( VIS2_SCENE_OBJECT_TYPE_SEPARATOR, object_name, geometry_path, diff_texture_path, scale, object_color);
        }

    }

    std::cout << "\n\tNR SHELLS: " << counter_shell_obj << std::endl;
    std::cout << "\tNR CONTENTS: " << counter_content_obj << std::endl;
    std::cout << "\tNR SEPARATORS: " << counter_separator_obj << std::endl;

}

void LoaderScene::string2Geometry(  const unsigned int _type,
                                    const std::string & _object_name,
                                    const std::string & _geometry_path,
                                    const std::string & _diff_texture_path,
                                    const std::string & _scale,
                                    const std::string & _object_color)
{
    if (_type != VIS2_SCENE_OBJECT_TYPE_SHELL &&
        _type != VIS2_SCENE_OBJECT_TYPE_CONTENT &&
        _type != VIS2_SCENE_OBJECT_TYPE_SEPARATOR)
        return;
    
    if (_object_name.empty()        ||
        _geometry_path.empty()      || _geometry_path.size() < 5 ||
        _diff_texture_path.empty()  || _diff_texture_path.size() < 5 ||
        _scale.empty()              || _object_color.empty())
        return;

    // copy name
    char* obj_name_copy = new char[_object_name.size()+1];
    sprintf_s(obj_name_copy, _object_name.size()+1, "%s", _object_name.c_str());
    // extract scale
    float obj_scale = string2Float(_scale);
    // extract color
    const glm::vec3 obj_color = string2Vec3(_object_color);
    

    if (_type == VIS2_SCENE_OBJECT_TYPE_SHELL && counter_shell_obj < VIS2_SCENE_MAX_NR_SHELL_OBJ)
    {
        // calculate object model matrix
        shells_mM[counter_shell_obj] = glm::scale(mM_obj, glm::vec3(obj_scale, obj_scale, obj_scale));
        // create loader
        loaders_shell[counter_shell_obj] = new vis2::LoaderOBJ(_geometry_path);
        // get texture
        textures_shell[counter_shell_obj] = new vis2::Texture(_diff_texture_path);
        // create drawable object
        shells[counter_shell_obj] = new vis2::ModelMultiTextured(   obj_name_copy,
                                                                    obj_color,
                                                                    this->col_edges,
                                                                    shells_mM[counter_shell_obj],
                                                                    loaders_shell[counter_shell_obj],
                                                                    shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]);
        shells[counter_shell_obj]->assignShaderController(shader_ctrls[VIS2_SHADER_TYPE_SOLID_COLOR], VIS2_SHADER_COLORID_SLOT);
        shells[counter_shell_obj]->assignShaderController(shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL], VIS2_SHADER_TRANSP_SLOT);
        // mark it as loaded
        shells_loaded[counter_shell_obj] = true;

        std::cout << counter_shell_obj << ": Loaded SHELL object \"" << shells[counter_shell_obj]->getIdName() << "\"." << std::endl;
        counter_shell_obj++;
    }
    else if (_type == VIS2_SCENE_OBJECT_TYPE_CONTENT && counter_content_obj < VIS2_SCENE_MAX_NR_CONTENT_OBJ)
    {
        // calculate object model matrix
        contents_mM[counter_content_obj] = glm::scale(mM_obj, glm::vec3(obj_scale, obj_scale, obj_scale));
        // create loader
        loaders_content[counter_content_obj] = new vis2::LoaderOBJ(_geometry_path);
        // get texture
        textures_content[counter_content_obj] = new vis2::Texture(_diff_texture_path);
        // create drawable object
        contents[counter_content_obj] = new vis2::ModelMultiTextured(   obj_name_copy,
                                                                        obj_color,
                                                                        this->col_edges,
                                                                        contents_mM[counter_content_obj],
                                                                        loaders_content[counter_content_obj],
                                                                        shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]);
        contents[counter_content_obj]->assignShaderController(shader_ctrls[VIS2_SHADER_TYPE_SOLID_COLOR], VIS2_SHADER_COLORID_SLOT);
        contents[counter_content_obj]->assignShaderController(shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED], VIS2_SHADER_TRANSP_SLOT);
        // mark it as loaded
        contents_loaded[counter_content_obj] = true;

        std::cout << counter_content_obj << ": Loaded CONTENTS object \"" << contents[counter_content_obj]->getIdName() << "\"." << std::endl;
        counter_content_obj++;
    }
    else if (_type == VIS2_SCENE_OBJECT_TYPE_SEPARATOR && counter_separator_obj < VIS2_SCENE_MAX_NR_SEPARATOR_OBJ)
    {
        // calculate object model matrix
        separators_mM[counter_separator_obj] = glm::scale(mM_obj, glm::vec3(obj_scale, obj_scale, obj_scale));
        // create loader
        loaders_separator[counter_separator_obj] = new vis2::LoaderOBJ(_geometry_path);
        // get texture
        textures_separator[counter_separator_obj] = new vis2::Texture(_diff_texture_path);
        // create drawable object
        separators[counter_separator_obj] = new vis2::ModelMultiTextured(   obj_name_copy,
                                                                            obj_color,
                                                                            this->col_edges,
                                                                            separators_mM[counter_separator_obj],
                                                                            loaders_separator[counter_separator_obj],
                                                                            shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]);
        separators[counter_separator_obj]->assignShaderController(shader_ctrls[VIS2_SHADER_TYPE_SOLID_COLOR], VIS2_SHADER_COLORID_SLOT);
        separators[counter_separator_obj]->assignShaderController(shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED], VIS2_SHADER_TRANSP_SLOT);
        // mark it as loaded
        separators_loaded[counter_separator_obj] = true;

        std::cout << counter_separator_obj << ": Loaded SEPARATOR object \"" << separators[counter_separator_obj]->getIdName() << "\"." << std::endl;
        counter_separator_obj++;
    }

}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% --------------------------- PARSE NEIGHBORS -------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderScene::parseNeighbors( std::FILE* _f)
{
    // file->stream
    std::ifstream file_stream(_f);
    std::string file_line;
    while (!file_stream.eof())
    {
        std::getline(file_stream, file_line);
        // -------------- EXTRACT NEIGHBORHOOD RELATIONSHIPS -------------- //
        // Example NEIGHBORHOOD:
        // #<object type>   : #neighbors
        // <object name>    : inside_1
        // <neighbors list> : inside_2 inside_3 OR NONE
        if (!file_line.substr(0,10).compare("#neighbors"))
        {
            std::string object_name;        
            std::string neighbors_list;

            std::getline(file_stream, object_name);
            std::getline(file_stream, neighbors_list);

            string2Neighbors( object_name, neighbors_list);
        }
    }

    std::cout << "\nNEIGHTBORS:" << std::endl;
    neighb_rec_Ptr->printNeighbLists();
}

void LoaderScene::string2Neighbors( const std::string & _name, const std::string & _neighbors)
{
    if (_name.empty() || _neighbors.empty() || (!_neighbors.compare("NONE")))
        return;

    // object name -> object color
    glm::vec3 obj_col = name2Color(_name);
    // disregard the background color
    if (obj_col.r == this->backgr_col.r && obj_col.g == this->backgr_col.g && obj_col.b == this->backgr_col.b)
        return;
    // ADD THE COLOR AS MEMBER
    neighb_rec_Ptr->addMember(obj_col);

    // neighbors -> object names -> object colors
    // open a string stream
    std::stringstream neighbors_ss(_neighbors);

    // split the string along the SPACE delimiter
    std::string str_neighb;
    while(std::getline(neighbors_ss,str_neighb,' '))
    {       
        glm::vec3 neighb_col = name2Color(str_neighb);
        // disregard the background color of the object color from above
        if ((neighb_col.r == this->backgr_col.r && neighb_col.g == this->backgr_col.g && neighb_col.b == this->backgr_col.b) ||
            (obj_col.r == neighb_col.r && obj_col.g == neighb_col.g && obj_col.b == neighb_col.b))
        {
            continue;
        }
        else
        {
            // ADD THE COLOR AS MEMBER
            neighb_rec_Ptr->addMember(neighb_col);
            // MARK THEM AS NEIGHBORS (repeats in the neighbor list are handled by NeighborhoodRecord)
            neighb_rec_Ptr->addNeighbor(obj_col, neighb_col);
        }

    }

}

glm::vec3 LoaderScene::name2Color(  const std::string & _obj_name)
{
    glm::vec3 obj_col = this->backgr_col;

    if (_obj_name.empty())
        return obj_col;

    bool obj_name_found = false;
    // look among the shell objects
    for (unsigned int i = 0; i < counter_shell_obj; i++)
    {
        const char* tmp_name = shells[i]->getIdName();
        if (!_obj_name.compare(tmp_name))
        {
            obj_col = shells[i]->getIdColor();
            obj_name_found = true;
            break;
        }
    }
    // look among the contents
    if (!obj_name_found)
    {
        for (unsigned int i = 0; i < counter_content_obj; i++)
        {
            const char* tmp_name = contents[i]->getIdName();
            if (!_obj_name.compare(tmp_name))
            {
                obj_col = contents[i]->getIdColor();
                obj_name_found = true;
                break;
            }
        }
    }
    // look among the separators
    if (!obj_name_found)
    {
        for (unsigned int i = 0; i < counter_separator_obj; i++)
        {
            const char* tmp_name = separators[i]->getIdName();
            if (!_obj_name.compare(tmp_name))
            {
                obj_col = separators[i]->getIdColor();
                obj_name_found = true;
                break;
            }
        }
    }

    return obj_col;
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% --------------------------- SETUP RENDERING -------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderScene::setupDrawing()
{

    // initialize the projection matrix
    this->projectionMatrix = glm::perspective(60.0f,(float)screen_width/(float)screen_height, 0.1f,20.0f);
    this->projectionMatrix = glm::translate(this->projectionMatrix, glm::vec3(this->view_pos.x, this->view_pos.y, this->view_pos.z));
    // communicate to shaders using depth maps for logarithmic depth buffers
    if (shader_loaded[VIS2_SHADER_TYPE_PHONG_TEXTURED])
        shader_ctrls[VIS2_SHADER_TYPE_PHONG_TEXTURED]->setNearFar(0.1f, 20.0f);
    if (shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL])
        shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL]->setNearFar(0.1f, 20.0f);

    // initialize the orthogonal matrix for post-preocessing
    this->orthoMatrix = glm::ortho(0.0f, 1.0f, 1.0f, 0.0f, -1.0f, 1.0f);

    // initialize light positions
    this->light_pos_0 = this->light_pos_0_init;
    this->light_pos_1 = this->light_pos_1_init;

    // set the selected color to the screen background color
    this->selected_col = this->backgr_col;

    // post-processing setup
    FBOs_ready = true;

    // FBO for selecting objects (both color and depth for correct depth test - otherwise brightest col is always visible)
    fbo_0 = new vis2::FramebufferObject(screen_width, screen_height, false);
    FBOs_ready = (fbo_0->getFBOStatus() == VIS2_FBO_SETUP_SUCCESS);

    // FBO setup EDGE DETECTION and FILTERING task (only color)
    FBOs_ready = setupEDF();
    if (!FBOs_ready)
    {
        std::cout << "Edge Detection and Filtering setup failed! No post-processing effects." << std::endl;
        return;
    }

    // FBO setup SELECTION MASKING and FILTERING task (only color)
    FBOs_ready = setupSMF();
    if (!FBOs_ready)
    {
        std::cout << "Selection Masking and Filtering setup failed! No post-processing effects." << std::endl;
        return;
    }

    // FBO setup DEPTH PEELING of SHELL task (both color and depth)
    FBOs_ready = setupDPS();
    if (!FBOs_ready)
    {
        std::cout << "Depth Peeling of Shell setup failed! No post-processing effects." << std::endl;
        return;
    }

    // FBO setup BLENDING of the result of DEPTH PEELING task (both color and depth)
    FBOs_ready = setupDPSB();
    if (!FBOs_ready)
    {
        std::cout << "Blending of the Depth Peeling setup failed! No post-processing effects." << std::endl;
        return;
    }

    // Quad for the final BLENDING
    if (shader_loaded[VIS2_SHADER_TYPE_COMPLEX_BLEND])
        quad_final_Ptr = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_COMPLEX_BLEND], true);
    else
        FBOs_ready = false;

    // DEBUG quad (upper left quarter of viewport)
    if (FBOs_ready && shader_loaded[VIS2_SHADER_TYPE_BASIC_TEXTURED])
        quad_debug_Ptr = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_BASIC_TEXTURED], false);

}


bool LoaderScene::setupEDF()
{
    // FBOs
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_EDF; i++)
    {
        fbos_EDF[i] = new vis2::FramebufferObject(screen_width, screen_height, true);
        if (fbos_EDF[i]->getFBOStatus() != VIS2_FBO_SETUP_SUCCESS)
            return false;
    }

    // Shader controllers and quads
    if (!shaderEDFLoaded())
    {
        return false;
    }
    else
    {
        quads_EDF[0] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_EDGE_DETECT_H], true);
        quads_EDF[1] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_EDGE_DETECT_V], true);

        quads_EDF[2] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_BLUR_H], true);
        quads_EDF[3] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_BLUR_V], true);
    }

    return true;
}

bool LoaderScene::setupSMF()
{
    // FBOs
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_SMF; i++)
    {
        fbos_SMF[i] = new vis2::FramebufferObject(screen_width, screen_height, true);
        if (fbos_SMF[i]->getFBOStatus() != VIS2_FBO_SETUP_SUCCESS)
            return false;
    }

    // Shader controllers and quads
    if (!shaderSMFLoaded())
    {
        return false;
    }
    else
    {
        quads_SMF[0] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_MASK], true);
        quads_SMF[1] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_BLUR_H], true);
        quads_SMF[2] = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_BLUR_V], true);
    }

    return true;
}

bool LoaderScene::setupDPS()
{
    // FBOs
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_DPS; i++)
    {
        fbos_DPS[i] = new vis2::FramebufferObject(screen_width, screen_height, false);
        if (fbos_DPS[i]->getFBOStatus() != VIS2_FBO_SETUP_SUCCESS)
            return false;
    }

    // Shader controllers (no quads necessary -> renders only geometry)
    if (!shaderDPSLoaded())
        return false;

    return true;
}

bool LoaderScene::setupDPSB()
{
    // FBOs
    for (unsigned int i = 0; i < VIS2_SCENE_NR_FBOS_DPSB; i++)
    {
        fbos_DPSB[i] = new vis2::FramebufferObject(screen_width, screen_height, false);
        if (fbos_DPSB[i]->getFBOStatus() != VIS2_FBO_SETUP_SUCCESS)
            return false;
    }

    // Shader controllers (no quads necessary -> renders only geometry)
    if (!shaderDPSBLoaded())
    {
        return false;
    }
    else
        quad_DPSB_Ptr = new vis2::QuadTextured(glm::mat4(1.0f), shader_ctrls[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND], true);

    return true;
}


glm::vec3 LoaderScene::getSelectedColorId(glm::vec3 & _color_in, float _tolerance)
{

    glm::vec3 found_col = this->backgr_col;

    bool found = false;
    for (unsigned int i = 0; i < counter_content_obj; i++)
    {
        if (contents_loaded[i])
        {   
            glm::vec3 tmp_col = contents[i]->getIdColor();
            found = (abs(tmp_col.r - _color_in.r) < _tolerance) &&
                    (abs(tmp_col.g - _color_in.g) < _tolerance) &&
                    (abs(tmp_col.b - _color_in.b) < _tolerance);
            if (found)
            {
                found_col = tmp_col;
                break;
            }
        }
    }

    return found_col;
}