LoaderScene.h

Go to the documentation of this file.

#ifndef __LOADER_SCENE_H__
#define __LOADER_SCENE_H__

#include <cstdio>
#include <vector>
#include <iostream>
#include <string>
#include <vector>
#include <glew.h>
#include <glm/glm.hpp>

#include "geometry/loader/LoaderOBJ.h"
#include "geometry/QuadTextured.h"
#include "geometry/ModelMultiTextured.h"
#include "geometry/NeighborhoodRecord.h"

#include "visualisation/Shader.h"
#include "visualisation/ShaderController.h"
#include "visualisation/Texture.h"
#include "visualisation/FramebufferObject.h"

#define VIS2_SCENE_MAX_NR_LIGHTS         2
#define VIS2_SCENE_MAX_NR_SHELL_OBJ     10
#define VIS2_SCENE_MAX_NR_CONTENT_OBJ   16
#define VIS2_SCENE_MAX_NR_SEPARATOR_OBJ 10

#define VIS2_SCENE_NR_FBOS_EDF           4
#define VIS2_SCENE_MAX_NR_MASKED_NEIGHB  4
#define VIS2_SCENE_NR_FBOS_SMF           VIS2_SCENE_MAX_NR_MASKED_NEIGHB + 3
#define VIS2_SCENE_NR_QUADS_SMF          3
#define VIS2_SCENE_NR_FBOS_DPS           3
#define VIS2_SCENE_NR_FBOS_DPSB          2

#define VIS2_SCENE_OBJECT_TYPE_SHELL     0
#define VIS2_SCENE_OBJECT_TYPE_CONTENT   1
#define VIS2_SCENE_OBJECT_TYPE_SEPARATOR 2

namespace vis2
{

    class LoaderScene
    {
    public:


        LoaderScene(    const std::string & _scene_path,
                        const unsigned int _screen_w,
                        const unsigned int _screen_h);

        ~LoaderScene();


        int loadScene();


        void updateScene(glm::mat4 & _modelMatrix);

        /*  The user input (right-click w. mouse) is used to calculate transparency.
            \param[in] _mouse_right_click : if \b true the user performed a right-click at normalized screen coordinates
            \param[in] _mouse_x and
            \param[in] _mouse_y,
            \param[in] _b_with_pp : if \b true draws scene with post-processing, otherwise - without,
            \param[in] _b_debug_mode : if \b true shows a small quad with the result of render-pass nr
            \param[in] _debug_pass as a diffuse texture.
        */
        void drawScene( bool _mouse_right_click, float _mouse_x, float _mouse_y,
                        bool _b_with_pp, bool _b_debug_mode, unsigned int _debug_pass);

        inline glm::vec3 getBackgrColor() const { return this->backgr_col; }

        inline glm::vec3 getSelectedColor() { return this->selected_col; }

        inline glm::mat4 getProjectionMatrix() { return this->projectionMatrix; }

        inline glm::vec2 getZoomLimits() const { return glm::vec2(0.1f - view_pos.z * 0.5f , - view_pos.z * 2.5f - 20.0f); }

    private:

        LoaderScene( const LoaderScene&);

        // -----------------  functions for SHADER parsing -------------------- //


        void parseShaders(std::FILE* _f);


        void string2Shader( const std::string & _shader_type,
                            const std::string & _vertex_shader_path,
                            const std::string & _geometry_shader_path,
                            const std::string & _fragment_shader_path);

        // ---------  functions for parsing of ENVIRONMENT PARAMETERS --------- //


        void parseEnvironment( std::FILE* _f);


        glm::vec3 string2Vec3(const std::string & _line);


        float string2Float(const std::string & _line);

        // ------------------  functions for GEOMETRY parsing ----------------- //


        void parseGeometry( std::FILE* _f);


        void 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);



        void parseNeighbors( std::FILE* _f);


        void string2Neighbors(  const std::string & _name, const std::string & _neighbors);


        glm::vec3 name2Color(   const std::string & _obj_name);

        // ----------------  functions for FBO and PP setup ------------------- //


        void setupDrawing();
        

        bool setupEDF();

        inline bool shaderEDFLoaded() const
        {
            bool result = (shader_loaded[VIS2_SHADER_TYPE_EDGE_DETECT_H] && shader_loaded[VIS2_SHADER_TYPE_EDGE_DETECT_H]);
            result = result && (shader_loaded[VIS2_SHADER_TYPE_BLUR_H] && shader_loaded[VIS2_SHADER_TYPE_BLUR_V]);
            return result;
        }
        

        bool setupSMF();

        inline bool shaderSMFLoaded() const
        {
            bool result = shader_loaded[VIS2_SHADER_TYPE_MASK];
            result = result && (shader_loaded[VIS2_SHADER_TYPE_BLUR_H] && shader_loaded[VIS2_SHADER_TYPE_BLUR_V]);
            return result;
        }
        

        bool setupDPS();

