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 <stereo_view_interactor.h>
 
#include "lib_begin.h"
 
 
enum VRkitVisType
{
        VVT_NONE,
        VVT_SPHERE = 1,
        VVT_MESH = 2,
        VVT_BOTH
};
 
 
 
class CGV_API vr_view_interactor : public stereo_view_interactor, public vr::vr_calibration_base
{
protected:
        ivec4 cgv_viewport;
        void* fbo_handle;
 
        mat3 head_tracker_orientation;
        vec3 head_tracker_position;
 
        float tracking_rotation;
        vec3 tracking_rotation_origin;
        vec3 tracking_origin;
        void calibrate_driver();
        std::string calibration_file_path;
public:
        void set_tracking_rotation(float tr) {
                tracking_rotation = tr;
        }
        float get_tracking_rotation() {
                return tracking_rotation;
        }
        void set_tracking_origin(vec3 ori) {
                tracking_origin = ori;
        }
        vec3 get_tracking_origin() {
                return tracking_origin;
        }
private:
        mat34 start_pose;
public:
        typedef cgv::math::fmat<float,3,4> mat34;
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;
        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<vec4>& spheres, std::vector<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();
 
 
        dvec3 get_view_dir_of_kit(int vr_kit_idx = -1) const;
 
        dvec3 get_view_up_dir_of_kit(int vr_kit_idx = -1) const;
 
        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);
        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); }
        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>