scene_graph_library.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_TYPES_SCENE_GRAPH_LIBRARY_H
#define H_OGF_SCENE_GRAPH_TYPES_SCENE_GRAPH_LIBRARY_H
 
#include <OGF/scene_graph/common/common.h>
#include <OGF/gom/reflection/meta.h>
 
#include <geogram/basic/environment.h>
 
#include <map>
 
namespace OGF {
 
    class SceneGraph;
    class SceneGraphShaderManager;
    class SceneGraphToolsManager;
    
    class SCENE_GRAPH_API SceneGraphLibrary : public Environment {
    public:
 
        SceneGraphLibrary();
 
         ~SceneGraphLibrary() override;
 
        static SceneGraphLibrary* instance();
 
        static void initialize();
 
        static void terminate();
 
 
        SceneGraph* scene_graph() {
            return scene_graph_;
        }
 
        const SceneGraph* scene_graph() const {
            return scene_graph_;
        }
        
        SceneGraphToolsManager* scene_graph_tools_manager() {
            return scene_graph_tools_manager_;
        }
        
        void register_grob_type(
            const std::string& grob_class_name, bool abstract=false
        );
 
        void register_grob_read_file_extension(
            const std::string& grob_class_name, const std::string& extension
        );
 
        void register_grob_write_file_extension(
            const std::string& grob_class_name, const std::string& extension
        );
 
        void register_grob_shader(
            const std::string& grob_class_name,
            const std::string& shader_class_name,
            const std::string& shader_user_name=""
        );
 
        void register_grob_tool(
            const std::string& grob_class_name,
            const std::string& tool_class_name
        );
 
 
        void register_grob_interface(
            const std::string& grob_class_name,
            const std::string& interface_class_name
        );
        
        void register_grob_commands(
            const std::string& grob_class_name,
            const std::string& commands_class_name
        );
 
        void register_full_screen_effect(
            const std::string& full_screen_effect_class_name,
            const std::string& user_name=""
        );
 
        std::string file_extension_to_grob(const std::string& extension) const;
 
        bool get_local_value(
            const std::string& name, std::string& value
        ) const override;
 
        bool set_local_value(
            const std::string& name, const std::string& value
        ) override;
 
        std::string default_grob_read_extension(
            const std::string& grob_class_name
        ) const;
 
        std::string default_grob_write_extension(
            const std::string& grob_class_name
        ) const;
 
        const std::string& shader_user_to_classname(
            const std::string& grob_class_name,
            const std::string& shader_user_name
        ) const;
 
        const std::string& shader_classname_to_user(
            const std::string& grob_class_name,
            const std::string& shader_class_name
        ) const;
 
        std::string full_screen_effect_user_to_classname(
            const std::string& full_screen_effect_user_name
        ) const;
 
        const std::string& full_screen_effect_classname_to_user(
            const std::string& full_screen_effect_classname
        ) const;
 
    protected:
        friend class SceneGraph;
        friend class SceneGraphCommandsManager;
        friend class SceneGraphShaderManager;
        friend class SceneGraphToolsManager;
 
 
        void scene_graph_values_changed_notify_environment();
        
        void set_scene_graph(SceneGraph* scene_graph) {
            ogf_assert(scene_graph_ == nullptr);
            scene_graph_ = scene_graph;
        }
 
        void set_scene_graph_shader_manager(
            SceneGraphShaderManager* scene_graph_shader_manager
        ) {
            ogf_assert(scene_graph_shader_manager_ == nullptr);
            scene_graph_shader_manager_ = scene_graph_shader_manager;
        }
 
        void set_scene_graph_tools_manager(
            SceneGraphToolsManager* scene_graph_tools_manager
        ) {
            ogf_assert(scene_graph_tools_manager_ == nullptr);
            scene_graph_tools_manager_ = scene_graph_tools_manager;
        }
        
    private:
        struct GrobInfo {
            GrobInfo(bool abstract_in=false) : abstract(abstract_in) {
            }
            std::vector<std::string> read_file_extensions;
            std::vector<std::string> write_file_extensions;
            std::vector<std::string> shaders;
            std::vector<std::string> shaders_user_names;
            std::vector<std::string> tools;
            std::vector<std::string> commands;
            std::vector<std::string> interfaces;
            bool abstract;
            std::string read_file_extensions_string() const;
            std::string write_file_extensions_string() const;
            std::string shaders_user_names_string() const;
            std::string tools_string() const;
            std::string commands_string() const;
            std::string interfaces_string() const;          
            bool has_read_extension(const std::string& ext) const;
        };
        std::map<std::string, GrobInfo> grob_infos_;
        std::vector<std::string> full_screen_effects_;
        std::vector<std::string> full_screen_effects_user_names_;
        SceneGraph* scene_graph_;
        SceneGraphShaderManager* scene_graph_shader_manager_;
        SceneGraphToolsManager* scene_graph_tools_manager_;
        static SceneGraphLibrary* instance_;
    };
 
//______________________________________________________________________________
 
 
    template <class T> class ogf_register_grob_type {
    public:
        ogf_register_grob_type() {
            SceneGraphLibrary::instance()->register_grob_type(
                ogf_meta<T>::type()->name()
            );            
        }
    };
 
 
    template <class T> class ogf_register_abstract_grob_type {
    public:
        ogf_register_abstract_grob_type() {
            SceneGraphLibrary::instance()->register_grob_type(
                ogf_meta<T>::type()->name(), true
            );            
        }
    };
    
    template <class T> class ogf_register_grob_read_file_extension {
    public:
        ogf_register_grob_read_file_extension(const std::string& extension) {
            SceneGraphLibrary::instance()->register_grob_read_file_extension(
                ogf_meta<T>::type()->name(), extension
            );            
        }
    };
 
    template <class T> class ogf_register_grob_write_file_extension {
    public:
        ogf_register_grob_write_file_extension(const std::string& extension) {
            SceneGraphLibrary::instance()->register_grob_write_file_extension(
                ogf_meta<T>::type()->name(), extension
            );            
        }
    };
 
    template <class T1, class T2> class ogf_register_grob_shader {
    public:
 
        ogf_register_grob_shader(const std::string& shader_user_name="") {
            SceneGraphLibrary::instance()->register_grob_shader(
                ogf_meta<T1>::type()->name(),
                ogf_meta<T2>::type()->name(),
                shader_user_name
            );            
        }
    };
 
    template <class T1, class T2> class ogf_register_grob_interface {
    public:
        
        ogf_register_grob_interface() {
            SceneGraphLibrary::instance()->register_grob_interface(
                ogf_meta<T1>::type()->name(), ogf_meta<T2>::type()->name()
            );            
        }
    };
    
    template <class T1, class T2> class ogf_register_grob_commands {
    public:
        
        ogf_register_grob_commands() {
            SceneGraphLibrary::instance()->register_grob_commands(
                ogf_meta<T1>::type()->name(), ogf_meta<T2>::type()->name()
            );            
        }
    };
 
    template <class T1, class T2> class ogf_register_grob_tool {
    public:
 
        ogf_register_grob_tool() {
            SceneGraphLibrary::instance()->register_grob_tool(
                ogf_meta<T1>::type()->name(), ogf_meta<T2>::type()->name()
            );            
        }
    };
 
    template <class T> class ogf_register_full_screen_effect {
    public:
 
        ogf_register_full_screen_effect(const std::string& user_name="") {
            SceneGraphLibrary::instance()->register_full_screen_effect(
                ogf_meta<T>::type()->name(), user_name
            );            
        }
    };
 
}
 
#endif