gr_renderable.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:
|     Joseph Schlecht, Luca Del Pero, Kyle Simek
|
* =========================================================================== */

#ifndef KJB_RENDERABLE_H
#define KJB_RENDERABLE_H

#include <m_cpp/m_matrix.h>
#include <l_cpp/l_exception.h>

namespace kjb {

class Base_gl_interface;

class Renderable
{
public:
    virtual ~Renderable() { }


    virtual void render() const = 0;
};


class Wire_renderable
{
public:
    virtual ~Wire_renderable() { }


    virtual void wire_render() const = 0;
};

class Solid_renderable
{
public:

    virtual ~Solid_renderable() { }


    virtual void solid_render() const = 0;
};


class Wire_occlude_renderable
{
public:

    virtual ~Wire_occlude_renderable() { }


    virtual void wire_occlude_render() const = 0;
};


class Abstract_renderable : public Renderable,
                            public Solid_renderable,
                            public Wire_renderable,
                            public Wire_occlude_renderable
{
public:

    virtual ~Abstract_renderable() { }

    virtual void render() const
    {
        solid_render();
    }

    static double get_rendering_framework(){ return _rendering_framework; }

    static void set_rendering_framework(unsigned int irf)
    {
        _rendering_framework = irf;
    }

    virtual void render_occluded_wireframe() const
    {
        wire_occlude_render();
        wire_render();
    }

    virtual void silhouette_render(const kjb::Base_gl_interface &, double width) const
    {
        width = width + 0.0; //This is to avoid a warning
        render_occluded_wireframe();
    }

protected:
    enum Rendering_frameworks
    {
        RI_OPENGL
    };

    static unsigned int _rendering_framework;
};

class Generic_renderable :
    public kjb::Abstract_renderable
{
public:

    virtual void wire_render() const;

    virtual void wire_occlude_render() const
    {
        _opengl_offset_edge(0, 0);
    }
    virtual void wire_occlude_render(double offset_factor, double offset_units) const
    {
        _opengl_offset_edge(offset_factor, offset_units);
    }

    virtual void solid_render() const = 0;


    static void set_background_color(const Vector& rgba)
    {
        background_color = rgba;
    }

    static void set_foreground_color(const Vector& rgba)
    {
        foreground_color = rgba;
    }

protected:
    void _opengl_stencil_edge(bool hollow = true) const;

    void _opengl_offset_edge(double offset_factor = 0, double offset_units = 0) const;

private:
    static Vector background_color;
    static Vector foreground_color;
};



class Generic_renderer : public Renderable
{
public:
    Generic_renderer() {}

    Generic_renderer(const Generic_renderable* model) :
        m_model(model)
    {
        IFT(m_model != NULL, Illegal_argument, "Given model is NULL.");
    }

    virtual void render() const
    {
        IFT(m_model != NULL, KJB_error, "Model not set.");
        render(*m_model);
    }

    virtual void render(const Generic_renderable&) const = 0;

    virtual void operator()(const Generic_renderable& model) const
    {
        render(model);
    }
protected:
    const Generic_renderable* m_model;
};

class Renderer : public Generic_renderer
{
public:
    Renderer() : Generic_renderer() {}

    Renderer(const Generic_renderable* model) :
        Generic_renderer(model) {}

    virtual void render(const Generic_renderable& model) const
    {
        model.render();
    }
};

class Wire_renderer : public Generic_renderer
{
public:
    Wire_renderer() : Generic_renderer() {}

    Wire_renderer(const Generic_renderable* model) :
        Generic_renderer(model) {}

    virtual void render(const Generic_renderable& model) const
    {
        model.wire_render();
    }
};

class Wire_occlude_renderer : public Generic_renderer
{
public:
    Wire_occlude_renderer(float offset_factor = 0, float offset_units = 0) :
        Generic_renderer(),
        m_offset_factor(offset_factor),
        m_offset_units(offset_units)
    {}

    Wire_occlude_renderer(const Generic_renderable* model, float offset_factor = 0, float offset_units = 0) :
        Generic_renderer(model),
        m_offset_factor(offset_factor),
        m_offset_units(offset_units)
    {}


    void set_factor(float f) { m_offset_factor = f; }
    void set_units(float u) { m_offset_units = u; }

    virtual void render(const Generic_renderable& model) const
    {
        model.wire_occlude_render(m_offset_factor, m_offset_units);
    }
protected:
    float m_offset_factor;
    float m_offset_units;
};

typedef Wire_occlude_renderer Silhouette_renderer;

class Solid_renderer : public Generic_renderer
{
public:
    Solid_renderer() : Generic_renderer() {}
    Solid_renderer(const Generic_renderable* model) :
        Generic_renderer(model) {}


    void render(const Generic_renderable& model) const
    {
        model.render();
    }
};

class Renderer_renderable : public Generic_renderable
{
public:
    virtual void render(const kjb::Generic_renderer& renderer) const = 0;

    void render() const
    {
        return render(kjb::Solid_renderer());
    }

    void solid_render() const
    {
        return render(kjb::Solid_renderer());
    }

    void wire_renderer() const
    {
        return render(kjb::Wire_renderer());
    }

    void wire_occlude_renderer() const
    {
        return render(kjb::Wire_occlude_renderer());
    }


};

// ///////////////////////////////////////////////////////
//    Multi-view renderables
//
//    These are mostly analagous to the Renderables above,
//    with the additional ability to represent multiple
//    views of a scene, and switch between the active view
//    to be rendered.
// ////////////////////////////////////////////////////////

class Mv_renderable : public Renderable
{
public:

    virtual ~Mv_renderable() { }

    virtual size_t num_views() const = 0;

    virtual void set_active_view(size_t i) const = 0;

    virtual void render() const = 0;
};

class Mv_generic_renderable : public Mv_renderable, public Generic_renderable
{ };


class Mv_wire_occlude_render_wrapper : public Mv_renderable
{
public:
    Mv_wire_occlude_render_wrapper(const Mv_generic_renderable* model,
            float offset_factor = 0, float offset_units = 0) :
        m_model(model),
        m_offset_factor(offset_factor),
        m_offset_units(offset_units)
    { }

    size_t num_views() const { return m_model->num_views(); }
    void set_active_view(size_t i) const { m_model->set_active_view(i); }

    void render() const
    {
        m_model->wire_occlude_render(m_offset_factor, m_offset_units);
    }
public:
    const Mv_generic_renderable* m_model;
    float m_offset_factor;
    float m_offset_units;
};

class Mv_wire_render_wrapper : public Mv_renderable
{
public:
    Mv_wire_render_wrapper(const Mv_generic_renderable* model) :
        m_model(model)
    { }

    size_t num_views() const { return m_model->num_views(); }
    void set_active_view(size_t i) const { m_model->set_active_view(i); }

    void render() const
    {
        m_model->wire_render();
    }
public:
    const Mv_generic_renderable* m_model;
    float m_offset_factor;
    float m_offset_units;
};

class Mv_solid_render_wrapper : public Mv_renderable
{
public:
    Mv_solid_render_wrapper(const Mv_generic_renderable* model) :
        m_model(model)
    { }

    size_t num_views() const { return m_model->num_views(); }
    void set_active_view(size_t i) const { m_model->set_active_view(i); }

    void render() const
    {
        m_model->solid_render();
    }
public:
    const Mv_generic_renderable* m_model;
    float m_offset_factor;
    float m_offset_units;
};

}


#endif