vr.h

#ifndef OE_EXT_VR_H
#define OE_EXT_VR_H
 
#include <string>
#include <vector>
#include <memory>
#include <OxygenEngine/util/non_copyable.h>
#include <OxygenEngine/core/window.h>
#include <OxygenEngine/render/texture.h>
 
#include <glm/mat4x4.hpp>
 
// OpenVR Forward declarations
namespace vr
{
    class IVRSystem;
    class IVROverlay;
 
    typedef uint64_t VROverlayHandle_t;
    typedef uint32_t TrackedDeviceIndex_t;
}
 
namespace oe::ext::vr
{
    bool canUseVr();
 
    class TrackedDevice;
 
    class System
    {
        public:
            static System generateForScene();
 
            static System generateForOverlay();
 
            std::unique_ptr<TrackedDevice> getTrackedHmdDevice();
 
            std::unique_ptr<TrackedDevice> getTrackedLeftHandDevice();
 
            std::unique_ptr<TrackedDevice> getTrackedRightHandDevice();
 
            std::vector<std::unique_ptr<TrackedDevice>> getAllTrackedDevices();
 
            friend class TrackedDevice;
 
        private:
            ::vr::IVRSystem* _raw_system = nullptr;
 
            System(const uint32_t& type);
    };
 
    class TrackedDevice
    {
        public:
            TrackedDevice(System* parent);
 
            bool isValid();
 
            std::string getModel();
 
            std::string getSerialNumber();
 
            bool isWireless();
 
            bool isCharging();
            bool isHmd();
 
            float getBatteryCharge();
 
            uint64_t getFirmwareVersion();
            int32_t getUsageTimeSinceFirstStarted();
 
        private:
            ::vr::TrackedDeviceIndex_t _handle = 0;
            System* _parent = nullptr;
 
            friend class System;
            friend class Overlay;
 
        //protected:
          //  TrackedDevice() {};
    };
 
    class Application : public oe::util::NonCopyable
    {
 
    };
 
    class Overlay : public Application
    {
        public:
            Overlay(const std::string& key, const std::string& name = "");
            ~Overlay();
 
            void setRatio(const float& width);
 
            void useStereoRendering(const bool enable = true);
 
            bool isUsingStereoRendering();
 
            void handleEvents(oe::core::EventHandler& event_handler, const glm::ivec2& window_dimensions);
 
            void submitTexture(const std::shared_ptr<oe::render::Texture>& texture);
 
            void bindToDevice(const std::unique_ptr<TrackedDevice>& device, const glm::mat4& matrix = glm::mat4(1.0));
 
        private:
            ::vr::IVROverlay* _manager = nullptr;
            ::vr::VROverlayHandle_t _handle = 0;
    };
 
    class Scene : public Application
    {
        // TODO
    };
}
#endif
 
#ifdef OE_EXT_VR_IMPLEMENTATION
#include <map>
#include <stdexcept>
#include <openvr/openvr.h>
#include <GLFW/glfw3.h>
 
/*static glm::mat4 convertHmd34ToMat4(const ::vr::HmdMatrix34_t& matrix)
{
    return glm::mat4(
        matrix.m[0][0], matrix.m[0][1], matrix.m[0][2], matrix.m[0][3],
        matrix.m[1][0], matrix.m[1][1], matrix.m[1][2], matrix.m[2][3],
        matrix.m[2][0], matrix.m[2][1], matrix.m[2][2], matrix.m[2][3],
        0, 0, 0, 1
    );
}*/
 
static ::vr::HmdMatrix34_t convertMat4ToHmd34(const glm::mat4& matrix)
{
    return {
        matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
        matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
        matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
    };
}
 
bool oe::ext::vr::canUseVr()
{
    return ::vr::VR_IsHmdPresent() && ::vr::VR_IsRuntimeInstalled();
}
 
oe::ext::vr::System::System(const uint32_t& type)
{
    ::vr::EVRInitError err = ::vr::VRInitError_None;
 
    _raw_system = ::vr::VR_Init(&err, (::vr::EVRApplicationType)type);
 
    if (err != ::vr::VRInitError_None)
        throw std::runtime_error(::vr::VR_GetVRInitErrorAsEnglishDescription(err));
 
    if (!::vr::VRCompositor())
        throw std::runtime_error("Unable to initialize VR compositor!\n ");
}
 
