VrGliderComponent.h

Go to the documentation of this file.

#pragma once
#include "Engine/Component/ArcadeGliderFlightModel.h"
#include "Engine/Component/LogicComponent.h"
#include "Engine/World/WindField.h"
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
namespace EngineCore
{
    class Headset;
}  // namespace EngineCore
 
namespace Input
{
    class XrInputHandler;
    enum class Hand;
}  // namespace Input
 
namespace Engine
{
    namespace Rendering
    {
        class Headset;
    }  // namespace Rendering

    enum class GliderState
    {
        FALLING,  // Normal gravity
        GLIDING,  // Arms spread - velocity control
        STALLED,  // Arms spread but too little momentum / too much climb
        WALKING   // On ground - thumbstick locomotion
    };

    struct GliderConfig
    {
        float minArmSpreadDistance = 0.4f;
        float armSpreadHysteresis  = 0.08f;
        float tuckDistance         = 0.45f;
 
        float gravity = 3.0f;
        float fallingTerminalVelocity = 25.0f;
 
        float momentumDrag = 0.12f;
        float highSpeedDrag = 0.005f;
        float minGlideSink = 0.65f;
        float maxClimbRate = 6.0f;
        float climbMomentumCost = 0.48f;
        float diveSinkRate = 7.0f;
        float diveMomentumGain = 0.72f;
        float windMomentumGain = 0.72f;
        float windDiminishingSpeed = 12.0f;
        float windAlignmentPower = 1.6f;
        float crosswindTurnRate = 0.06f;
        float headwindPenalty = 0.55f;
        float glideTurnRate = 7.0f;
        float stallSpeed = 3.5f;
        float stallRecoverySpeed = 4.7f;
        float stallSinkSpeed = 6.0f;
        float stallDiveSinkScale = 0.35f;
        float stallExtraDrag = 0.12f;
        float stallRecoveryDelay = 0.18f;
        float emergencyMaxSpeed = 80.0f;
 
        float snapTurnDegrees   = 30.0f;
        float snapTurnThreshold = 0.7f;
        float stickDeadzone     = 0.15f;
 
        glm::vec3 spawnPosition{ 0.0f, 10.0f, 0.0f };
 
        float walkSpeed         = 2.5f;
        float groundRayLength   = 1.5f;
        float groundSmoothSpeed = 12.0f;
        float maxStepHeight     = 0.3f;
        float maxWalkableSlope  = 0.7f;
        float groundHoverOffset = 0.01f;
        float walkTakeoffLiftSpeed = 2.0f;
        float walkTakeoffMomentum = 4.0f;
        float walkTakeoffClearance = 0.2f;
        float flightCollisionFallSpeed = 1.5f;
        float fallResetY = -350.0f;
        float landingCheckpointSettleTime = 0.5f;
        float respawnHeightOffset = 1.0f;
    };
 
    namespace Components
    {
        class PhysicsBody;

        class VrGlider : public Logic
        {
        public:
            static constexpr bool IsUnique = true;
            static constexpr const char* ComponentName = "VrGlider";
            static constexpr float CAPSULE_RADIUS      = 0.3f;  // Must match GliderPlayerActor capsule
            static constexpr float CAPSULE_HALF_HEIGHT = 0.7f;  // Half of cylinder portion (1.4/2)
            static constexpr float CAPSULE_TOTAL_HALF  = 1.0f;  // CAPSULE_RADIUS + CAPSULE_HALF_HEIGHT

            struct DebugSnapshot
            {
                bool tickSkipped = false;
                bool missingHeadset = false;
                bool missingInputHandler = false;
                bool missingPhysicsBody = false;
 
                bool enabled = true;
                bool frozen = true;
                bool debugLogging = true;
                GliderState previousState = GliderState::FALLING;
                GliderState currentState = GliderState::FALLING;
 
                float leftGrip = 0.0f;
                float rightGrip = 0.0f;
                bool bothGripsPressed = false;
                bool bothGripsWerePressed = false;
 
                float leftTrigger = 0.0f;
                float rightTrigger = 0.0f;
                bool leftTriggerPressed = false;
                bool rightTriggerPressed = false;
                glm::vec2 rightThumbstick{ 0.0f };
                bool snapTurnArmed = true;
                bool snapTurnTriggered = false;
                int snapTurnDirection = 0;
 
                bool leftHandValid = false;
                bool rightHandValid = false;
                float leftHandDistance = 0.0f;
                float rightHandDistance = 0.0f;
                float leftHandCylinderDistance = 0.0f;
                float rightHandCylinderDistance = 0.0f;
                bool armsSpread = false;
                bool armsSpreadWithHysteresis = false;
                bool handsTucked = false;
 
