vr_view_interactor.h

#pragma once
 
#include <cgv/base/base.h>
#include <vr/vr_kit.h>
#include <cg_vr/vr_server.h>
#include <vr/vr_driver.h>
#include <cgv_gl/box_renderer.h>
#include <cgv_gl/sphere_renderer.h>
#include <cgv_gl/gl/mesh_render_info.h>
#include <plugins/crg_stereo_view/stereo_view_interactor.h>
 
#include "lib_begin.h"


enum VRkitVisType
{
    VVT_NONE,
    VVT_SPHERE = 1,
    VVT_MESH = 2,
    VVT_BOTH
};

extern CGV_API cgv::reflect::enum_reflection_traits<VRkitVisType> get_reflection_traits(const VRkitVisType& gm);


class CGV_API vr_view_interactor : public stereo_view_interactor, public vr::vr_calibration_base
{
protected:
    cgv::ivec4 cgv_viewport;
    void* fbo_handle;


    cgv::mat3 head_tracker_orientation;
    cgv::vec3 head_tracker_position;


    float tracking_rotation;
    cgv::vec3 tracking_rotation_origin;
    cgv::vec3 tracking_origin;
    void calibrate_driver();
    std::string calibration_file_path;
public:
    void set_tracking_rotation(float tr) {
        tracking_rotation = tr;
        calibrate_driver();
    }
    float get_tracking_rotation() {
        return tracking_rotation;
    }
    void set_tracking_origin(cgv::vec3 ori) {
        tracking_origin = ori;
        calibrate_driver();
    }
    cgv::vec3 get_tracking_origin() {
        return tracking_origin;
    }
private:
    cgv::mat3x4 start_pose;
protected:
    bool separate_view;
    bool dont_render_kits;
    bool blit_vr_views;
    // extent of blitting
    int blit_width;
    float blit_aspect_scale;
    int none_separate_view;
    int head_tracker;
    int rendered_eye;
    vr::gl_vr_display* rendered_display_ptr;
    int rendered_display_index;
 
    cgv::gui::VREventTypeFlags event_flags;
 
    // debugging of vr events on console
    bool debug_vr_events;
 
    // visualization of kits and action zone
    VRkitVisType vis_type, hmd_vis_type, controller_vis_type, tracker_vis_type, base_vis_type;
    bool show_action_zone;
    cgv::rgb fence_color1, fence_color2;
    float fence_frequency;
    float fence_line_width;
    
    // current vr kit handle is selected by an integer cast into an enum whos names correspond to the vr kit names
    void* current_vr_handle;
    int current_vr_handle_index;
    std::string kit_enum_definition;
    // list of vr kit states
    std::vector<vr::vr_kit_state> kit_states;
    // list of to be initialized vr kits
    std::vector<void*> new_kits;
    // list of vr kits
    std::vector<void*> kits;
    // list of to be destructed vr kits
    std::vector<void*> old_kits;
    int pose_query;
 
    // render objects
    cgv::render::box_renderer br;
    cgv::render::surface_render_style brs;
    cgv::render::sphere_render_style srs;
 
    // helper members to allow change of mesh file names
    std::string hmd_mesh_file_name, controller_mesh_file_name, tracker_mesh_file_name, base_mesh_file_name;
    // for each mesh type a scale
    float mesh_scales[4];
    vr::vr_kit* get_vr_kit_from_index(int i) const;
    //
    void configure_kits();
    void on_status_change(void* handle, int controller_index, vr::VRStatus old_status, vr::VRStatus new_status);
    virtual void on_device_change(void* handle, bool attach);
    void add_trackable_spheres(const float* pose, int i, std::vector<cgv::vec4>& spheres, std::vector<cgv::rgb>& sphere_colors);
public:
    vr_view_interactor(const char* name);
    std::string get_type_name() const;


    cgv::gui::VREventTypeFlags get_event_type_flags() const;
    void set_event_type_flags(cgv::gui::VREventTypeFlags flags);
    bool vr_event_debugging_enabled() const { return debug_vr_events; }
    void enable_vr_event_debugging(bool enable = true);
    const vr::vr_kit_state* get_current_vr_state() const;
    vr::vr_kit* get_current_vr_kit() const;
    // query vr state
    void query_vr_states();


    cgv::dvec3 get_view_dir_of_kit(int vr_kit_idx = -1) const;

    cgv::dvec3 get_view_up_dir_of_kit(int vr_kit_idx = -1) const;

    cgv::dvec3 get_eye_of_kit(int eye = 0, int vr_kit_idx = -1) const;
    

    bool seperate_view_drawn() const { return separate_view; }
    void draw_separate_view(bool do_draw);
    bool vr_kits_drawn() const { return vis_type != VVT_NONE; }
    void draw_vr_kits(bool do_draw);
    void draw_vr_controllers(bool do_draw);
    bool action_zone_drawn() const { return show_action_zone; }
    void draw_action_zone(bool do_draw);
    bool blit_vr_views_enabled() const { return blit_vr_views; }
    void enable_blit_vr_views(bool enable);
    int get_blit_vr_view_width() const { return blit_width; }
    void set_blit_vr_view_width(int width);


    int get_rendered_eye() const { return rendered_eye; }
    vr::gl_vr_display* get_rendered_display() const { return rendered_display_ptr; }
    vr::vr_kit* get_rendered_vr_kit() const { return static_cast<vr::vr_kit*>(rendered_display_ptr); }
    int get_rendered_vr_kit_index() const { return rendered_display_index; }

    void on_set(void* member_ptr);
    void stream_stats(std::ostream&);
    bool init(cgv::render::context& ctx);
    void clear(cgv::render::context& ctx);
    bool handle_vr_events(cgv::gui::event& e);
    bool handle(cgv::gui::event& e);
    void stream_help(std::ostream& os);
    // render the views for the kits in nested render passes
    void render_vr_kits(cgv::render::context& ctx);
    void init_frame(cgv::render::context&);
    void draw_vr_kits(cgv::render::context& ctx);
    void draw_action_zone(cgv::render::context& ctx);
    void draw(cgv::render::context&);
    void finish_frame(cgv::render::context&);
    void after_finish(cgv::render::context& ctx);
    bool self_reflect(cgv::reflect::reflection_handler& srh);
    void create_gui();
};

 
#include <cgv/config/lib_end.h>