gr_renderable_model.h

Go to the documentation of this file.

/* =========================================================================== *
|
|  Copyright (c) 1994-2008 by Kobus Barnard (author).
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT cs DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
| Authors:
|     Luca Del Pero
|
* =========================================================================== */


#ifndef GR_RENDERABLE_MODEL_H_
#define GR_RENDERABLE_MODEL_H_

#include <gr_cpp/gr_renderable.h>
#include <l_cpp/l_cloneable.h>

namespace kjb
{
    class Base_gl_interface;

    /*
     * @class Renderable_model This class implements basic functionalities for a parametric model
     * with the capability of being renderable. This assumes that a model has some parameters and
     * a representation used for rendering that need to be consistent with the value of
     * the model parameters. Since updating the rendering interface to match the model
     * parameters is usually expensive, we do it only when it is strictly necessary, that is
     * to say before calling any rendering method. This class provides basic rendering
     * methods (wireframe, solid, wireframe with occluded edges removed) that check whether
     * the rendering interface is updated before calling the appropriate rendering method,
     * and update it if it is the case
     */
    class Renderable_model: public Cloneable
    {
    public:

        Renderable_model(bool istatus = false) : Cloneable()
        {
            _rendering_representation_updated = istatus;
        }

        Renderable_model(const Renderable_model & src) : Cloneable()
        {
            (*this) = src;
        }

        inline Renderable_model & operator=(const Renderable_model & /* src */)
        {
            _rendering_representation_updated = false;
            return (*this);
        }

        virtual ~Renderable_model() { }

        virtual void wire_render() const throw(kjb::KJB_error);
        virtual void wire_occlude_render() const throw(kjb::KJB_error);
        virtual void solid_render() const throw(kjb::KJB_error);
        virtual void render_occluded_wireframe() const throw(kjb::KJB_error);

        virtual void silhouette_render(const kjb::Base_gl_interface &, double width = 1.0) const;

        inline void update_if_needed() const
        {
            if(!_rendering_representation_updated)
            {
                update_rendering_representation();
                _rendering_representation_updated = true;
            }
        }

        inline void force_update() const
        {
            update_rendering_representation();
            _rendering_representation_updated = true;
        }

    protected:
        virtual Abstract_renderable & get_rendering_interface() const = 0;

        virtual void update_rendering_representation() const throw(kjb::KJB_error) = 0;

        inline void set_rendering_representation_dirty() const
        {
            _rendering_representation_updated = false;
        }

    private:
        mutable bool _rendering_representation_updated;
    };
}

#endif