                bool groundDetected = false;
                bool isNearGround = false;
                bool groundIsWalkable = false;
                bool groundYInitialized = false;
                float groundDistance = 9999.0f;
                float groundHitFraction = 1.0f;
                glm::vec3 groundHitPoint{ 0.0f };
                glm::vec3 groundHitNormal{ 0.0f, 1.0f, 0.0f };
                float smoothedGroundY = 0.0f;
 
                glm::vec3 playerPosition{ 0.0f };
                glm::vec3 headLocalPosition{ 0.0f };
                glm::vec3 headWorldPosition{ 0.0f };
                glm::vec3 headForward{ 0.0f, 0.0f, -1.0f };
                glm::vec3 bodyForward{ 0.0f, 0.0f, -1.0f };
                glm::vec3 horizontalAim{ 0.0f, 0.0f, -1.0f };
 
                glm::vec3 velocityBeforeUpdate{ 0.0f };
                glm::vec3 targetVelocity{ 0.0f };
                glm::vec3 velocityAfterUpdate{ 0.0f };
                glm::vec3 desiredPosition{ 0.0f };
                glm::vec3 physicsBodyVelocity{ 0.0f };
 
                float playerYawRadians = 0.0f;
                float palmTilt = 0.0f;
                float forwardAmount = 0.0f;
                float rightAmount = 0.0f;
                float momentum = 0.0f;
                float verticalVelocity = 0.0f;
                float climbDemand = 0.0f;
                float diveDemand = 0.0f;
                float windAlignment = 0.0f;
                float windMomentumDelta = 0.0f;
                float dragDelta = 0.0f;
                float climbMomentumDelta = 0.0f;
                float stallRecoveryTimer = 0.0f;
                bool isBraking = false;
                bool isClimbing = false;
                bool isDiving = false;
                bool isStalled = false;
                bool enteredStall = false;
                bool recoveredStall = false;
 
                World::WindSample windSample{};
                glm::vec3 windContribution{ 0.0f };
 
                bool collisionTested = false;
                bool collisionImpact = false;
                bool collisionReset = false;
                bool takeoffArmed = true;
                bool takeoffRequested = false;
                bool takeoffBlocked = false;
                bool hasLastSafeLanding = false;
                bool respawnTriggered = false;
                glm::vec3 takeoffTestPosition{ 0.0f };
                glm::vec3 lastSafeLandingPosition{ 0.0f };
                glm::vec3 collisionTestPosition{ 0.0f };
                glm::vec3 collisionPushOut{ 0.0f };
                glm::vec3 collisionGroundNormal{ 0.0f };
                float collisionMaxPenetration = 0.0f;
                float landingCheckpointTimer = 0.0f;
 
                float capsuleRadius = CAPSULE_RADIUS;
                float capsuleCylinderHeight = CAPSULE_HALF_HEIGHT * 2.0f;
                float capsuleTotalHeight = CAPSULE_TOTAL_HALF * 2.0f;
            };

            VrGlider(
                Entities::Scene *       owningScene,
                Rendering::Headset *   headset,
                Input::XrInputHandler * inputHandler,
                PhysicsBody *           physicsBody
            );
 
            ~VrGlider() override = default;
 
            [[nodiscard]] std::string getComponentName() const override { return ComponentName; }
 
            void beginPlay() override;
            void tick( double deltaTime ) override;
            void endPlay() override;
            bool drawImGui() override;

            [[nodiscard]] GliderState getState() const
            {
                return currentState_;
            }

            [[nodiscard]] glm::vec3 getVelocity() const
            {
                return velocity_;
            }

            [[nodiscard]] float getSpeed() const
            {
                return glm::length( velocity_ );
            }

            [[nodiscard]] const GliderConfig & getConfig() const
            {
                return config_;
            }

            GliderConfig & getConfig()
            {
                return config_;
            }

            void setConfig( const GliderConfig & config )
            {
                config_ = config;
            }

            void setEnabled( bool enabled )
            {
                enabled_ = enabled;
            }

            [[nodiscard]] bool isEnabled() const
            {
                return enabled_;
            }

            void setFrozen( bool frozen );
 
            void resetGliderStateTo( GliderState state );
 
            [[nodiscard]] PhysicsBody * getPhysicsBody() const { return physicsBody_; }
 
            [[nodiscard]] const DebugSnapshot & getDebugSnapshot() const { return debugSnapshot_; }

            [[nodiscard]] bool isFrozen() const
            {
                return frozen_;
            }

            void setDebugLogging( bool enabled )
            {
                debugLogging_ = enabled;
            }

