InputSampleSystem.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "config/InputBindings.hpp"
#include "ecs/components/Controllable.hpp"
#include "ecs/components/InputSnapshot.hpp"
#include "ecs/components/LocalPlayer.hpp"
#include "ecs/components/RespawnTimer.hpp"
#include "ecs/registry/Registry.hpp"
 
#include <SDL3/SDL.h>
 
#include <algorithm>
#include <cmath>
#include <glm/geometric.hpp>
#include <glm/trigonometric.hpp>
#include <glm/vec2.hpp>

namespace systems
{

inline bool prevKillSelfKey = false;
inline bool prevGrenadeKey = false;
inline float grenadeHeldSeconds = 0.0f;
inline bool grenadeRadialActive = false;
inline glm::vec2 grenadeRadialAim{0.0f, -1.0f};
inline bool pendingGrenadeThrow = false;
inline constexpr float k_grenadeRadialHoldSeconds = 0.24f;
inline constexpr float k_grenadeRadialDeadzone = 18.0f;
inline constexpr float k_grenadeRadialMaxDistance = 130.0f;
inline bool prevAbilitySelectLeft = false;
inline bool prevAbilitySelectRight = false;
inline bool prevGamepadAbilitySelectLeft = false;
inline bool prevGamepadAbilitySelectRight = false;

struct JoystickAxis
{
    SDL_GamepadAxis x;
    SDL_GamepadAxis y;
};

inline JoystickAxis getLookJoystickAxes(bool swapSticks)
{
    return {
        .x = swapSticks ? SDL_GAMEPAD_AXIS_LEFTX : SDL_GAMEPAD_AXIS_RIGHTX,
        .y = swapSticks ? SDL_GAMEPAD_AXIS_LEFTY : SDL_GAMEPAD_AXIS_RIGHTY,
    };
}

inline JoystickAxis getMoveJoystickAxes(bool swapSticks)
{
    return {
        .x = swapSticks ? SDL_GAMEPAD_AXIS_RIGHTX : SDL_GAMEPAD_AXIS_LEFTX,
        .y = swapSticks ? SDL_GAMEPAD_AXIS_RIGHTY : SDL_GAMEPAD_AXIS_LEFTY,
    };
}

inline bool gamepadConnected(SDL_Gamepad* gamepad)
{
    return gamepad != nullptr && SDL_GamepadConnected(gamepad);
}

inline std::uint8_t grenadeRadialIndexFromAim()
{
    if (glm::dot(grenadeRadialAim, grenadeRadialAim) < k_grenadeRadialDeadzone * k_grenadeRadialDeadzone) {
        return kInvalidGrenadeSelectIndex;
    }
 
    constexpr glm::vec2 directions[3] = {
        {0.0f, -1.0f},
        {0.8660254f, 0.5f},
        {-0.8660254f, 0.5f},
    };
 
    const glm::vec2 aim = glm::normalize(grenadeRadialAim);
    std::uint8_t bestIndex = 0;
    float bestDot = glm::dot(aim, directions[0]);
    for (std::uint8_t i = 1; i < 3; ++i) {
        const float d = glm::dot(aim, directions[i]);
        if (d > bestDot) {
            bestDot = d;
            bestIndex = i;
        }
    }
    return bestIndex;
}

inline bool consumePendingGrenadeThrow()
{
    const bool shouldThrow = pendingGrenadeThrow;
    pendingGrenadeThrow = false;
    return shouldThrow;
}

inline void runMouseLook(Registry& registry, float mouseSensitivity, bool gravityFlipped = false)
{
    float mdx = 0.0f;
    float mdy = 0.0f;
    SDL_GetRelativeMouseState(&mdx, &mdy);
 
    if (grenadeRadialActive) {
        grenadeRadialAim += glm::vec2{mdx, mdy};
        const float len = glm::length(grenadeRadialAim);
        if (len > k_grenadeRadialMaxDistance) {
            grenadeRadialAim *= k_grenadeRadialMaxDistance / len;
        }
        return;
    }
 
    // When gravity is flipped the camera is rolled 180°, which swaps
    // both screen-left/right and screen-up/down relative to world space.
    // Negating both deltas keeps controls feeling natural.
    if (gravityFlipped) {
        mdx = -mdx;
        mdy = -mdy;
    }
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        // Negate: SDL mdx is positive when moving right, but positive yaw
        // rotates toward +X which maps to screen-left via glm::lookAt's
        // cross(forward, up) convention.  Negating gives the standard
        // "mouse right = look right" behaviour.
        snap.yaw -= mdx * mouseSensitivity;
 
        // Wrap yaw to [-π, π] to avoid float precision drift over time.
        snap.yaw = std::remainder(snap.yaw, glm::radians(360.0f));
 
        // Clamp pitch to avoid gimbal-lock at the poles.
        snap.pitch = std::clamp(snap.pitch + mdy * mouseSensitivity, -glm::radians(89.0f), glm::radians(89.0f));
    });
}

