VrMovementComponent.cpp

Go to the documentation of this file.

#include "Engine/Component/VrMovementComponent.h"
#include "Engine/Input/XrInputHandler.h"
#include "Engine/Renderer/Headset.h"
#include <glm/gtc/matrix_transform.hpp>
#include <plog/Log.h>
 
namespace EngineCore {
 
VrMovementComponent::VrMovementComponent(Scene* owningScene, Headset* headset, Input::XrInputHandler* inputHandler)
    : LogicComponent(owningScene)
    , headset_(headset)
    , inputHandler_(inputHandler)
{
    setCanTick(true);
}
 
void VrMovementComponent::beginPlay()
{
    LogicComponent::beginPlay();
    PLOGD << "VrMovementComponent initialized";
}
 
void VrMovementComponent::tick(double deltaTime)
{
    if (!headset_ || !inputHandler_) {
        return;
    }
 
    glm::vec3 currentPos = headset_->getPlayerPosition();
    glm::vec3 movement{0.0f};
 
    // Get right thumbstick for XZ movement
    glm::vec2 thumbstick = inputHandler_->getRightThumbstick();
 
    // Apply deadzone
    if (glm::length(thumbstick) < deadzone_) {
        thumbstick = glm::vec2{0.0f};
    }
 
    // Get forward direction on XZ plane from headset orientation
    glm::vec3 forwardXZ = getHeadsetForwardXZ();
    glm::vec3 rightXZ = glm::normalize(glm::cross(forwardXZ, glm::vec3{0.0f, 1.0f, 0.0f}));
 
    // thumbstick.y = forward/back, thumbstick.x = strafe left/right
    movement += forwardXZ * thumbstick.y * moveSpeed_ * static_cast<float>(deltaTime);
    movement += rightXZ * thumbstick.x * moveSpeed_ * static_cast<float>(deltaTime);
 
    // Vertical movement from triggers (up) and grips (down)
    float triggerLeft = inputHandler_->getTriggerValue(Input::Hand::LEFT);
    float triggerRight = inputHandler_->getTriggerValue(Input::Hand::RIGHT);
    float gripLeft = inputHandler_->getGripValue(Input::Hand::LEFT);
    float gripRight = inputHandler_->getGripValue(Input::Hand::RIGHT);
 
    float upInput = glm::max(triggerLeft, triggerRight);
    float downInput = glm::max(gripLeft, gripRight);
 
    movement.y += (upInput - downInput) * verticalSpeed_ * static_cast<float>(deltaTime);
 
    // Apply movement
    currentPos += movement;
    headset_->setPlayerPosition(currentPos);
}
 
void VrMovementComponent::endPlay()
{
    LogicComponent::endPlay();
}
 
glm::vec3 VrMovementComponent::getHeadsetForwardXZ() const
{
    // Get the view matrix of the left eye (eye 0) - the inverse gives us the camera world transform
    // We use the raw eye view matrix without player offset to get headset orientation
    glm::mat4 viewMatrix = headset_->getEyeViewMatrix(0);
 
    // The view matrix is inverse(camera_world_transform)
    // To get forward direction: in view space, forward is -Z
    // In world space, forward = inverse(viewMatrix) * (0,0,-1,0)
    // But we can extract it directly from the view matrix:
    // Forward direction in world space is the negative of the third column of the transpose of the upper 3x3
    // Or equivalently: -viewMatrix[2] (the third row, which is -forward in view space)
 
    glm::vec3 forward = -glm::vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]);
 
    // Project onto XZ plane and normalize
    forward.y = 0.0f;
    float length = glm::length(forward);
    if (length > 0.001f) {
        forward /= length;
    } else {
        // Looking straight up or down, default to -Z
        forward = glm::vec3{0.0f, 0.0f, -1.0f};
    }
 
    return forward;
}
 
}