            [[nodiscard]] bool isDebugLogging() const
            {
                return debugLogging_;
            }

            [[nodiscard]] static const char * stateToString( GliderState state );
 
        private:
            struct HandData
            {
                glm::vec3 position{ 0.0f };
                glm::vec3 relativePosition{ 0.0f };
                glm::quat orientation{ 1.0f, 0.0f, 0.0f, 0.0f };
                glm::vec3 palmNormal{ 0.0f, -1.0f, 0.0f };
                glm::vec3 fingerDirection{ 0.0f, 0.0f, -1.0f };
                glm::vec3 thumbDirection{ 0.0f, 1.0f, 0.0f };
                float     distanceFromHead = 0.0f;
                bool      isValid          = false;
            };
 
            [[nodiscard]] HandData getHandData( Input::Hand hand ) const;
 
            [[nodiscard]] bool areArmsSpread(
                const HandData & leftHand,
                const HandData & rightHand,
                float            hysteresis = 0.0f
            ) const;
 
            [[nodiscard]] bool areHandsTucked( const HandData & leftHand, const HandData & rightHand ) const;
 
            void updateGlidingVelocity( const HandData & leftHand, const HandData & rightHand, float dt );
 
            [[nodiscard]] ArcadeGliderTuning makeFlightTuning() const;
 
            [[nodiscard]] glm::vec3 buildGlideDirection(
                const HandData & leftHand,
                const HandData & rightHand,
                glm::vec3 &       outBodyForward,
                float &           outForwardAmount,
                float &           outRightAmount
            ) const;

            [[nodiscard]] glm::vec3 getHeadWorldPosition() const;

            [[nodiscard]] glm::quat getHeadOrientation() const;

            [[nodiscard]] glm::vec3 getHeadForward() const;
 
            bool canStartGlidingFromWalking( const glm::vec3 & currentPos, glm::vec3 & outTakeoffPos ) const;
 
            bool handleFlightCollision( const glm::vec3 & currentPos, glm::vec3 & desiredPos );
 
            bool sweepGround(
                const glm::vec3 & origin,
                glm::vec3 &       outHitPoint,
                glm::vec3 &       outHitNormal,
                float &           outHitFraction
            ) const;
 
            void updateWalkingInput( float dt );
 
            glm::vec3 collideAndSlide( const glm::vec3 & startPos, const glm::vec3 & displacement );
 
            void updateLastSafeLanding( const glm::vec3 & position, bool stableWalkableGround, float dt );
 
            void teleportPlayer( const glm::vec3 & position );
 
            void resetToLastSafeLanding();
 
            void resetToSpawn();
 
            Rendering::Headset *    headset_      = nullptr;
            Input::XrInputHandler * inputHandler_ = nullptr;
            PhysicsBody *           physicsBody_  = nullptr;
 
            GliderConfig config_;
            GliderState  currentState_ = GliderState::FALLING;
            bool         takeoffArmed_ = true;
 
            glm::vec3              velocity_{ 0.0f };
            bool                   enabled_           = true;
            bool                   frozen_            = true;  // Start frozen so user can put on headset
            bool                   debugLogging_      = true;  // Enabled to diagnose flight tuning issues.
            float                  debugLogTimer_     = 0.0f;
            static constexpr float DEBUG_LOG_INTERVAL = 0.5f;  // Log every 0.5 seconds
 
            // Grip toggle detection (freeze/unfreeze)
            bool bothGripsWerePressed_ = false;
            static constexpr float GRIP_THRESHOLD = 0.8f;  // Grip/trigger must be >80% to count as pressed
 
            ArcadeGliderState flightState_{};
            World::WindSample lastWindSample_{};
            DebugSnapshot debugSnapshot_{};
            glm::vec3 lastSafeLandingPosition_{ 0.0f, 10.0f, 0.0f };
            bool      hasLastSafeLandingPosition_ = false;
            float     landingCheckpointTimer_ = 0.0f;
 
            // Player yaw for right-stick snap turning (radians, applied to body forward)
            float playerYaw_ = 0.0f;
            bool  rightStickSnapTurnArmed_ = true;
 
            // Walking state
            float smoothedGroundY_    = 0.0f;   // Lerp-smoothed ground height to prevent jitter
            bool  groundYInitialized_ = false;  // Whether smoothedGroundY_ has been set from a sweep yet
 
            // Sweep test constants
            static constexpr float SKIN_WIDTH = 0.02f;          // Small gap to prevent direct surface contact
            static constexpr int   MAX_SLIDE_ITERATIONS = 3;    // Max collide-and-slide recursions
        };
    }  // namespace Components
 
}  // namespace Engine