inline void runMovementKeys(Registry& registry, const InputBindings& bindings, bool gravityFlipped = false)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
 
    // Edge-detect K key: only fire killSelf on the rising edge (key-down),
    // not while held.  Prevents respawn → immediate re-death loop.
    const bool killKeyNow = bindings.pressed(Action::KillSelf, kKeys, mouse);
    const bool killEdge = killKeyNow && !prevKillSelfKey;
    prevKillSelfKey = killKeyNow;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        // Movement keys
        const bool forward = bindings.pressed(Action::Forward, kKeys, mouse);
        const bool back = bindings.pressed(Action::Back, kKeys, mouse);
        const bool left = bindings.pressed(Action::Left, kKeys, mouse);
        const bool right = bindings.pressed(Action::Right, kKeys, mouse);
 
        snap.forward = forward;
        snap.back = back;
        // When gravity is flipped the camera is rolled 180°, which negates
        // the screen-space right vector.  Swapping A/D compensates so
        // pressing A still moves the player screen-left.
        snap.left = gravityFlipped ? right : left;
        snap.right = gravityFlipped ? left : right;
        snap.jump = bindings.pressed(Action::Jump, kKeys, mouse);
        snap.crouch = bindings.pressed(Action::Crouch, kKeys, mouse);
        snap.ability1 = bindings.pressed(Action::Ability1, kKeys, mouse);
        snap.ability2 = bindings.pressed(Action::Ability2, kKeys, mouse);
        snap.killSelf = killEdge;
        snap.skipRespawn = false; // Clear stale flag from previous death.
    });
}

inline void runDeadInput(Registry& registry, const InputBindings& bindings)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
 
    registry.view<InputSnapshot, LocalPlayer, RespawnTimer>().each(
        [&](InputSnapshot& snap, const RespawnTimer& /*unused*/) {
            snap.skipRespawn = bindings.pressed(Action::Jump, kKeys, mouse);
        });
}

inline void runWeaponKeys(Registry& registry, const InputBindings& bindings, float dt = 0.0f)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
    const bool abilityMenuHeld = bindings.pressed(Action::AbilityMenu, kKeys, mouse);
    const bool shootDown = bindings.pressed(Action::Shoot, kKeys, mouse);
    const bool scopeDown = bindings.pressed(Action::Scope, kKeys, mouse);
    const bool selectLeftNow = abilityMenuHeld && shootDown;
    const bool selectRightNow = abilityMenuHeld && scopeDown;
    const bool selectLeftEdge = selectLeftNow && !prevAbilitySelectLeft;
    const bool selectRightEdge = selectRightNow && !prevAbilitySelectRight;
    prevAbilitySelectLeft = selectLeftNow;
    prevAbilitySelectRight = selectRightNow;
 
    const bool grenadeKeyNow = bindings.pressed(Action::CycleGrenade, kKeys, mouse);
    if (grenadeKeyNow) {
        if (!prevGrenadeKey) {
            grenadeHeldSeconds = 0.0f;
            grenadeRadialActive = false;
            grenadeRadialAim = glm::vec2{0.0f, -1.0f};
        } else {
            grenadeHeldSeconds += dt;
        }
 
        if (!grenadeRadialActive && grenadeHeldSeconds >= k_grenadeRadialHoldSeconds) {
            grenadeRadialActive = true;
        }
    } else if (prevGrenadeKey) {
        if (!grenadeRadialActive) {
            pendingGrenadeThrow = true;
        }
        grenadeHeldSeconds = 0.0f;
        grenadeRadialActive = false;
    }
    prevGrenadeKey = grenadeKeyNow;
    const std::uint8_t grenadeSelectIndex =
        grenadeRadialActive ? grenadeRadialIndexFromAim() : kInvalidGrenadeSelectIndex;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        snap.shooting = shootDown && !abilityMenuHeld;
        snap.scoped = scopeDown && !abilityMenuHeld;
        snap.switchToPrimary = bindings.pressed(Action::SwitchToPrimary, kKeys, mouse);
        snap.switchToSecondary = bindings.pressed(Action::SwitchToSecondary, kKeys, mouse);
        snap.throwGrenade = false;
        snap.grenadeMenuHeld = grenadeRadialActive;
        snap.grenadeSelectIndex = grenadeSelectIndex;
        snap.reload = bindings.pressed(Action::Reload, kKeys, mouse);
        snap.pickup = bindings.pressed(Action::Pickup, kKeys, mouse);
        snap.abilitySelectHeld = abilityMenuHeld;
        snap.abilitySelectLeft = selectLeftEdge;
        snap.abilitySelectRight = selectRightEdge;
    });
}