oe::ext::vr::System oe::ext::vr::System::generateForScene()
{
    return {::vr::VRApplication_Scene};
}
 
oe::ext::vr::System oe::ext::vr::System::generateForOverlay()
{
    return {::vr::VRApplication_Overlay};
}
 
std::unique_ptr<oe::ext::vr::TrackedDevice> oe::ext::vr::System::getTrackedHmdDevice()
{
    std::unique_ptr<oe::ext::vr::TrackedDevice> result = std::make_unique<TrackedDevice>(this);
 
    result->_handle = ::vr::k_unTrackedDeviceIndex_Hmd;
 
    return result;
}
 
std::unique_ptr<oe::ext::vr::TrackedDevice> oe::ext::vr::System::getTrackedLeftHandDevice()
{
    std::unique_ptr<oe::ext::vr::TrackedDevice> result;
 
    ::vr::TrackedDeviceIndex_t id = _raw_system->GetTrackedDeviceIndexForControllerRole(::vr::TrackedControllerRole_LeftHand);
 
    if (id != ::vr::k_unTrackedDeviceIndexInvalid && id != ::vr::k_unTrackedDeviceIndex_Hmd)
    {
        result = std::make_unique<TrackedDevice>(this);
 
        result->_handle = id;
    }
 
    return result;
}
 
std::unique_ptr<oe::ext::vr::TrackedDevice> oe::ext::vr::System::getTrackedRightHandDevice()
{
    std::unique_ptr<oe::ext::vr::TrackedDevice> result;
 
    ::vr::TrackedDeviceIndex_t id = _raw_system->GetTrackedDeviceIndexForControllerRole(::vr::TrackedControllerRole_RightHand);
 
    if (id != ::vr::k_unTrackedDeviceIndexInvalid && id != ::vr::k_unTrackedDeviceIndex_Hmd)
    {
        result = std::make_unique<TrackedDevice>(this);
 
        result->_handle = id;
    }
 
    return result;
}
 
std::vector<std::unique_ptr<oe::ext::vr::TrackedDevice>> oe::ext::vr::System::getAllTrackedDevices()
{
    std::vector<std::unique_ptr<TrackedDevice>> result;
 
    uint32_t maxTrackedDevices = ::vr::k_unMaxTrackedDeviceCount;
 
    for (unsigned int id = 0; id<maxTrackedDevices; ++id)
    {
        if (_raw_system->GetTrackedDeviceClass(id) == ::vr::TrackedDeviceClass_Invalid)
            continue;
 
        auto device = std::make_unique<TrackedDevice>(this);
 
        device->_handle = id;
 
        result.push_back(std::move(device));
    }
 
    return result;
}
 
bool oe::ext::vr::TrackedDevice::isValid()
{
    return _parent->_raw_system->GetTrackedDeviceClass(_handle) != ::vr::TrackedDeviceClass_Invalid;
}
 
bool oe::ext::vr::TrackedDevice::isHmd()
{
    return _handle == ::vr::k_unTrackedDeviceIndex_Hmd;
}
 
#define GENERATE_OPENVR_GETTER(TYPE, METHOD, PROPERTY) \
TYPE oe::ext::vr::TrackedDevice::METHOD() \
{ \
\
    assert(isValid() && "Device not valid"); \
 \
    ::vr::ETrackedPropertyError error = ::vr::TrackedProp_Success; \
 \
    TYPE result = getPropertyOpenVR<TYPE>(_parent->_raw_system, _handle, ::vr::PROPERTY, &error); \
 \
    /* (Doesn't work : ex. for isWireless an error is thrown but the property is correctly returned)
    if (false && error != ::vr::TrackedProp_Success) \
    { \
        throw std::runtime_error("Cannot fetch property: " + std::to_string(::vr::PROPERTY) + std::string(" ") + _parent->_raw_system->GetPropErrorNameFromEnum(error)); \
    } */\
 \
    return result; \
}
 
