grob.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_GROB_H
#define H_OGF_SCENE_GRAPH_TYPES_GROB_H
 
#include <OGF/scene_graph/common/common.h>
#include <OGF/scene_graph/types/properties.h>
#include <OGF/gom/types/node.h>
#include <OGF/basic/math/geometry.h>
 
#include <map>
 
namespace OGF {
 
//_________________________________________________________
 
    class CompositeGrob;
    class SceneGraph;
    class Commands;
    class InputGraphiteFile;
    class OutputGraphiteFile;
    class Interpreter;
 
    gom_attribute(abstract, "true")
    gom_class SCENE_GRAPH_API Grob : public Node {
    public:
 
        Grob(CompositeGrob* parent);
 
         ~Grob() override;
 
 
        const std::string& name() const {
            return name_;
        }
 
        virtual Box3d bbox() const = 0;
 
        virtual Box3d world_bbox() const;
 
        virtual bool is_serializable() const;
 
        virtual bool serialize_read(InputGraphiteFile& geofile);
 
        virtual bool serialize_write(OutputGraphiteFile& geofile);
 
        void set_shader(const std::string& value);
 
 
        void get_shader_and_shader_properties(
            std::string& classname, ArgList& properties, bool pointers=true
        );
 
        void set_shader_and_shader_properties(
            const std::string& classname, const ArgList& properties
        );
 
 
        ArgList& attributes() {
            return grob_attributes_;
        }
 
        const ArgList& attributes() const {
            return grob_attributes_;
        }
 
        bool dirty() const {
            return dirty_;
        }
 
        void up_to_date() {
            dirty_ = false;
        }
 
        bool graphics_are_locked() const {
            return (nb_graphics_locks_ != 0);
        }
 
        void lock_graphics() {
            ++nb_graphics_locks_;
            dirty_ = true;
        }
 
        void unlock_graphics() {
            --nb_graphics_locks_;
        }
 
        static Grob* find(SceneGraph* sg, const std::string& name);
 
 
        virtual Interpreter* interpreter();
 
    gom_slots:
        virtual void update();
 
        virtual void redraw();
 
        SceneGraph* scene_graph() const {
            return scene_graph_;
        }
 
        virtual bool load(const FileName& value);
 
        virtual bool save(const NewFileName& value);
 
        virtual bool append(const FileName& value);
 
        virtual void clear();
 
        virtual void rename(const std::string& value);
 
        virtual Grob* duplicate(SceneGraph* sg);
 
        virtual Object* query_interface(const std::string& name);
 
 
        index_t nb_grob_attributes() const {
            return attributes().nb_args();
        }
 
        const std::string& ith_grob_attribute_name(index_t i) const {
            return attributes().ith_arg_name(i);
        }
 
        std::string ith_grob_attribute_value(index_t i) const {
            return attributes().ith_arg_value(i).as_string();
        }
 
        void set_grob_attribute(
            const std::string& name, const std::string& value
        ) {
            attributes().set_arg(name, value);
        }
 
    gom_signals:
 
        virtual void value_changed(Grob* value);
 
    gom_properties:
 
        const std::string& get_name() const {
            return name_;
        }
 
        void set_filename(const std::string& value) {
            filename_ = value;
        }
 
        const std::string& get_filename() const {
            return filename_;
        }
 
        bool get_visible() const;
 
        void set_visible(bool value);
 
        Object* get_shader() const;
 
        Object* get_shader_manager() const {
            // Stored as Object_var to avoid dependency to Shader
            // return (ShaderManager*)(shader_manager_.get());
            return shader_manager_;
        }
 
        void set_obj_to_world_transform(const mat4& value) {
            obj_to_world_ = value;
        }
 
        const mat4& get_obj_to_world_transform() const {
            return obj_to_world_;
        }
 
    protected:
        void initialize_name(const std::string& name);
 
        void set_shader_manager(Object* s/* ShaderManager* s */) {
            // shader_manager_ = (Object *)s;
            shader_manager_ = s;
        }
 
    protected:
        std::string name_;
        std::string filename_;
        bool visible_;
        SceneGraph* scene_graph_;
        mat4 obj_to_world_;
        Object_var shader_manager_;
        ArgList grob_attributes_;
        bool dirty_;
        index_t nb_graphics_locks_;
 
        friend class SceneGraph;
        friend class SceneGraphShaderManager;
        friend class ShaderManager;
    };
 
    typedef SmartPointer<Grob> Grob_var;
 
//_________________________________________________________
 
}
#endif