inline void runInputSample(Registry& registry, const InputBindings& bindings, float mouseSensitivity = 0.001f)
{
    runMouseLook(registry, mouseSensitivity);
    runMovementKeys(registry, bindings);
    runWeaponKeys(registry, bindings);
}
 
// ─── Gamepad samplers ────────────────────────────────────────────────────────
//
// Mirror the keyboard/mouse pipeline so a controller can drive every action a
// PC player has access to.  SDL3's gamepad API gives us a standardised
// abstract layout (Xbox 360 / One, DualShock, Switch Pro, etc. all map onto
// the same buttons/axes) so a single mapping serves "all controllers behave
// the same way".  Tested on Xbox 360.
//
// Gamepad samplers OR their state into the InputSnapshot fields that the
// keyboard samplers already populated, so a player can use kbm and pad
// simultaneously without one stomping the other.  The look sampler ADDs to
// yaw/pitch the same way mouse delta does, so the two compose cleanly.
 
namespace gamepad
{

inline constexpr float k_stickDeadzone = 0.15f;

inline constexpr float k_triggerThreshold = 0.5f;

inline float normaliseAxis(Sint16 raw, float deadzone = k_stickDeadzone)
{
    // SDL_Gamepad axes are int16; normalise to [-1, 1].  -32768 is one larger
    // in magnitude than 32767 — divide by 32767 and clamp to keep the range
    // symmetric (otherwise full-down on a stick reads as -1.0000305...).
    const float v = std::clamp(static_cast<float>(raw) / 32767.0f, -1.0f, 1.0f);
    if (std::fabs(v) < deadzone)
        return 0.0f;
    // Rescale [deadzone, 1] → [0, 1] so the user gets the full output range.
    const float sign = v < 0.0f ? -1.0f : 1.0f;
    return sign * (std::fabs(v) - deadzone) / (1.0f - deadzone);
}
 
} // namespace gamepad

inline void runGamepadLook(Registry& registry,
                           SDL_Gamepad* gamepad,
                           float pitchSensitivity,
                           float yawSensitivity,
                           float deadzone,
                           float dt,
                           bool gravityFlipped = false,
                           bool swapSticks = false)
{
    if (!gamepadConnected(gamepad))
        return;
 
    JoystickAxis lookAxis = getLookJoystickAxes(swapSticks);
 
    float rx = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, lookAxis.x), deadzone);
    float ry = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, lookAxis.y), deadzone);
 
    if (rx == 0.0f && ry == 0.0f)
        return;
 
    if (gravityFlipped) {
        rx = -rx;
        ry = -ry;
    }
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        // Sign convention matches runMouseLook: stick-right (positive rx)
        // should look right, which means yaw decreases (see runMouseLook
        // comment for why the negation is correct).
        snap.yaw -= rx * yawSensitivity * dt;
        snap.yaw = std::remainder(snap.yaw, glm::radians(360.0f));
 
        // SDL gamepad Y axis is +down/-up (screen-coord convention) — same as
        // mouse mdy — so adding directly matches mouse-down = pitch+ behaviour.
        snap.pitch = std::clamp(snap.pitch + ry * pitchSensitivity * dt, -glm::radians(89.0f), glm::radians(89.0f));
    });
}