template <typename T>
static T getPropertyOpenVR(::vr::IVRSystem* system, ::vr::TrackedDeviceIndex_t handle, ::vr::TrackedDeviceProperty prop, ::vr::TrackedPropertyError *error)
{
    throw std::runtime_error("Unknown Type!");
}
 
template <>
bool getPropertyOpenVR(::vr::IVRSystem* system, ::vr::TrackedDeviceIndex_t handle, ::vr::TrackedDeviceProperty prop, ::vr::TrackedPropertyError* error)
{
    return system->GetBoolTrackedDeviceProperty(handle, prop, error);
}
 
template <>
float getPropertyOpenVR(::vr::IVRSystem* system, ::vr::TrackedDeviceIndex_t handle, ::vr::TrackedDeviceProperty prop, ::vr::TrackedPropertyError* error)
{
    return system->GetFloatTrackedDeviceProperty(handle, prop, error);
}
 
template <>
int32_t getPropertyOpenVR(::vr::IVRSystem* system, ::vr::TrackedDeviceIndex_t handle, ::vr::TrackedDeviceProperty prop, ::vr::TrackedPropertyError* error)
{
    return system->GetInt32TrackedDeviceProperty(handle, prop, error);
}
 
template <>
uint64_t getPropertyOpenVR(::vr::IVRSystem* system, ::vr::TrackedDeviceIndex_t handle, ::vr::TrackedDeviceProperty prop, ::vr::TrackedPropertyError* error)
{
    return system->GetUint64TrackedDeviceProperty(handle, prop, error);
}
 
template <>
std::string getPropertyOpenVR(::vr::IVRSystem* system, ::vr::TrackedDeviceIndex_t handle, ::vr::TrackedDeviceProperty prop, ::vr::TrackedPropertyError* error)
{
    uint32_t bufferLength = system->GetStringTrackedDeviceProperty(handle, prop, NULL, 0, error);
 
    if (bufferLength == 0)
        return "";
 
    char *buffer = new char[bufferLength];
    bufferLength = system->GetStringTrackedDeviceProperty(handle, prop, buffer, bufferLength, error );
 
    std::string result = buffer;
 
    delete[] buffer;
 
    return result;
}
 
GENERATE_OPENVR_GETTER(std::string, getModel, Prop_ModelNumber_String)
GENERATE_OPENVR_GETTER(std::string, getSerialNumber, Prop_SerialNumber_String)
GENERATE_OPENVR_GETTER(bool, isWireless, Prop_DeviceIsWireless_Bool)
GENERATE_OPENVR_GETTER(bool, isCharging, Prop_DeviceIsCharging_Bool)
GENERATE_OPENVR_GETTER(float, getBatteryCharge, Prop_DeviceBatteryPercentage_Float)
GENERATE_OPENVR_GETTER(uint64_t, getFirmwareVersion, Prop_FirmwareVersion_Uint64)
GENERATE_OPENVR_GETTER(int32_t, getUsageTimeSinceFirstStarted, Prop_EstimatedDeviceFirstUseTime_Int32)
 
#undef GENERATE_OPENVR_GETTER
 
oe::ext::vr::Overlay::Overlay(const std::string& key, const std::string& name)
{
    _manager = ::vr::VROverlay();
 
    assert(_manager != nullptr);
 
    _manager->CreateOverlay(key.c_str(), name != "" ? name.c_str() : key.c_str(), &_handle);
    _manager->SetOverlayInputMethod(_handle, ::vr::VROverlayInputMethod_Mouse);
 
    // Set overlay texture bounds to fit an OpenGL texture
    ::vr::VRTextureBounds_t bounds;
    bounds.uMin = 1;
    bounds.uMax = 0;
    bounds.vMin = 1;
    bounds.vMax = 0;
    _manager->SetOverlayTextureBounds(_handle, &bounds );
 
    _manager->SetOverlayFlag(_handle, ::vr::VROverlayFlags_SendVRSmoothScrollEvents, true);
 
    // Todo : Make the overlay able to read input even if dashboard is off
    //_manager->SetOverlayFlag(_handle, ::vr::VROverlayFlags_MakeOverlaysInteractiveIfVisible, true);
 
    _manager->ShowOverlay(_handle);
}
 
