XrInputHandler.h

#pragma once
 
#include <Engine/Core/OpenXrHelper.h>
#include <Engine/Input/XrProfile.h>
#include <Engine/Renderer/Headset.h>
#include <glm/glm.hpp>
#include <openxr/openxr.h>
#include <string>
#include <unordered_map>
#include <vector>

 
namespace Engine
{
    class EngineKern;
}  // namespace Engine
 
namespace Input
{
    enum class Hand
    {
        LEFT  = 0,  
        RIGHT = 1   
    };

    struct HandPoseInfo
    {
        glm::mat4                   matrix{};  
        Engine::OpenXrHelper::posef handPose;  
 
        XrPath  handPath{};              
        XrSpace space = XR_NULL_HANDLE;  
    };

    class XrInputHandler
    {
    public:
        XrInputHandler();

        ~XrInputHandler();

        void bindForSession();

        void rebind();

        void syncInputs();

        XrSpace getLeftHandSpace();

        XrSpace getRightHandSpace();

        [[nodiscard]] HandPoseInfo getHandPoseInfo( Hand hand ) const;

        [[nodiscard]] glm::vec2 getRightThumbstick() const
        {
            return getVec2( "thumbstick", Hand::RIGHT );
        }

        [[nodiscard]] glm::vec2 getLeftThumbstick() const
        {
            return getVec2( "thumbstick", Hand::LEFT );
        }

        [[nodiscard]] float getTriggerValue( Hand hand ) const
        {
            return getFloat( "trigger_value", hand );
        }

        [[nodiscard]] float getGripValue( Hand hand ) const
        {
            return getFloat( "grip_value", hand );
        }

        [[nodiscard]] bool getAButtonPressed() const
        {
            return getBool( "a_button", Hand::RIGHT );
        }

        [[nodiscard]] bool getBButtonPressed() const
        {
            return getBool( "b_button", Hand::RIGHT );
        }

        [[nodiscard]] bool getXButtonPressed() const
        {
            return getBool( "x_button", Hand::LEFT );
        }

        [[nodiscard]] bool getYButtonPressed() const
        {
            return getBool( "y_button", Hand::LEFT );
        }

        [[nodiscard]] bool getBool( const std::string & suffix, Hand hand ) const;

        [[nodiscard]] float getFloat( const std::string & suffix, Hand hand ) const;

        [[nodiscard]] glm::vec2 getVec2( const std::string & suffix, Hand hand ) const;

        void triggerHaptic( Hand hand, float amplitude, float durationSeconds );

        std::vector<HandPoseInfo> handPoseInfos;
 
    private:
        struct XrActionCache
        {
            bool                          active      = false;  
            bool                          boolValue   = false;  
            float                         floatValue  = 0.0f;   
            glm::vec2                     vec2Value   = glm::vec2( 0.0f );  
            XrSpace                       space       = XR_NULL_HANDLE;  
            glm::mat4                     matrix      = glm::mat4( 1.0f );  
            Engine::OpenXrHelper::posef   pose        = {};  
        };

        struct XrActionInfo
        {
            std::string                name;              
            std::string                suffix;            
            XrAction                   handle = XR_NULL_HANDLE;  
            XrInputType                type   = XrInputType::Boolean;  
            std::vector<XrPath>        subactionPaths;    
            std::vector<XrPath>        bindingPaths;      
            std::vector<XrActionCache> cache;             
        };

        void createActions();

        void suggestAllBindings();

        void attachActionSet();

        void createPoseSpaces();

        void detectActiveProfiles();

        void updateAimPoseSpaces();

        const XrActionInfo * findAction( const std::string & suffix, Hand hand, size_t & cacheIndex ) const;
 
        XrActionSet defaultActionSet = XR_NULL_HANDLE;  
        std::vector<XrPath> handPaths;                  
 
        std::unordered_map<std::string, XrActionInfo> actions_;          
        std::vector<const XrProfileDef *>             activeProfiles_;   
 
        bool actionsCreated_      = false;  
        bool actionSetAttached_   = false;  
 
        Engine::EngineKern *                  engine    = nullptr;  
        const Engine::Rendering::Headset *    headset_  = nullptr;  
        const Engine::Core::ApplicationContext * context_ = nullptr;  
    };
}  // namespace Input