feat: add joystick support for player controls and camera movement

Author: AhmedAmrNabil

src/common/application.cpp

@@ -265,6 +265,7 @@ int our::Application::run(int run_for_frames) {
     setupCallbacks();
     keyboard.enable(window);
     mouse.enable(window);
+    joystick.enable();
 
     // Start the ImGui context and set dark style (just my preference :D)
     IMGUI_CHECKVERSION();
@@ -323,6 +324,9 @@ int our::Application::run(int run_for_frames) {
         // record this event.
         keyboard.setEnabled(!io.WantCaptureKeyboard, window);
         mouse.setEnabled(!io.WantCaptureMouse, window);
+        joystick.setEnabled(
+            !io.WantCaptureKeyboard);  // Joystick events are treated as keyboard events, so we check
+                                       // io.WantCaptureKeyboard to decide whether to capture them or not.
 
         // Render the ImGui commands we called (this doesn't actually draw to the screen yet.
         ImGui::Render();
@@ -383,6 +387,7 @@ int our::Application::run(int run_for_frames) {
         // Update the keyboard and mouse data
         keyboard.update();
         mouse.update();
+        joystick.update();
 
         // If a scene change was requested, apply it
         while (nextState) {
@@ -425,6 +430,7 @@ void our::Application::setupCallbacks() {
     // We use GLFW to store a pointer to "this" window instance.
     glfwSetWindowUserPointer(window, this);
     // The pointer is then retrieved in the callback function.
+    if (glfwJoystickPresent(GLFW_JOYSTICK_1)) glfwSetJoystickUserPointer(GLFW_JOYSTICK_1, this);
 
     // The second parameter to "glfwSet---Callback" is a function pointer.
     // It is replaced by an inline function -lambda expression- as it is not needed to create
@@ -474,4 +480,13 @@ void our::Application::setupCallbacks() {
             if (app->currentState) app->currentState->onScrollEvent(x_offset, y_offset);
         }
     });
+
+    // joystick connection callbacks
+    glfwSetJoystickCallback([](int jid, int event) {
+        auto* app = static_cast<Application*>(glfwGetJoystickUserPointer(GLFW_JOYSTICK_1));
+        if (app) {
+            app->getJoystick().joystickEvent(jid, event);
+            if (app->currentState) app->currentState->onJoystickEvent(jid, event);
+        }
+    });
 }

src/common/application.hpp

@@ -14,6 +14,7 @@
 #include <type_traits>
 #include <unordered_map>
 
+#include "input/joystick.hpp"
 #include "input/keyboard.hpp"
 #include "input/mouse.hpp"
 #include "systems/audio-system.hpp"
@@ -49,6 +50,7 @@ namespace our {
         virtual void onCursorEnterEvent(int entered) {}
         virtual void onMouseButtonEvent(int button, int action, int mods) {}
         virtual void onScrollEvent(double x_offset, double y_offset) {}
+        virtual void onJoystickEvent(int jid, int event) {}
 
         // Returns a pointer
         Application* getApp() {
@@ -64,9 +66,9 @@ namespace our {
     protected:
         GLFWwindow* window = nullptr;  // Pointer to the window created by GLFW using "glfwCreateWindow()".
 
-        Keyboard keyboard;  // Instance of "our" keyboard class that handles keyboard functionalities.
-        Mouse mouse;        // Instance of "our" mouse class that handles mouse functionalities.
-
+        Keyboard keyboard;          // Instance of "our" keyboard class that handles keyboard functionalities.
+        Mouse mouse;                // Instance of "our" mouse class that handles mouse functionalities.
+        Joystick joystick;          // Instance of "our" joystick class that handles joystick functionalities.
         nlohmann::json app_config;  // A Json file that contains all application configuration
 
         std::unordered_map<std::string, State*> states;  // This will store all the states that the application can run
@@ -143,7 +145,12 @@ namespace our {
         [[nodiscard]] const Mouse& getMouse() const {
             return mouse;
         }
-
+        Joystick& getJoystick() {
+            return joystick;
+        }
+        [[nodiscard]] const Joystick& getJoystick() const {
+            return joystick;
+        }
         [[nodiscard]] const nlohmann::json& getConfig() const {
             return app_config;
         }

src/common/input/joystick.hpp

@@ -0,0 +1,140 @@
+#pragma once
+
+#include <GLFW/glfw3.h>
+
+#include <cstring>
+#include <glm/glm.hpp>
+#include <iomanip>
+#include <iostream>
+
+namespace our {
+
+    class Joystick {
+    private:
+        bool enabled;
+        bool currentButtons[GLFW_GAMEPAD_BUTTON_LAST + 1], previousButtons[GLFW_GAMEPAD_BUTTON_LAST + 1];
+        float currentAxes[GLFW_GAMEPAD_AXIS_LAST + 1], previousAxes[GLFW_GAMEPAD_AXIS_LAST + 1];
+        int currentJoystickId = -1;
+        bool currentTriggersPressed[2] = {false, false}, previousTriggersPressed[2] = {false, false};
+
+    public:
+        Joystick() : enabled(false) {
+            disable();
+        }
+
+        int getFirstGamepad() {
+            for (int i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; i++) {
+                if (glfwJoystickPresent(i) && glfwJoystickIsGamepad(i)) return i;
+            }
+            return -1;  // none connected
+        }
+
+        void enable() {
+            enabled = true;
+            std::memset(currentButtons, 0, sizeof(currentButtons));
+            std::memset(previousButtons, 0, sizeof(previousButtons));
+            std::memset(currentAxes, 0, sizeof(currentAxes));
+            std::memset(previousAxes, 0, sizeof(previousAxes));
+            currentJoystickId = getFirstGamepad();
+            GLFWgamepadstate state;
+            if (glfwJoystickIsGamepad(currentJoystickId) && glfwGetGamepadState(currentJoystickId, &state)) {
+                for (int i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++)
+                    currentButtons[i] = previousButtons[i] = state.buttons[i] == GLFW_PRESS;
+                for (int i = 0; i <= GLFW_GAMEPAD_AXIS_LAST; i++) currentAxes[i] = previousAxes[i] = state.axes[i];
+                currentTriggersPressed[0] = previousTriggersPressed[0] =
+                    state.axes[GLFW_GAMEPAD_AXIS_LEFT_TRIGGER] > 0.01f - 1;
+                currentTriggersPressed[1] = previousTriggersPressed[1] =
+                    state.axes[GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER] > 0.01f - 1;
+            }
+        }
+
+        void disable() {
+            enabled = false;
+            currentJoystickId = -1;
+            std::memset(currentButtons, 0, sizeof(currentButtons));
+            std::memset(previousButtons, 0, sizeof(previousButtons));
+            std::memset(currentAxes, 0, sizeof(currentAxes));
+            std::memset(previousAxes, 0, sizeof(previousAxes));
+        }
+
+        void update() {
+            if (!enabled) return;
+            std::memcpy(previousButtons, currentButtons, sizeof(previousButtons));
+            std::memcpy(previousAxes, currentAxes, sizeof(previousAxes));
+            std::memcpy(previousTriggersPressed, currentTriggersPressed, sizeof(previousTriggersPressed));
+            GLFWgamepadstate state;
+            if (glfwJoystickIsGamepad(currentJoystickId) && glfwGetGamepadState(currentJoystickId, &state)) {
+                for (int i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++) currentButtons[i] = state.buttons[i] == GLFW_PRESS;
+                for (int i = 0; i <= GLFW_GAMEPAD_AXIS_LAST; i++) currentAxes[i] = state.axes[i];
+                currentTriggersPressed[0] = state.axes[GLFW_GAMEPAD_AXIS_LEFT_TRIGGER] > 0.01f - 1;
+                currentTriggersPressed[1] = state.axes[GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER] > 0.01f - 1;
+            } else {
+                // Joystick disconnected mid-session — clear current but keep previous for justReleased to fire
+                std::memset(currentButtons, 0, sizeof(currentButtons));
+                std::memset(currentAxes, 0, sizeof(currentAxes));
+                std::memset(currentTriggersPressed, 0, sizeof(currentTriggersPressed));
+            }
+        }
+
+        void joystickEvent(int jid, int event) {
+            if (event == GLFW_DISCONNECTED && jid == currentJoystickId && enabled) {
+                enabled = false;  // Automatically disable if the joystick is disconnected
+                currentJoystickId = -1;
+                std::memset(currentButtons, 0, sizeof(currentButtons));
+                std::memset(currentAxes, 0, sizeof(currentAxes));
+                std::memset(currentTriggersPressed, 0, sizeof(currentTriggersPressed));
+            } else if (event == GLFW_CONNECTED && !enabled) {
+                enable();  // Automatically enable if the joystick is connected
+            }
+        }
+
+        [[nodiscard]] bool isPressed(int button) const {
+            return currentButtons[button];
+        }
+        [[nodiscard]] bool justPressed(int button) const {
+            return currentButtons[button] && !previousButtons[button];
+        }
+        [[nodiscard]] bool justReleased(int button) const {
+            return !currentButtons[button] && previousButtons[button];
+        }
+        [[nodiscard]] float getAxis(int axis) const {
+            return currentAxes[axis];
+        }
+
+        [[nodiscard]] bool isTriggerPressed(int triggerIndex) const {
+            return currentTriggersPressed[triggerIndex];
+        }
+        [[nodiscard]] bool justPressedTrigger(int triggerIndex) const {
+            return currentTriggersPressed[triggerIndex] && !previousTriggersPressed[triggerIndex];
+        }
+        [[nodiscard]] bool justReleasedTrigger(int triggerIndex) const {
+            return !currentTriggersPressed[triggerIndex] && previousTriggersPressed[triggerIndex];
+        }
+
+        [[nodiscard]] glm::vec2 getLeftStick() const {
+            return {getAxis(GLFW_GAMEPAD_AXIS_LEFT_X), getAxis(GLFW_GAMEPAD_AXIS_LEFT_Y)};
+        }
+        [[nodiscard]] glm::vec2 getRightStick() const {
+            return {getAxis(GLFW_GAMEPAD_AXIS_RIGHT_X), getAxis(GLFW_GAMEPAD_AXIS_RIGHT_Y)};
+        }
+        [[nodiscard]] float getLeftTrigger() const {
+            return (getAxis(GLFW_GAMEPAD_AXIS_LEFT_TRIGGER) + 1.0f) / 2.0f;
+        }
+        [[nodiscard]] float getRightTrigger() const {
+            return (getAxis(GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER) + 1.0f) / 2.0f;
+        }
+
+        [[nodiscard]] bool isEnabled() const {
+            return enabled;
+        }
+        void setEnabled(bool enabled) {
+            if (this->enabled != enabled) {
+                if (enabled)
+                    enable();
+                else
+                    disable();
+            }
+        }
+    };
+
+}  // namespace our

src/common/systems/free-camera-controller.hpp

@@ -53,9 +53,16 @@ namespace our {
             // We get a reference to the entity's rotation
             glm::vec3& rotation = entity->localTransform.rotation;
 
+            glm::vec2 delta{0.0f};
             // While the play state is active, the mouse stays locked
             if (mouse_locked) {
-                glm::vec2 delta = app->getMouse().getMouseDelta();
+                delta = app->getMouse().getMouseDelta();
+                rotation.x -= delta.y * controller->rotationSensitivity;  // The y-axis controls the pitch
+                rotation.y -= delta.x * controller->rotationSensitivity;  // The x-axis controls the yaw
+            }
+
+            delta = app->getJoystick().getRightStick();
+            if (glm::length(delta) > 0.1f) {                              // deadzone
                 rotation.x -= delta.y * controller->rotationSensitivity;  // The y-axis controls the pitch
                 rotation.y -= delta.x * controller->rotationSensitivity;  // The x-axis controls the yaw
             }
@@ -71,6 +78,7 @@ namespace our {
             if (baseFov <= 0.0f) baseFov = camera->fovY;
 
             aiming = app->getMouse().isPressed(GLFW_MOUSE_BUTTON_RIGHT);
+            aiming |= app->getJoystick().isTriggerPressed(0);  // also check joystick input
 
             currentAimSpeed = controller->aimSpeed;
             float targetFov;

src/game/systems/player-movement-system.cpp

@@ -7,9 +7,10 @@
 namespace gameplay {
 
     void PlayerMovementSystem::handleSlidingAndCrouching(PlayerMovementComponent* movement, our::Keyboard& keyboard,
-                                                         const glm::vec3& moveDir, float deltaTime,
-                                                         float slideStartSpeed) {
+                                                         our::Joystick& joystick, const glm::vec3& moveDir,
+                                                         float deltaTime, float slideStartSpeed) {
         bool crouchPressed = keyboard.justPressed(GLFW_KEY_LEFT_CONTROL);
+        crouchPressed |= joystick.justPressed(GLFW_GAMEPAD_BUTTON_B);  // also check joystick input for crouching
 
         if (movement->isSliding) {
             movement->slideTimer -= deltaTime;
@@ -61,8 +62,10 @@ namespace gameplay {
 
     void PlayerMovementSystem::handleDashing(PlayerMovementComponent* movement, glm::vec3& playerPosition,
                                              our::Keyboard& keyboard, const glm::vec3& frontXZ,
-                                             const glm::vec3& moveDir) {
-        if (keyboard.justPressed(GLFW_KEY_Q) && movement->dashCooldownTimer <= 0) {
+                                             const glm::vec3& moveDir, our::Joystick& joystick) {
+        bool dashPressed = keyboard.justPressed(GLFW_KEY_Q);
+        dashPressed |= joystick.justPressed(GLFW_GAMEPAD_BUTTON_X);
+        if (dashPressed && movement->dashCooldownTimer <= 0) {
             glm::vec3 dashDirection = glm::normalize(frontXZ);
             if (glm::length(moveDir) > 0.001f) {
                 // Dash along active WASD input direction (not velocity, which may still be decaying)
@@ -102,8 +105,11 @@ namespace gameplay {
     }
 
     void PlayerMovementSystem::handleJumpingAndGravity(PlayerMovementComponent* movement, glm::vec3& playerPosition,
-                                                       our::Keyboard& keyboard, float deltaTime) {
-        if (keyboard.justPressed(GLFW_KEY_SPACE) && movement->isGrounded) {
+                                                       our::Keyboard& keyboard, our::Joystick& joystick,
+                                                       float deltaTime) {
+        bool jumpPressed = keyboard.justPressed(GLFW_KEY_SPACE);
+        jumpPressed |= joystick.justPressed(GLFW_GAMEPAD_BUTTON_A);  // also check joystick input
+        if (jumpPressed && movement->isGrounded) {
             if (movement->isSliding) {
                 movement->slideCooldownTimer = movement->slideCooldown;
             }
@@ -178,6 +184,7 @@ namespace gameplay {
         movement->groundLevel = groundHeight;
 
         our::Keyboard& keyboard = app->getKeyboard();
+        our::Joystick& joystick = app->getJoystick();
         movement->dashTriggeredThisFrame = false;
 
         if (movement->slideCooldownTimer > 0) movement->slideCooldownTimer -= deltaTime;
@@ -196,18 +203,25 @@ namespace gameplay {
         if (keyboard.isPressed(GLFW_KEY_A)) moveDir -= rightXZ;
         if (glm::length(moveDir) > 0.001f) moveDir = glm::normalize(moveDir);
 
+        // handle joystick percent input for movement
+        glm::vec2 leftStick = joystick.getLeftStick();
+        if (glm::length(leftStick) > 0.1f) {  // deadzone
+            glm::vec3 joystickMoveDir = frontXZ * leftStick.y - rightXZ * leftStick.x;
+            moveDir -= joystickMoveDir;
+        }
+
         movement->isSprinting = keyboard.isPressed(GLFW_KEY_LEFT_SHIFT) && !movement->isSliding;
 
         float sprintSpeed = movement->walkSpeed * movement->sprintMultiplier;
         float slideStartSpeed = sprintSpeed * movement->slideSpeedMultiplier;
 
-        handleSlidingAndCrouching(movement, keyboard, moveDir, deltaTime, slideStartSpeed);
+        handleSlidingAndCrouching(movement, keyboard, joystick, moveDir, deltaTime, slideStartSpeed);
         handleGroundedMovement(movement, moveDir, deltaTime);
 
         playerPosition += movement->velocity * deltaTime;
 
-        handleDashing(movement, playerPosition, keyboard, frontXZ, moveDir);
-        handleJumpingAndGravity(movement, playerPosition, keyboard, deltaTime);
+        handleDashing(movement, playerPosition, keyboard, frontXZ, moveDir, joystick);
+        handleJumpingAndGravity(movement, playerPosition, keyboard, joystick, deltaTime);
         handleHeightInterpolation(movement, playerPosition, deltaTime);
     }
 

src/game/systems/player-movement-system.hpp

@@ -4,6 +4,7 @@
 #include <components/player-movement.hpp>
 #include <ecs/world.hpp>
 #include <glm/glm.hpp>
+#include <input/joystick.hpp>
 #include <input/keyboard.hpp>
 
 namespace gameplay {
@@ -15,12 +16,13 @@ namespace gameplay {
         CollisionSystem* collisionSystem = nullptr;  // for raycasting checks
 
         void handleSlidingAndCrouching(PlayerMovementComponent* movement, our::Keyboard& keyboard,
-                                       const glm::vec3& moveDir, float deltaTime, float slideStartSpeed);
+                                       our::Joystick& joystick, const glm::vec3& moveDir, float deltaTime,
+                                       float slideStartSpeed);
         void handleGroundedMovement(PlayerMovementComponent* movement, const glm::vec3& moveDir, float deltaTime);
         void handleDashing(PlayerMovementComponent* movement, glm::vec3& playerPosition, our::Keyboard& keyboard,
-                           const glm::vec3& frontXZ, const glm::vec3& moveDir);
+                           const glm::vec3& frontXZ, const glm::vec3& moveDir, our::Joystick& joystick);
         void handleJumpingAndGravity(PlayerMovementComponent* movement, glm::vec3& playerPosition,
-                                     our::Keyboard& keyboard, float deltaTime);
+                                     our::Keyboard& keyboard, our::Joystick& joystick, float deltaTime);
         void handleHeightInterpolation(PlayerMovementComponent* movement, glm::vec3& playerPosition, float deltaTime);
 
         float getGroundHeight(const glm::vec3& position);

src/game/systems/projectile-system.hpp

@@ -134,12 +134,14 @@ namespace gameplay {
             if (!playerComp) return false;
 
             WeaponComponent* weapon = playerComp->currentWeapon;
-            if (!weapon || weapon->currentAmmo <= 0) return false;
+            if (!weapon) return false;
 
             if (weapon->automatic) {
-                if (!app->getMouse().isPressed(GLFW_MOUSE_BUTTON_LEFT)) return false;
+                if (!app->getMouse().isPressed(GLFW_MOUSE_BUTTON_LEFT) && !app->getJoystick().isTriggerPressed(1))
+                    return false;
             } else {
-                if (!app->getMouse().justPressed(GLFW_MOUSE_BUTTON_LEFT)) return false;
+                if (!app->getMouse().justPressed(GLFW_MOUSE_BUTTON_LEFT) && !app->getJoystick().justPressedTrigger(1))
+                    return false;
             }
 
             glm::mat4 playerM = playerEntity->getLocalToWorldMatrix();