XrInputHandler.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <string>
#include <Engine/Core/OpenXrHelper.h>
#include <openxr/openxr.h>
#include <Engine/Renderer/Headset.h>
 
namespace EngineCore {
    class Engine;
    class Headset;
    class ApplicationContext;
}
 
 
 
namespace Input {
 
#define RIGHT_HAND_DECLARATION(varName) \
    static const std::string r_##varName;
 
#define LEFT_HAND_DECLARATION(varName) \
    static const std::string l_##varName;
 
#define BOTH_HAND_DECLARATION(varName) \
    RIGHT_HAND_DECLARATION(varName)    \
    LEFT_HAND_DECLARATION(varName);

    class ActionProfileBase {
    protected:
 
        static const std::string handLeft;
        static const std::string handRight;
    
        struct ActionProfiles {
            static const std::string simpleControllerInteractionProfile;
            static const std::string oculusTouchInteractionProfile;
        };
 
    public:
        virtual void suggestBindings() = 0;
    };

    class ActionProfileSimpleController : ActionProfileBase {
    public:
        static const std::string actionProfile;
        
        BOTH_HAND_DECLARATION(select_click)
        BOTH_HAND_DECLARATION(menu_click)
        BOTH_HAND_DECLARATION(grip_pose)
        BOTH_HAND_DECLARATION(aim_pose)
 
        void suggestBindings() override;
    };

    class ActionProfileOculusTouchController : ActionProfileBase{
    public:
        static const std::string actionProfile;
        
        // left hand
        LEFT_HAND_DECLARATION(x_click)
        LEFT_HAND_DECLARATION(x_touch)
        LEFT_HAND_DECLARATION(y_click)
        LEFT_HAND_DECLARATION(y_touch)
        LEFT_HAND_DECLARATION(menu_click)
 
        // right hand
        RIGHT_HAND_DECLARATION(a_click)
        RIGHT_HAND_DECLARATION(a_touch)
        RIGHT_HAND_DECLARATION(b_click)
        RIGHT_HAND_DECLARATION(b_touch)
        RIGHT_HAND_DECLARATION(system_click)
 
        // both hands
        BOTH_HAND_DECLARATION(squeeze_value)
        BOTH_HAND_DECLARATION(trigger_value)
        BOTH_HAND_DECLARATION(trigger_touch)
        BOTH_HAND_DECLARATION(trigger_proximity)
        BOTH_HAND_DECLARATION(thumb_resting_surfaces_proximity)
        BOTH_HAND_DECLARATION(thumbstick_click)
        BOTH_HAND_DECLARATION(thumbstick_touch)
        BOTH_HAND_DECLARATION(thumbrest_touch)
        BOTH_HAND_DECLARATION(grip_pose)
        BOTH_HAND_DECLARATION(aim_pose)
        
        // outputs  
        // both hands
        BOTH_HAND_DECLARATION(haptic)
 
    public:
 
        void suggestBindings() override;
 
    };
 
#undef RIGHT_HAND_DECLARATION
#undef LEFT_HAND_DECLARATION
#undef BOTH_HAND_DECLARATION
 
    struct HandPoseInfo {
        glm::mat4 matrix{};
        EngineCore::OpenXrHelper::posef handPose;
 
        XrPath handPath{};
        XrSpace space = XR_NULL_HANDLE;
    };
 
    enum class Hand {
        LEFT = 0,
        RIGHT = 1
    };
 
    class XrInputHandler {
    public:
        XrInputHandler(const EngineCore::Headset* headset, const EngineCore::ApplicationContext* context);
 
        void syncInputs(XrSpace playerSpace, XrTime predictedDisplayTime);
 
        XrSpace getLeftHandSpace();
        XrSpace getRightHandSpace();
 
        HandPoseInfo getHandPoseInfo(Hand hand) const;

        [[nodiscard]] glm::vec2 getRightThumbstick() const { return rightThumbstick_; }

        [[nodiscard]] glm::vec2 getLeftThumbstick() const { return leftThumbstick_; }

        [[nodiscard]] float getTriggerValue(Hand hand) const;

        [[nodiscard]] float getGripValue(Hand hand) const;
 
        std::vector<HandPoseInfo> handPoseInfos;
 
    private:
        XrActionSet defaultActionSet = XR_NULL_HANDLE;
        std::vector<XrPath> handPaths;
 
        XrAction aimPoseAction = XR_NULL_HANDLE;
        XrAction aimPoseLeftHand = XR_NULL_HANDLE;
 
        // Thumbstick actions
        XrAction thumbstickAction_ = XR_NULL_HANDLE;
 
        // Trigger and grip actions
        XrAction triggerAction_ = XR_NULL_HANDLE;
        XrAction gripAction_ = XR_NULL_HANDLE;
 
        // Cached input values
        glm::vec2 rightThumbstick_{0.0f};
        glm::vec2 leftThumbstick_{0.0f};
        float triggerValues_[2] = {0.0f, 0.0f};  // [LEFT, RIGHT]
        float gripValues_[2] = {0.0f, 0.0f};     // [LEFT, RIGHT]
 
        EngineCore::Engine* engine = nullptr;
 
        const EngineCore::Headset* headset = nullptr;
        const EngineCore::ApplicationContext* context = nullptr;
    };
}