vr_driver.h

Go to the documentation of this file.

#pragma once
 
#include "vr_kit.h"
#include <string>
#include <map>
 
#include "lib_begin.h"
 
namespace vr {
        
        class CGV_API vr_driver;
 
        class CGV_API vr_calibration_base
        {
        protected:
                void set_driver_calibration_matrix(vr_driver* driver, const float calibration_matrix[12]) const;
        public:
                vr_calibration_base();
        };
 
 
        class CGV_API vr_driver
        {
        private:
                unsigned driver_index;
        protected:
                void set_index(unsigned _idx);
                friend void CGV_API register_driver(vr_driver* vrd);
                void register_vr_kit(void* handle, vr_kit* kit);
                void replace_vr_kit(void* handle, vr_kit* kit);
        private:
                std::map<std::string, vr_trackable_state> tracking_reference_states;
                mutable std::map<std::string, vr_trackable_state> calibrated_tracking_reference_states;
        protected:
                friend class vr_kit;
                mutable vr_tracking_system_info tracking_system_info;
                vr_trackable_state& ref_tracking_reference_state(const std::string& serial_nummer);
                void clear_tracking_reference_states();
                void mark_tracking_references_as_untracked();
        private:
                float calibration_matrix[12];
                bool use_calibration_matrix;
        protected:
                void set_calibration_transformation(const float new_transformation_matrix[12]);
                friend class vr_calibration_base;
                vr_driver();
        public:
                virtual ~vr_driver();
                virtual std::string get_driver_name() const = 0;
                virtual bool is_installed() const = 0;
                virtual std::vector<void*> scan_vr_kits() = 0;
                virtual vr_kit* replace_by_index(int& index, vr_kit* new_kit_ptr) = 0;
                virtual bool replace_by_pointer(vr_kit* old_kit_ptr, vr_kit* new_kit_ptr) = 0;
 
                void put_x_direction(float* x_dir) const;
                virtual void put_up_direction(float* up_dir) const = 0;
                virtual float get_floor_level() const = 0;
                virtual float get_action_zone_height() const = 0;
                virtual void put_action_zone_bounary(std::vector<float>& boundary) const = 0;
 
                void put_calibration_transformation(float transformation_matrix[12]) const;
                void calibrate_pose(float(&pose)[12]) const;
                void enable_calibration_transformation();
                void disable_calibration_transformation();
                bool is_calibration_transformation_enabled() const;
 
 
                virtual const std::map<std::string, vr_trackable_state>& get_tracking_reference_states() const;
                virtual const vr_tracking_system_info& get_tracking_system_info() const;
        };
        extern CGV_API std::vector<vr_driver*>& get_vr_drivers();
        extern CGV_API void register_driver(vr_driver* vrd);
        template <typename T>
        struct driver_registry
        {
                driver_registry(const std::string& options)
                {
                        register_driver(new T(options));
                }
        };
 
        extern CGV_API std::vector<void*> scan_vr_kits();
        extern CGV_API vr_kit* replace_by_index(int vr_kit_index, vr_kit* new_kit_ptr);
        extern CGV_API bool replace_by_pointer(vr_kit* old_kit_ptr, vr_kit* new_kit_ptr);
 
        extern CGV_API vr_kit* get_vr_kit(void* vr_kit_handle);
        extern CGV_API bool unregister_vr_kit(void* vr_kit_handle, vr_kit* vr_kit_ptr);
}
 
#include <cgv/config/lib_end.h>