XrInputHandler.cpp

Go to the documentation of this file.

#include "Engine/Logging/TracyMacros.hpp"
 
#include <Engine/Core/Engine.h>
#include <Engine/Core/OpenXrHelper.h>
#include <Engine/Input/XrInputHandler.h>
#include <cstring>
 
namespace Input {
 
#define LEFT_HAND_IMPLEMENTATION(className, varName, pathValue)                             \
    const std::string className::l_##varName = ActionProfileBase::handLeft + pathValue;
 
#define RIGHT_HAND_IMPLEMENTATION(className, varName, pathValue)                            \
    const std::string className::r_##varName = ActionProfileBase::handRight + pathValue;
 
#define BOTH_HAND_IMPLEMENTATION(className, varName, pathValue)                             \
    LEFT_HAND_IMPLEMENTATION(className, varName, pathValue)                                 \
    RIGHT_HAND_IMPLEMENTATION(className, varName, pathValue)
 
    // hand paths
    const std::string ActionProfileBase::handLeft = "/user/hand/left";
    const std::string ActionProfileBase::handRight = "/user/hand/right";
 
    // base profile paths
    const std::string ActionProfileBase::ActionProfiles::simpleControllerInteractionProfile = "/interaction_profiles/khr/simple_controller";
    const std::string ActionProfileBase::ActionProfiles::oculusTouchInteractionProfile = "/interaction_profiles/oculus/touch_controller";
 
 
    const std::string ActionProfileSimpleController::actionProfile = ActionProfileBase::ActionProfiles::simpleControllerInteractionProfile;
 
    void ActionProfileSimpleController::suggestBindings()
    {
 
    }
 
    BOTH_HAND_IMPLEMENTATION(ActionProfileSimpleController, select_click, "/input/select/click");
    BOTH_HAND_IMPLEMENTATION(ActionProfileSimpleController, menu_click, "/input/menu/click");
    BOTH_HAND_IMPLEMENTATION(ActionProfileSimpleController, grip_pose, "/input/grip/pose");
    BOTH_HAND_IMPLEMENTATION(ActionProfileSimpleController, aim_pose, "/input/aim/pose");
 
    const std::string ActionProfileOculusTouchController::actionProfile = ActionProfileBase::ActionProfiles::oculusTouchInteractionProfile;
 
    void ActionProfileOculusTouchController::suggestBindings()
    {
 
    }
 
