vr_server.h

#pragma once
 
#include <cgv/gui/key_event.h>
#include <cgv/gui/throttle_event.h>
#include <cgv/gui/stick_event.h>
#include <cgv/gui/pose_event.h>
#include <cgv/gui/event_handler.h>
#include <vr/vr_kit.h>
#include <cgv/gui/window.h>
#include <cgv/signal/signal.h>
#include <cgv/signal/bool_signal.h>
#include <vr/vr_log.h>
#include <fstream>
 
#include "lib_begin.h"
 
 
namespace cgv {
    namespace gui {
 
        enum VREventTypeFlags
        {
            VRE_NONE = 0,      
            VRE_DEVICE = 1,    
            VRE_STATUS = 2,    
            VRE_KEY = 4,       
            VRE_ONE_AXIS = 8,  
            VRE_TWO_AXES = 16, 
            VRE_ONE_AXIS_GENERATES_KEY =32,
            VRE_TWO_AXES_GENERATES_DPAD = 64, 
            VRE_POSE = 128,    
            VRE_ALL = 255      
        };
 
        enum VRFocus
        {
            VRF_RELEASED = 0,
            VRF_GRAB = 1,
            VRF_EXCLUSIVE = 2,
            VRF_GRAB_EXCLUSIVE = 3,
            VRF_PERMANENT = 4,
            VRF_GRAB_PERMANENT = 5,
            VRF_GRAB_PERMANENT_AND_EXCLUSIVE = 7
        };
 
 
        class CGV_API vr_server
        {
        protected:
            double last_device_scan;
            double device_scan_interval;
            std::vector<void*> vr_kit_handles;
            std::vector<vr::vr_kit_state> last_states;
            std::vector<unsigned> last_time_stamps;
            VREventTypeFlags event_type_flags;
            VRFocus focus_type;
            event_handler* focus;
            std::unordered_map<int, cgv::data::ref_ptr<vr::vr_log>> log_data;
            void emit_events_and_update_state(void* kit_handle, const vr::vr_kit_state& new_state, int kit_index, VREventTypeFlags flags, double time);
            float correct_deadzone_and_precision(float value, const vr::controller_input_config& IC);
            vec2 correct_deadzone_and_precision(const vec2& position, const vr::controller_input_config& IC);
        public:
            vr_server();
            VREventTypeFlags get_event_type_flags() const;
            void set_event_type_flags(VREventTypeFlags flags);
            void set_device_scan_interval(double duration);
            double get_device_scan_interval() const { return device_scan_interval; }
            void check_device_changes(double time);
            void check_and_emit_events(double time);
            bool check_new_state(void* kit_handle, const vr::vr_kit_state& new_state, double time);
            bool check_new_state(void* kit_handle, const vr::vr_kit_state& new_state, double time, VREventTypeFlags flags);
            bool grab_focus(VRFocus focus, event_handler* handler);
            bool release_focus(event_handler* handler);
            bool dispatch(cgv::gui::event& e);
            cgv::signal::bool_signal<cgv::gui::event&> on_event;
            cgv::signal::signal<void*, bool> on_device_change;
            cgv::signal::signal<void*, int, vr::VRStatus, vr::VRStatus> on_status_change;
            void enable_log(const std::string fn="", const bool in_memory_log = true, const int filter=vr::vr_log::F_ALL, const int kit_index = 0);
            void disable_log(const int kit_index=0);
            vr::vr_log& ref_log(const int kit_index=0);
            cgv::data::ref_ptr<vr::vr_log> get_log(const int kit_index=0);
        };
 
        extern CGV_API vr_server& ref_vr_server();
 
 
        extern CGV_API void connect_vr_server(bool connect_only_device_change_to_animation_trigger = true, cgv::gui::window_ptr w = cgv::gui::window_ptr());
    }
}
 
 
#include <cgv/config/lib_end.h>