overlay.h

#pragma once
 
#include <cgv/data/informed_ptr.h>
#include <cgv/defines/deprecated.h>
#include <cgv/gui/event_handler.h>
#include <cgv/gui/provider.h>
#include <cgv/render/context.h>
#include <cgv/render/drawable.h>
#include <cgv_g2d/trect.h>
#include <cgv_g2d/utils.h>
 
#include <cgv/gui/key_event.h>
#include <cgv/gui/mouse_event.h>
 
#include "lib_begin.h"
 
namespace cgv {
namespace overlay {
 
enum class Alignment {
    kFree,          // alignment solely controlled by margin
    kStart,         // left for horizontal, bottom for vertical direction
    kCenter,        // center of the reference area for both directions
    kEnd,           // right for horizontal, top for vertical direction
    kPercentual,    // alignment based on offset from lower left corner based on percentual size of reference area
};
 
enum class StretchMode {
    kNone,          // size is unchanged
    kHorizontal,    // width is stretched to cover reference area
    kVertical,      // height is stretched to cover reference area
    kCover,         // width and height are stretched to cover reference area
    kPercentual,    // width and height are scaled according to percentual size of reference area
};
 
class CGV_API overlay :
    public cgv::base::node,
    public cgv::render::drawable,
    public cgv::gui::provider,
    public cgv::gui::event_handler
{
public:
    struct gui_options_t {
        std::string heading = "";
        bool create_default_tree_node = true;
        bool show_heading = false;
        bool show_layout_options = true;
        bool allow_alignment = true;
        bool allow_stretch = true;
        bool allow_margin = true;
    };
    gui_options_t gui_options;
 
    virtual bool self_reflect(cgv::reflect::reflection_handler& _rh) { return false; }
 
    virtual void stream_help(std::ostream& os) {};
 
    virtual bool handle(cgv::gui::event& e);
 
    virtual bool handle_key_event(cgv::gui::key_event& e) { return false; };
 
    virtual bool handle_mouse_event(cgv::gui::mouse_event& e, cgv::ivec2 local_mouse_pos) { return false; };
 
    virtual void handle_member_change(cgv::data::informed_ptr ptr) {}
 
    virtual void on_set(void* member_ptr);
 
    bool blocks_events() const { return blocks_events_; }
 
    void blocks_events(bool flag) { blocks_events_ = flag; }
 
    ivec2 get_viewport_size() const { return last_viewport_size_; }
 
    virtual ivec2 get_local_mouse_pos(ivec2 mouse_pos) const;
 
    cgv::g2d::irect get_rectangle() const { return container_; }
 
    cgv::g2d::irect get_local_rectangle() const { return cgv::g2d::irect(ivec2(0), container_.size); }
 
    Alignment get_horizontal_alignment() const { return horizontal_alignment_; }
 
    Alignment get_vertical_alignment() const { return vertical_alignment_; }
 
    vec2 get_percentual_offset() const { return percentual_offset_; }
 
    void set_alignment(Alignment horizontal, Alignment vertical, vec2 percentual_offset = vec2(-1.0f));
 
    StretchMode get_stretch_mode() const { return stretch_; }
 
    vec2 get_percentual_size() const { return percentual_size_; }
 
    void set_stretch_mode(StretchMode stretch, vec2 percentual_size = vec2(-1.0f));
 
    ivec2 get_margin() const { return margin_; }
 
    void set_margin(const ivec2& margin);
 
    void set_size(const ivec2& size);
 
    void set_visibility(bool visible);
 
    void toggle_visibility();
 
    bool ensure_viewport(cgv::render::context& ctx);
 
    bool ensure_layout(cgv::render::context& ctx);
 
    virtual bool is_hit(const ivec2& mouse_pos) const;
 
    bool begin_overlay_gui();
    void end_overlay_gui();
 
    void create_layout_gui();
 
    void create_gui();
 
protected:
    virtual void on_visibility_change();
 
    virtual void on_layout_change();
 
    void update_layout();
 
    virtual void create_gui_impl() {};
 
private:
    ivec2 last_viewport_size_ = ivec2(-1);
    ivec2 last_size_ = ivec2(-1);
    ivec2 last_local_mouse_pos_ = ivec2(-1);
    bool captured_mouse_ = false;
    cgv::g2d::irect container_;
    bool blocks_events_ = false;
 
    Alignment horizontal_alignment_ = Alignment::kStart;
    Alignment vertical_alignment_ = Alignment::kStart;
    StretchMode stretch_ = StretchMode::kNone;
    ivec2 margin_ = ivec2(0);
    vec2 percentual_offset_ = vec2(0.0f);
    vec2 percentual_size_ = vec2(1.0f);
 
    template<typename T>
    data::ref_ptr<cgv::gui::control<T>> add_layout_member_control(const std::string& label, T& value, const std::string& gui_type = "", const std::string& options = "", const std::string& align = "\n") {
        data::ref_ptr<cgv::gui::control<T>> cp = add_control(label, value, gui_type, options, align);
        if(cp)
            connect_copy(cp->value_change, cgv::signal::rebind(this, &overlay::on_layout_change));
        return cp;
    }
};
 
typedef cgv::data::ref_ptr<overlay> overlay_ptr;
 
} // namespace overlay
} // namespace cgv
 
#include <cgv/config/lib_end.h>