    // Left hand implementations
    LEFT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, x_click, "/input/x/click");
    LEFT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, x_touch, "/input/x/touch");
    LEFT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, y_click, "/input/y/click");
    LEFT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, y_touch, "/input/y/touch");
    LEFT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, menu_click, "/input/menu/click");
 
    // Right hand implementations
    RIGHT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, a_click, "/input/a/click");
    RIGHT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, a_touch, "/input/a/touch");
    RIGHT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, b_click, "/input/b/click");
    RIGHT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, b_touch, "/input/b/touch");
    RIGHT_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, system_click, "/input/system/click");
 
    // Both hands implementations
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, squeeze_value, "/input/squeeze/value");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, trigger_value, "/input/trigger/value");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, trigger_touch, "/input/trigger/touch");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, trigger_proximity, "/input/trigger/proximity");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, thumb_resting_surfaces_proximity, "/input/thumb_resting_surfaces/proximity");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, thumbstick_click, "/input/thumbstick/click");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, thumbstick_touch, "/input/thumbstick/touch");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, thumbrest_touch, "/input/thumbrest/touch");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, grip_pose, "/input/grip/pose");
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, aim_pose, "/input/aim/pose");
 
    // Output (haptic) for both hands
    BOTH_HAND_IMPLEMENTATION(ActionProfileOculusTouchController, haptic, "/output/haptic");
 
    XrInputHandler::XrInputHandler(const EngineCore::Headset* headset, const EngineCore::ApplicationContext* context) : headset(headset), context(context)
    {
#ifdef ENABLE_TRACY
        TRACY_ZONE_SCOPED_FUNCTION;
#endif
        engine = EngineCore::EngineManager::getInstance().getEngineModule();
 
        {
            handPoseInfos.resize(2);
 
            XrPath& leftHandPath = handPoseInfos.at(static_cast<uint32_t>(Hand::LEFT)).handPath;
            XrPath& rightHandPath = handPoseInfos.at(static_cast<uint32_t>(Hand::RIGHT)).handPath;
 
            xrStringToPath(context->getXrInstance(), "/user/hand/left", &leftHandPath);
            xrStringToPath(context->getXrInstance(), "/user/hand/right", &rightHandPath);
            handPaths = { leftHandPath , rightHandPath };
        }
        {
            XrActionSetCreateInfo actionSetCreateInfo{ XR_TYPE_ACTION_SET_CREATE_INFO };
            strcpy(actionSetCreateInfo.actionSetName, "actionset");
            strcpy(actionSetCreateInfo.localizedActionSetName, "Actions");
            actionSetCreateInfo.priority = 0;
 
            PLOG_THROW_FN_XR(xrCreateActionSet(context->getXrInstance(), &actionSetCreateInfo, &defaultActionSet));
        }
        {
            XrActionCreateInfo poseActionCreateInfo{ XR_TYPE_ACTION_CREATE_INFO };
            strcpy(poseActionCreateInfo.actionName, "handpose");
            strcpy(poseActionCreateInfo.localizedActionName, "Hand Pose");
            poseActionCreateInfo.actionType = XR_ACTION_TYPE_POSE_INPUT;
            poseActionCreateInfo.countSubactionPaths = static_cast<uint32_t>(handPaths.size());
            poseActionCreateInfo.subactionPaths = handPaths.data();
 
            PLOG_THROW_FN_XR(xrCreateAction(defaultActionSet, &poseActionCreateInfo, &aimPoseAction));
        }
        // Create thumbstick action (vec2, both hands)
        {
            XrActionCreateInfo thumbstickCreateInfo{ XR_TYPE_ACTION_CREATE_INFO };
            strcpy(thumbstickCreateInfo.actionName, "thumbstick");
            strcpy(thumbstickCreateInfo.localizedActionName, "Thumbstick");
            thumbstickCreateInfo.actionType = XR_ACTION_TYPE_VECTOR2F_INPUT;
            thumbstickCreateInfo.countSubactionPaths = static_cast<uint32_t>(handPaths.size());
            thumbstickCreateInfo.subactionPaths = handPaths.data();
 
            PLOG_THROW_FN_XR(xrCreateAction(defaultActionSet, &thumbstickCreateInfo, &thumbstickAction_));
        }
        // Create trigger action (float, both hands)
        {
            XrActionCreateInfo triggerCreateInfo{ XR_TYPE_ACTION_CREATE_INFO };
            strcpy(triggerCreateInfo.actionName, "trigger");
            strcpy(triggerCreateInfo.localizedActionName, "Trigger");
            triggerCreateInfo.actionType = XR_ACTION_TYPE_FLOAT_INPUT;
            triggerCreateInfo.countSubactionPaths = static_cast<uint32_t>(handPaths.size());
            triggerCreateInfo.subactionPaths = handPaths.data();
 
            PLOG_THROW_FN_XR(xrCreateAction(defaultActionSet, &triggerCreateInfo, &triggerAction_));
        }
        // Create grip/squeeze action (float, both hands)
        {
            XrActionCreateInfo gripCreateInfo{ XR_TYPE_ACTION_CREATE_INFO };
            strcpy(gripCreateInfo.actionName, "grip");
            strcpy(gripCreateInfo.localizedActionName, "Grip");
            gripCreateInfo.actionType = XR_ACTION_TYPE_FLOAT_INPUT;
            gripCreateInfo.countSubactionPaths = static_cast<uint32_t>(handPaths.size());
            gripCreateInfo.subactionPaths = handPaths.data();
 
            PLOG_THROW_FN_XR(xrCreateAction(defaultActionSet, &gripCreateInfo, &gripAction_));
        }
        {
            constexpr XrVector3f defaultVector3f = { 0.0f, 0.0f, 0.0f };
            constexpr XrVector2f defaultVector2f = { 0.0f, 0.0f };
            constexpr XrQuaternionf defaultQuat = { 0.0f, 0.0f, 0.0f, 1.0f };
 
            for (HandPoseInfo& handPoseInfo : handPoseInfos) {
                XrActionSpaceCreateInfo handPoseActionSpaceCreateInfo{ XR_TYPE_ACTION_SPACE_CREATE_INFO };
                handPoseActionSpaceCreateInfo.action = aimPoseAction;
                handPoseActionSpaceCreateInfo.poseInActionSpace.position = defaultVector3f;
                handPoseActionSpaceCreateInfo.poseInActionSpace.orientation = defaultQuat;
                handPoseActionSpaceCreateInfo.subactionPath = handPoseInfo.handPath;
                PLOG_FN_XR(xrCreateActionSpace(headset->getSession(), &handPoseActionSpaceCreateInfo, &handPoseInfo.space));
            }
        }
        // Suggest bindings for simple controller profile (fallback)
        {
            XrPath aimPoseLeftHandPath = {};
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/left/input/aim/pose", &aimPoseLeftHandPath));
 
            XrPath aimPoseRightHandPath = {};
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/right/input/aim/pose", &aimPoseRightHandPath));
 
            std::vector<XrActionSuggestedBinding> actionBindings = {
                { aimPoseAction, aimPoseLeftHandPath },
                { aimPoseAction, aimPoseRightHandPath }
            };
 
            XrPath interactionProfilePath;
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), ActionProfileSimpleController::actionProfile.c_str(), &interactionProfilePath));
 
            XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
            suggestedBindings.interactionProfile = interactionProfilePath;
            suggestedBindings.countSuggestedBindings = static_cast<uint32_t>(actionBindings.size());
            suggestedBindings.suggestedBindings = actionBindings.data();
 
            PLOG_FN_XR(xrSuggestInteractionProfileBindings(context->getXrInstance(), &suggestedBindings));
        }
        // Suggest bindings for Oculus Touch controllers
        {
            XrPath aimPoseLeftPath, aimPoseRightPath;
            XrPath thumbstickLeftPath, thumbstickRightPath;
            XrPath triggerLeftPath, triggerRightPath;
            XrPath gripLeftPath, gripRightPath;
 
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/left/input/aim/pose", &aimPoseLeftPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/right/input/aim/pose", &aimPoseRightPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/left/input/thumbstick", &thumbstickLeftPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/right/input/thumbstick", &thumbstickRightPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/left/input/trigger/value", &triggerLeftPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/right/input/trigger/value", &triggerRightPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/left/input/squeeze/value", &gripLeftPath));
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), "/user/hand/right/input/squeeze/value", &gripRightPath));
 
            std::vector<XrActionSuggestedBinding> oculusBindings = {
                { aimPoseAction, aimPoseLeftPath },
                { aimPoseAction, aimPoseRightPath },
                { thumbstickAction_, thumbstickLeftPath },
                { thumbstickAction_, thumbstickRightPath },
                { triggerAction_, triggerLeftPath },
                { triggerAction_, triggerRightPath },
                { gripAction_, gripLeftPath },
                { gripAction_, gripRightPath }
            };
 
            XrPath oculusProfilePath;
            PLOG_FN_XR(xrStringToPath(context->getXrInstance(), ActionProfileOculusTouchController::actionProfile.c_str(), &oculusProfilePath));
 
            XrInteractionProfileSuggestedBinding oculusSuggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
            oculusSuggestedBindings.interactionProfile = oculusProfilePath;
            oculusSuggestedBindings.countSuggestedBindings = static_cast<uint32_t>(oculusBindings.size());
            oculusSuggestedBindings.suggestedBindings = oculusBindings.data();
 
            PLOG_FN_XR(xrSuggestInteractionProfileBindings(context->getXrInstance(), &oculusSuggestedBindings));
        }
        {
            XrSessionActionSetsAttachInfo attachInfo{ XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO };
            attachInfo.countActionSets = 1;
            attachInfo.actionSets = &defaultActionSet;
            PLOG_FN_XR(xrAttachSessionActionSets(headset->getSession(), &attachInfo));
        }
 
        PLOGI << "Finished xr input handler setup";
    }
 
    void XrInputHandler::syncInputs(XrSpace playerSpace, XrTime predictedDisplayTime)
    {
        XrSession xrSession = headset->getSession();
 
        const XrActiveActionSet activeActionSet{ defaultActionSet, XR_NULL_PATH };
        XrActionsSyncInfo syncInfo{ XR_TYPE_ACTIONS_SYNC_INFO };
        syncInfo.countActiveActionSets = 1;
        syncInfo.activeActionSets = &activeActionSet;
        xrSyncActions(xrSession, &syncInfo);
 
        // Sync hand poses
        for (size_t i = 0; i < handPoseInfos.size(); ++i) {
            HandPoseInfo& handPoseInfo = handPoseInfos[i];
 
            XrActionStateGetInfo actionStateGetInfo{ XR_TYPE_ACTION_STATE_GET_INFO };
            actionStateGetInfo.action = aimPoseAction;
            actionStateGetInfo.subactionPath = handPoseInfo.handPath;
 
            XrActionStatePose aimPoseState{ XR_TYPE_ACTION_STATE_POSE };
            PLOG_THROW_FN_XR(xrGetActionStatePose(xrSession, &actionStateGetInfo, &aimPoseState));
 
            if (aimPoseState.isActive) {
                XrSpaceLocation spaceLocation{ XR_TYPE_SPACE_LOCATION };
                PLOG_THROW_FN_XR(xrLocateSpace(handPoseInfo.space, playerSpace, predictedDisplayTime, &spaceLocation));
 
                constexpr XrSpaceLocationFlags checkFlags =
                    XR_SPACE_LOCATION_POSITION_VALID_BIT | XR_SPACE_LOCATION_POSITION_TRACKED_BIT |
                    XR_SPACE_LOCATION_ORIENTATION_VALID_BIT | XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT;
 
                if ((spaceLocation.locationFlags & checkFlags) == checkFlags) {
                    handPoseInfo.matrix = EngineCore::OpenXrHelper::poseToMatrix(spaceLocation.pose);
                    handPoseInfo.handPose = EngineCore::OpenXrHelper::xrPosefToGlmPosef(spaceLocation.pose);
                }
            }
 
            // Sync thumbstick for this hand
            {
                XrActionStateGetInfo thumbstickGetInfo{ XR_TYPE_ACTION_STATE_GET_INFO };
                thumbstickGetInfo.action = thumbstickAction_;
                thumbstickGetInfo.subactionPath = handPoseInfo.handPath;
 
                XrActionStateVector2f thumbstickState{ XR_TYPE_ACTION_STATE_VECTOR2F };
                if (xrGetActionStateVector2f(xrSession, &thumbstickGetInfo, &thumbstickState) == XR_SUCCESS) {
                    if (thumbstickState.isActive) {
                        glm::vec2 value(thumbstickState.currentState.x, thumbstickState.currentState.y);
                        if (i == static_cast<size_t>(Hand::LEFT)) {
                            leftThumbstick_ = value;
                        } else {
                            rightThumbstick_ = value;
                        }
                    }
                }
            }
 
            // Sync trigger for this hand
            {
                XrActionStateGetInfo triggerGetInfo{ XR_TYPE_ACTION_STATE_GET_INFO };
                triggerGetInfo.action = triggerAction_;
                triggerGetInfo.subactionPath = handPoseInfo.handPath;
 
                XrActionStateFloat triggerState{ XR_TYPE_ACTION_STATE_FLOAT };
                if (xrGetActionStateFloat(xrSession, &triggerGetInfo, &triggerState) == XR_SUCCESS) {
                    if (triggerState.isActive) {
                        triggerValues_[i] = triggerState.currentState;
                    }
                }
            }
 
            // Sync grip for this hand
            {
                XrActionStateGetInfo gripGetInfo{ XR_TYPE_ACTION_STATE_GET_INFO };
                gripGetInfo.action = gripAction_;
                gripGetInfo.subactionPath = handPoseInfo.handPath;
 
                XrActionStateFloat gripState{ XR_TYPE_ACTION_STATE_FLOAT };
                if (xrGetActionStateFloat(xrSession, &gripGetInfo, &gripState) == XR_SUCCESS) {
                    if (gripState.isActive) {
                        gripValues_[i] = gripState.currentState;
                    }
                }
            }
        }
    }
 
    XrSpace XrInputHandler::getLeftHandSpace()
    {
        return getHandPoseInfo(Hand::LEFT).space;
    }
 
    XrSpace XrInputHandler::getRightHandSpace()
    {
        return getHandPoseInfo(Hand::RIGHT).space;
    }
 
    Input::HandPoseInfo XrInputHandler::getHandPoseInfo(Hand hand) const
    {
        return handPoseInfos.at(static_cast<uint32_t>(hand));
    }
 
    float XrInputHandler::getTriggerValue(Hand hand) const
    {
        return triggerValues_[static_cast<size_t>(hand)];
    }
 
    float XrInputHandler::getGripValue(Hand hand) const
    {
        return gripValues_[static_cast<size_t>(hand)];
    }
 
}