VrGliderComponent.h

#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 InputManager;
    class XrInputHandler;
    enum class Hand;
}  // namespace Input
 
namespace Engine
{
    namespace Rendering
    {
        class Headset;
    }  // namespace Rendering

    enum class GliderState
    {
        FALLING,  
        GLIDING,  
        STALLED,  
        WALKING   
    };

    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; 
            static constexpr float CAPSULE_HALF_HEIGHT = 0.7f; 
            static constexpr float CAPSULE_TOTAL_HALF  = 1.0f; 

            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::InputManager * inputManager,
                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::InputManager *inputManager_ = 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