        inline bool shaderDPSLoaded() const
        {
            bool result = (shader_loaded[VIS2_SHADER_TYPE_PHONG_TEXTURED] && shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL]);
            return result;
        }


        bool setupDPSB();

        inline bool shaderDPSBLoaded() const
        {
            bool result = (shader_loaded[VIS2_SHADER_TYPE_PHONG_TEXTURED] && shader_loaded[VIS2_SHADER_TYPE_DEPTH_PEEL_BLEND]);
            return result;
        }


        glm::vec3 getSelectedColorId(glm::vec3 & _color_in, float _tolerance);

        // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

        // -------------------  paramaters from CALLER ------------------------ //

        const unsigned int screen_width; 
        const unsigned int screen_height; 
        std::string scene_path; 

        glm::vec4 light_pos_0; 
        glm::vec4 light_pos_1; 

        glm::vec3 selected_col; 

        glm::mat4 modelMatrix; 

        // -----------------  paramaters from SCENE FILE ---------------------- //

        // ----------------------  scene environment -------------------------- //
        glm::vec3 backgr_col; 

        glm::vec4 view_pos; 
        glm::vec4 view_pos_lookAt; 

        glm::mat4 projectionMatrix; 

        glm::vec4 light_pos_0_init; 
        glm::vec4 light_pos_1_init; 

        glm::vec3 light_col_0; 
        glm::vec3 light_col_1; 

        glm::vec3 col_edges; 

        // --------------  shader programs and controllers  -------------- //

        bool shader_loaded[VIS2_MAX_NR_SHADER_TYPES]; 
        vis2::Shader* shaders[VIS2_MAX_NR_SHADER_TYPES]; 
        vis2::ShaderController* shader_ctrls[VIS2_MAX_NR_SHADER_TYPES]; 


        // ---------------  geometry objects in the scene ---------------- //

        const glm::mat4 mM_obj; 

        unsigned int counter_shell_obj; 
        bool shells_loaded[VIS2_SCENE_MAX_NR_SHELL_OBJ]; 
        glm::mat4 shells_mM[VIS2_SCENE_MAX_NR_SHELL_OBJ]; 
        vis2::LoaderOBJ* loaders_shell[VIS2_SCENE_MAX_NR_SHELL_OBJ]; 
        vis2::Texture* textures_shell[VIS2_SCENE_MAX_NR_SHELL_OBJ]; 
        vis2::ModelMultiTextured* shells[VIS2_SCENE_MAX_NR_SHELL_OBJ]; 

        unsigned int counter_content_obj; 
        bool contents_loaded[VIS2_SCENE_MAX_NR_CONTENT_OBJ]; 
        glm::mat4 contents_mM[VIS2_SCENE_MAX_NR_CONTENT_OBJ]; 
        vis2::LoaderOBJ* loaders_content[VIS2_SCENE_MAX_NR_CONTENT_OBJ]; 
        vis2::Texture* textures_content[VIS2_SCENE_MAX_NR_CONTENT_OBJ]; 
        vis2::ModelMultiTextured* contents[VIS2_SCENE_MAX_NR_CONTENT_OBJ]; 

        vis2::NeighborhoodRecord* neighb_rec_Ptr;

        unsigned int counter_separator_obj; 
        bool separators_loaded[VIS2_SCENE_MAX_NR_SEPARATOR_OBJ]; 
        glm::mat4 separators_mM[VIS2_SCENE_MAX_NR_SEPARATOR_OBJ]; 
        vis2::LoaderOBJ* loaders_separator[VIS2_SCENE_MAX_NR_SEPARATOR_OBJ]; 
        vis2::Texture* textures_separator[VIS2_SCENE_MAX_NR_SEPARATOR_OBJ]; 
        vis2::ModelMultiTextured* separators[VIS2_SCENE_MAX_NR_SEPARATOR_OBJ]; 

        // ---------  paramaters and objects for POST-PROCESSING -------------- //

        // -------------  Frame Buffer Objects and Textures  ------------------ //
        
        bool FBOs_ready; 
        glm::mat4 orthoMatrix; 

        vis2::FramebufferObject* fbo_0; 

        vis2::FramebufferObject* fbos_EDF[VIS2_SCENE_NR_FBOS_EDF]; 
        vis2::QuadTextured* quads_EDF[VIS2_SCENE_NR_FBOS_EDF]; 

        vis2::FramebufferObject* fbos_SMF[VIS2_SCENE_NR_FBOS_SMF]; 
        vis2::QuadTextured* quads_SMF[VIS2_SCENE_NR_QUADS_SMF]; 

        vis2::FramebufferObject* fbos_DPS[VIS2_SCENE_NR_FBOS_DPS]; 

        vis2::FramebufferObject* fbos_DPSB[VIS2_SCENE_NR_FBOS_DPSB]; 
        vis2::QuadTextured* quad_DPSB_Ptr; 

        vis2::QuadTextured* quad_final_Ptr; 

        vis2::QuadTextured* quad_debug_Ptr; 
        
    };
}


#endif