inline void runGamepadMovement(Registry& registry,
                               SDL_Gamepad* gamepad,
                               const InputBindings& bindings,
                               float deadzone,
                               bool gravityFlipped = false,
                               bool swapSticks = false)
{
    if (!gamepadConnected(gamepad))
        return;
 
    JoystickAxis moveAxis = getMoveJoystickAxes(swapSticks);
 
    const float lx = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, moveAxis.x), deadzone);
    const float ly = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, moveAxis.y), deadzone);
 
    // Movement booleans are derived from a stronger threshold than the deadzone
    // so a player resting their thumb on the stick doesn't drift-walk.  0.3 is
    // ~tip pressure on a 360 stick.
    constexpr float moveThresh = 0.3f;
    const bool padForward = ly < -moveThresh; // stick-up = -Y in SDL
    const bool padBack = ly > moveThresh;
    // Swap left/right when gravity is flipped (same reasoning as keyboard).
    const bool padLeft = gravityFlipped ? (lx > moveThresh) : (lx < -moveThresh);
    const bool padRight = gravityFlipped ? (lx < -moveThresh) : (lx > moveThresh);
 
    const bool padJump = bindings.controllerPressed(Action::Jump, gamepad);
    const bool padCrouch = bindings.controllerPressed(Action::Crouch, gamepad);
    const bool padAbility1 = bindings.controllerPressed(Action::Ability1, gamepad);
    const bool padAbility2 = bindings.controllerPressed(Action::Ability2, gamepad);
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        snap.forward |= padForward;
        snap.back |= padBack;
        snap.left |= padLeft;
        snap.right |= padRight;
        snap.jump |= padJump;
        snap.crouch |= padCrouch;
        snap.ability1 |= padAbility1;
        snap.ability2 |= padAbility2;
    });
}

inline void runGamepadWeapon(Registry& registry, SDL_Gamepad* gamepad, const InputBindings& bindings)
{
    if (!gamepadConnected(gamepad))
        return;
 
    const bool abilityMenuHeld = bindings.controllerPressed(Action::AbilityMenu, gamepad);
    const bool padShoot = bindings.controllerPressed(Action::Shoot, gamepad);
    const bool padScope = bindings.controllerPressed(Action::Scope, gamepad);
    const bool padReload = bindings.controllerPressed(Action::Reload, gamepad);
    const bool padPickup = bindings.controllerPressed(Action::Pickup, gamepad);
    const bool padPrimary = bindings.controllerPressed(Action::SwitchToPrimary, gamepad);
    const bool padSecondary = bindings.controllerPressed(Action::SwitchToSecondary, gamepad);
    const bool padCycleGrenade = bindings.controllerPressed(Action::CycleGrenade, gamepad);
    const bool selectLeftNow = abilityMenuHeld && padShoot;
    const bool selectRightNow = abilityMenuHeld && padScope;
    const bool selectLeftEdge = selectLeftNow && !prevGamepadAbilitySelectLeft;
    const bool selectRightEdge = selectRightNow && !prevGamepadAbilitySelectRight;
    prevGamepadAbilitySelectLeft = selectLeftNow;
    prevGamepadAbilitySelectRight = selectRightNow;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        snap.shooting |= padShoot && !abilityMenuHeld;
        snap.scoped |= padScope && !abilityMenuHeld;
        snap.reload |= padReload;
        snap.pickup |= padPickup;
        snap.switchToPrimary |= padPrimary;
        snap.switchToSecondary |= padSecondary;
        snap.grenadeMenuHeld |= padCycleGrenade;
        snap.abilitySelectHeld |= abilityMenuHeld;
        snap.abilitySelectLeft |= selectLeftEdge;
        snap.abilitySelectRight |= selectRightEdge;
    });
}

inline void runGamepadDeadInput(Registry& registry, SDL_Gamepad* gamepad, const InputBindings& bindings)
{
    if (!gamepadConnected(gamepad))
        return;
    const bool skipRespawn = bindings.controllerPressed(Action::Jump, gamepad);
    registry.view<InputSnapshot, LocalPlayer, RespawnTimer>().each(
        [&](InputSnapshot& snap, const RespawnTimer& /*unused*/) { snap.skipRespawn = skipRespawn; });
}
 
} // namespace systems