oe::ext::vr::Overlay::~Overlay()
{
    ::vr::VR_Shutdown();
}
 
void oe::ext::vr::Overlay::setRatio(const float& meters)
{
    _manager->SetOverlayWidthInMeters(_handle, meters);
}
 
static const std::map<uint32_t, uint32_t> OPENVR_TO_GLFW_MOUSE_BUTTONS = {
    {::vr::VRMouseButton_Left, GLFW_MOUSE_BUTTON_LEFT},
    {::vr::VRMouseButton_Middle, GLFW_MOUSE_BUTTON_MIDDLE},
    {::vr::VRMouseButton_Right, GLFW_MOUSE_BUTTON_RIGHT},
};
 
void oe::ext::vr::Overlay::handleEvents(oe::core::EventHandler& event_handler, const glm::ivec2& window_dimensions)
{
    ::vr::VREvent_t vrEvent;
 
    while (_manager->PollNextOverlayEvent(_handle, &vrEvent, sizeof(vrEvent)))
    {
        //oe::log << "VR Event " << vrEvent.eventType << " on " << vrEvent.trackedDeviceIndex;
 
        switch( vrEvent.eventType )
        {
            case ::vr::VREvent_MouseMove:
            {
                // We need to flip Y because OpenVr send texture uv coordinates of point instead of position
                // Window origin is top-left while texture origin is bottom-left
                event_handler.setCursorPos({window_dimensions.x*vrEvent.data.mouse.x, window_dimensions.y * (1.0f-vrEvent.data.mouse.y)});
            }
            break;
 
            case ::vr::VREvent_ScrollSmooth:
            {
                event_handler.setMouseScroll(vrEvent.data.scroll.viewportscale * glm::vec2(vrEvent.data.scroll.xdelta, vrEvent.data.scroll.ydelta));
            }
            break;
 
            case ::vr::VREvent_MouseButtonDown:
            {
                event_handler.forceState(OPENVR_TO_GLFW_MOUSE_BUTTONS.at(vrEvent.data.mouse.button), true, true);
            }
            break;
 
            case ::vr::VREvent_MouseButtonUp:
            {
                event_handler.forceState(OPENVR_TO_GLFW_MOUSE_BUTTONS.at(vrEvent.data.mouse.button), false, true);
            }
            break;
        }
    }
}
 
void oe::ext::vr::Overlay::bindToDevice(const std::unique_ptr<TrackedDevice>& device, const glm::mat4& matrix)
{
    ::vr::HmdMatrix34_t openvr_matrix = convertMat4ToHmd34(matrix);
 
    _manager->SetOverlayTransformTrackedDeviceRelative(_handle, device->_handle, &openvr_matrix);
}
 
void oe::ext::vr::Overlay::useStereoRendering(const bool enable)
{
    _manager->SetOverlayFlag(_handle, ::vr::VROverlayFlags_SideBySide_Parallel, enable);
}
 
bool oe::ext::vr::Overlay::isUsingStereoRendering()
{
    bool result;
 
    _manager->GetOverlayFlag(_handle, ::vr::VROverlayFlags_SideBySide_Parallel, &result);
 
    return result;
}
 
void oe::ext::vr::Overlay::submitTexture(const std::shared_ptr<oe::render::Texture>& texture)
{
    struct ::vr::Texture_t overlay_texture;
    overlay_texture.eColorSpace = ::vr::ColorSpace_Auto;
    overlay_texture.eType = ::vr::TextureType_OpenGL;
    overlay_texture.handle = reinterpret_cast<uintptr_t*>(texture->getHandle());
 
    _manager->SetOverlayTexture(_handle, &overlay_texture);
}
 
/*oe::ext::vr::System::System()
{
_raw_system
}
 
oe::ext::vr::System::~System()
{
 
}*/
 
oe::ext::vr::TrackedDevice::TrackedDevice(System* parent)
    : _parent(parent)
{}
#endif