vr_emulator.h

Go to the documentation of this file.

#pragma once
 
#include <cgv/base/base.h>
#include <cgv/render/drawable.h>
#include <cgv/math/quaternion.h>
#include <cgv/gui/provider.h>
#include <cgv/gui/event_handler.h>
#include <cgv/gui/key_event.h>
#include <vr/vr_kit.h>
#include <vr/vr_driver.h>
 
#include "lib_begin.h"
 
 
class CGV_API vr_emulator;
 
enum TrackerAttachment 
{
    TA_WORLD,
    TA_HEAD,
    TA_LEFT_HAND,
    TA_RIGHT_HAND
};
 
class CGV_API vr_emulated_kit : public vr::vr_kit
{
protected:
    friend class vr_emulator;
    vr::vr_kit_state state;
    typedef cgv::math::quaternion<float> quat;
    float body_direction;
    float body_height;
    float hip_parameter;
    float yaw_parameter;
    float fovy;
    cgv::vec3 body_position;
 
    cgv::vec3 hand_position[2];
    quat hand_orientation[2];
 
    cgv::vec3 tracker_positions[4];
    quat tracker_orientations[4];
    bool tracker_enabled[4];
    TrackerAttachment tracker_attachments[4];
 
    cgv::mat3x4 construct_pos_matrix(const quat& orientation, const cgv::vec3& position);
    cgv::mat4 construct_homogeneous_matrix(const quat& orientation, const cgv::vec3& position);
    void set_pose_matrix(const cgv::mat4& H, float* pose) const;
    void compute_state_poses();
    bool query_state_impl(vr::vr_kit_state& state, int pose_query = 2);
public:
    vr_emulated_kit(float _body_direction, const cgv::vec3& _body_position, float _body_height, unsigned _width, unsigned _height, vr::vr_driver* _driver, void* _handle, const std::string& _name, int _nr_trackers);
    cgv::vec3 get_body_direction() const;
    const std::vector<std::pair<int, int> >& get_controller_throttles_and_sticks(int controller_index) const;
    const std::vector<std::pair<float, float> >& get_controller_throttles_and_sticks_deadzone_and_precision(int controller_index) const;
    bool set_vibration(unsigned controller_index, float low_frequency_strength, float high_frequency_strength);
    void put_eye_to_head_matrix(int eye, float* pose_matrix) const;
    void put_projection_matrix(int eye, float z_near, float z_far, float* projection_matrix, const float* hmd_pose) const;
    void submit_frame();
};
 
enum InteractionMode {
    IM_BODY,
    IM_LEFT_HAND,
    IM_RIGHT_HAND,
    IM_TRACKER_1,
    IM_TRACKER_2,
    IM_TRACKER_3,
    IM_TRACKER_4,
    IM_BASE_1,
    IM_BASE_2,
    IM_BASE_3,
    IM_BASE_4
};
 
class CGV_API vr_emulator : 
    public cgv::base::node, public cgv::render::drawable,
    public vr::vr_driver, public cgv::gui::provider, public cgv::gui::event_handler
{
public:
    std::vector<vr_emulated_kit*> kits;
    static bool gamepad_connected;
    unsigned screen_width, screen_height;
    unsigned counter;
    int nr_trackers = 2;
    cgv::vec3 body_position;
    float body_direction;
    float body_height;
    InteractionMode interaction_mode;
    cgv::quat hand_orientation[2];
 
    // coordinate transform used to emulate a displacement between tracking and world system
    cgv::quat coordinate_rotation;
    cgv::vec3 coordinate_displacement;
    // information used to define reference states
    std::vector<cgv::quat> base_orientations;
    std::vector<cgv::vec3> base_positions;
    std::vector<std::string> base_serials;
    void update_reference_states(int i = -1);
 
protected:
    mutable std::map<std::string, vr::vr_trackable_state> transformed_reference_states;
    
    // emulation
    bool installed;
    float body_speed;
 
    bool left_ctrl, right_ctrl, up_ctrl, down_ctrl;
    bool home_ctrl, end_ctrl, pgup_ctrl, pgdn_ctrl;
    bool is_alt;
 
    void create_tracker_gui(vr_emulated_kit* kit, int i);
    void create_trackable_gui(const std::string& name, vr::vr_trackable_state& ts);
    void create_controller_gui(int i, vr::vr_controller_state& cs);
 
    int current_kit_index;
 
    void add_new_kit();
    void timer_event(double t, double dt);
public:
    vr_emulator();
    void on_set(void* member_ptr);
    std::string get_driver_name() const;
    bool is_installed() const;
    std::vector<void*> scan_vr_kits();
    vr::vr_kit* replace_by_index(int& index, vr::vr_kit* new_kit_ptr);
    bool replace_by_pointer(vr::vr_kit* old_kit_ptr, vr::vr_kit* new_kit_ptr);
    void put_up_direction(float* up_dir) const;
    float get_floor_level() const;
    float get_action_zone_height() const;
    void put_action_zone_bounary(std::vector<float>& boundary) const;
    bool check_for_button_toggle(cgv::gui::key_event& ke, int controller_index, vr::VRButtonStateFlags button, float touch_x = 0.0f, float touch_y = 0.0f);
    bool handle_ctrl_key(cgv::gui::key_event& ke, bool& fst_ctrl, bool* snd_ctrl_ptr = 0);
    bool handle(cgv::gui::event& e);
    void stream_help(std::ostream& os);
    std::string get_type_name() const;
    void stream_stats(std::ostream&);
    bool init(cgv::render::context& ctx);
    void init_frame(cgv::render::context&);
    void draw(cgv::render::context&);
    void finish_frame(cgv::render::context&);
    bool self_reflect(cgv::reflect::reflection_handler& srh);
    void create_gui();
};
 
#include <cgv/config/lib_end.h>