scene_graph_shader_manager.h

Go to the documentation of this file.

/*
 *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 */
 
 
#ifndef H_OGF_SCENE_GRAPH_GFX_SHADERS_SCENE_GRAPH_SHDR_MGR_H
#define H_OGF_SCENE_GRAPH_GFX_SHADERS_SCENE_GRAPH_SHDR_MGR_H
 
#include <OGF/scene_graph_gfx/common/common.h>
#include <OGF/scene_graph_gfx/full_screen_effects/full_screen_effect.h>
#include <OGF/scene_graph/types/properties.h>
#include <map>
 
namespace OGF {
 
    class Grob;
    class Shader;
    class ShaderManager;
    class SceneGraph;
 
    gom_class SCENE_GRAPH_GFX_API SceneGraphShaderManager : public Object {
    public:
 
        SceneGraphShaderManager();
 
        ~SceneGraphShaderManager() override;
 
        void get_grob_shader(
            Grob* grob, std::string& classname,
            ArgList& args, bool pointers = true
        );
 
        void set_grob_shader(
            Grob* grob, const std::string& classname, const ArgList& args
        );
 
 
        Interpreter* interpreter();
 
    gom_slots:
        void update_focus();
 
        void current_object(const std::string& value);
 
        void shader(const std::string& value);
 
        void draw();
 
 
        void pick_object();
 
        void apply_to_scene_graph(bool visible_only = false);
 
        Shader* current();
 
        FullScreenEffect* current_effect();
 
        void full_screen_effect(const std::string& value);
 
 
        ShaderManager* resolve_shader_manager(Grob* grob);
 
    gom_signals:
        void focus_changed(const mat4& value);
 
    gom_properties:
 
        void set_auto_focus(bool value) {
            auto_focus_ = value;
            update_focus();
        }
 
 
        bool get_auto_focus() const {
            return auto_focus_;
        }
 
        void set_highlight_selected(bool value);
 
        bool get_highlight_selected() const {
            return highlight_selected_;
        }
 
        void set_draw_selected_only(bool value);
 
        bool get_draw_selected_only() const {
            return draw_selected_only_;
        }
 
        void set_effect(const FullScreenEffectName& effect);
 
        const FullScreenEffectName& get_effect() const;
 
        const mat4& get_focus_matrix() const {
            return focus_;
        }
 
 
    private:
        SceneGraph* scene_graph_;
 
        Grob* current_object_;
 
        bool auto_focus_;
        mat4 focus_;
 
        bool highlight_selected_;
        bool draw_selected_only_;
 
        std::string last_shader_;
 
        typedef std::map<std::string, FullScreenEffect_var> EffectsMap;
        EffectsMap effects_;
 
        FullScreenEffect* effect_;
        FullScreenEffectName user_effect_name_;
    };
}
 
#endif