feat: player movement (#32)

* refactor: remove translation logic from free camera controller

* feat: add player movement component

* feat: add player movement system

* feat: add jumping to player movement

* feat: improve sliding and allow jumping while sliding, make height lerped from and to crouch

* feat: add a post process shader on dash to give a sense of speed

* chore: format

* fix: sprinting cancels crouching

* chore: remove redundant camera check

* refactor: split movement into functions

* refactor: add postprocesssystem for gameplay driven post process shaders, and move postprocesscomponent from game to common

* format

Author: OmarGamal10

CMakeLists.txt

@@ -265,6 +265,8 @@ add_executable(${PROJECT_NAME}
     src/game/game-registration.cpp
     src/game/systems/collision-system.cpp
     src/game/systems/collision-debug-drawer.cpp
+    src/game/components/player-movement.cpp
+    src/game/systems/player-movement-system.cpp
 
     src/common/systems/forward-renderer.cpp
     src/common/systems/audio-system.cpp

assets/shaders/postprocess/dash-distortion.frag

@@ -0,0 +1,41 @@
+#version 330
+
+uniform sampler2D tex;
+uniform float intensity;
+
+in vec2 tex_coord;
+out vec4 frag_color;
+
+#define BLUR_SAMPLES 8
+
+void main() {
+    vec2 center = vec2(0.5);
+    vec2 dir = tex_coord - center;
+
+    // Radial Zoom Blur
+    vec3 color = vec3(0.0);
+    float blurStrength = intensity * 0.2;
+    for (int i = 0; i < BLUR_SAMPLES; i++) {
+        float t = float(i) / float(BLUR_SAMPLES);
+        vec2 offset = dir * blurStrength * t;
+        color += texture(tex, tex_coord - offset).rgb;
+    }
+    color /= float(BLUR_SAMPLES);
+
+    // Chromatic Aberration
+    float caStrength = intensity * 0.015;
+    vec2 caDir = normalize(dir + vec2(0.001)) * caStrength;
+    float r = texture(tex, tex_coord - caDir).r;
+    float g = texture(tex, tex_coord).g;
+    float b = texture(tex, tex_coord + caDir).b;
+    vec3 caColor = vec3(r, g, b);
+
+    color = mix(color, caColor, 0.4);
+
+    // Vignette
+    vec2 ndc = tex_coord * 2.0 - 1.0;
+    float vignette = 1.0 / (1.0 + dot(ndc, ndc));
+    color *= vignette;
+
+    frag_color = vec4(color, 1.0);
+}

config/app.jsonc

@@ -11,7 +11,7 @@
     "scene": {
         "renderer": {
             "sky": "assets/textures/sky.jpg",
-            "postprocess": "assets/shaders/postprocess/vignette.frag"
+            "postprocess": "assets/shaders/postprocess/dash-distortion.frag"
         },
         "assets": {
             "shaders": {
@@ -290,15 +290,32 @@
                     },
                     {
                         "type": "Free Camera Controller",
-                        "positionSensitivity": [8.0, 0.0, 8.0],
-                        "rotationSensitivity": 0.008,
-                        "speedupFactor": 2.5,
+                        "rotationSensitivity": 0.01,
+                        "fovSensitivity": 0.3
+                    },
+                    {
+                        "type": "PlayerMovement",
+                        "walkSpeed": 8.0,
+                        "sprintMultiplier": 2.0,
+                        "crouchSpeed": 4.0,
+                        "crouchHeight": 1.0,
+                        "slideSpeedMultiplier": 1.5,
+                        "slideDuration": 0.8,
+                        "slideCooldown": 0.5,
+                        "dashDistance": 5.0,
+                        "dashCooldown": 1.0,
                         "groundLevel": 0.0,
-                        "playerHeight": 1.8
+                        "playerHeight": 2,
+                        "jumpForce": 9.0
                     },
                     {
                         "type": "Player"
                     },
+                    {
+                        "type": "Post Process Effects Component"
+                    }
+                ],
+                "children": [
                     {
                         "type": "Health",
                         "maxHealth": 100.0

src/common/components/free-camera-controller.cpp

@@ -1,17 +1,10 @@
 #include "free-camera-controller.hpp"
 
-#include "../deserialize-utils.hpp"
-#include "../ecs/entity.hpp"
-
 namespace our {
     // Reads sensitivities & speedupFactor from the given json object
     void FreeCameraControllerComponent::deserialize(const nlohmann::json& data) {
         if (!data.is_object()) return;
         rotationSensitivity = data.value("rotationSensitivity", rotationSensitivity);
         fovSensitivity = data.value("fovSensitivity", fovSensitivity);
-        positionSensitivity = data.value("positionSensitivity", positionSensitivity);
-        speedupFactor = data.value("speedupFactor", speedupFactor);
-        groundLevel = data.value("groundLevel", groundLevel);
-        playerHeight = data.value("playerHeight", playerHeight);
     }
 }  // namespace our

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

@@ -16,13 +16,6 @@ namespace our {
         // The senstivity paramter defined sensitive the camera rotation & fov is to the mouse moves and wheel scrolling
         float rotationSensitivity = 0.01f;  // The angle change per pixel of mouse movement
         float fovSensitivity = 0.3f;        // The fov angle change per unit of mouse wheel scrolling
-        glm::vec3 positionSensitivity = {3.0f, 3.0f,
-                                         3.0f};  // The unity per second of camera movement if WASD is pressed
-        float speedupFactor = 5.0f;              // A multiplier for the positionSensitivity if "Left Shift" is held.
-
-        // Ground collision
-        float groundLevel = 0.0f;
-        float playerHeight = 1.7f;
 
         // The ID of this component type is "Free Camera Controller"
         static std::string getID() {

src/common/components/post-process-effects.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <ecs/component.hpp>
+#include <string>
+#include <unordered_map>
+
+namespace our {
+
+    // values set by gameplay and read by the renderer for the active postprocess shader
+    class PostProcessEffectsComponent : public Component {
+    public:
+        std::unordered_map<std::string, float> uniforms;
+
+        static std::string getID() {
+            return "Post Process Effects Component";
+        }
+
+        void deserialize(const nlohmann::json& data) override {}
+    };
+
+}  // namespace our

src/common/systems/forward-renderer.cpp

@@ -1,6 +1,7 @@
 #include "forward-renderer.hpp"
 
 #include "../components/model-renderer.hpp"
+#include "../components/post-process-effects.hpp"
 #include "../mesh/mesh-utils.hpp"
 #include "../texture/texture-utils.hpp"
 
@@ -280,6 +281,17 @@ namespace our {
         if (postprocessMaterial) {
             glBindFramebuffer(GL_FRAMEBUFFER, 0);
             postprocessMaterial->setup();
+
+            for (auto entity : world->getEntities()) {
+                if (auto* effects = entity->getComponent<our::PostProcessEffectsComponent>()) {
+                    for (auto& [name, value] : effects->uniforms) {
+                        postprocessMaterial->shader->set(name, value);
+                    }
+                    break;  // handles gameplay driven postprocess effects, other ones (like bloom) should be handled
+                            // separately outside this loop
+                }
+            }
+
             glBindVertexArray(postProcessVertexArray);
             glDrawArrays(GL_TRIANGLES, 0, 3);
         }

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

@@ -45,8 +45,7 @@ namespace our {
             // Get the entity that we found via getOwner of camera (we could use controller->getOwner())
             Entity* entity = camera->getOwner();
 
-            // We get a reference to the entity's position and rotation
-            glm::vec3& position = entity->localTransform.position;
+            // We get a reference to the entity's rotation
             glm::vec3& rotation = entity->localTransform.rotation;
 
             // While the play state is active, the mouse stays locked
@@ -69,31 +68,6 @@ namespace our {
             fov = glm::clamp(fov, glm::pi<float>() * 0.01f,
                              glm::pi<float>() * 0.99f);  // We keep the fov in the range 0.01*PI to 0.99*PI
             camera->fovY = fov;
-
-            // We get the camera model matrix (relative to its parent) to compute the front and right directions
-            glm::mat4 matrix = entity->localTransform.toMat4();
-
-            glm::vec3 front = glm::vec3(matrix * glm::vec4(0, 0, -1, 0));
-            glm::vec3 right = glm::vec3(matrix * glm::vec4(1, 0, 0, 0));
-
-            glm::vec3 current_sensitivity = controller->positionSensitivity;
-            // If the LEFT SHIFT key is pressed, we multiply the position sensitivity by the speed up factor
-            if (app->getKeyboard().isPressed(GLFW_KEY_LEFT_SHIFT)) current_sensitivity *= controller->speedupFactor;
-
-            // We change the camera position based on the keys WASD
-            glm::vec3 frontXZ = glm::normalize(glm::vec3(front.x, 0, front.z));
-            glm::vec3 rightXZ = glm::normalize(glm::vec3(right.x, 0, right.z));
-
-            // S & W moves the player back and forth along the ground plane
-            if (app->getKeyboard().isPressed(GLFW_KEY_W)) position += frontXZ * (deltaTime * current_sensitivity.z);
-            if (app->getKeyboard().isPressed(GLFW_KEY_S)) position -= frontXZ * (deltaTime * current_sensitivity.z);
-            // A & D moves the player left or right along the ground plane
-            if (app->getKeyboard().isPressed(GLFW_KEY_D)) position += rightXZ * (deltaTime * current_sensitivity.x);
-            if (app->getKeyboard().isPressed(GLFW_KEY_A)) position -= rightXZ * (deltaTime * current_sensitivity.x);
-
-            // stop the player from going below the ground plane
-            float minY = controller->groundLevel + controller->playerHeight;
-            if (position.y < minY) position.y = minY;
         }
 
         // When the state exits, it should call this function to ensure the mouse is unlocked

src/game/components/player-movement.cpp

@@ -0,0 +1,28 @@
+#include "player-movement.hpp"
+
+namespace gameplay {
+
+    void PlayerMovementComponent::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) return;
+
+        walkSpeed = data.value("walkSpeed", walkSpeed);
+        groundLevel = data.value("groundLevel", groundLevel);
+        playerHeight = data.value("playerHeight", playerHeight);
+
+        sprintMultiplier = data.value("sprintMultiplier", sprintMultiplier);
+
+        crouchSpeed = data.value("crouchSpeed", crouchSpeed);
+        crouchHeight = data.value("crouchHeight", crouchHeight);
+
+        slideSpeedMultiplier = data.value("slideSpeedMultiplier", slideSpeedMultiplier);
+        slideDuration = data.value("slideDuration", slideDuration);
+        slideCooldown = data.value("slideCooldown", slideCooldown);
+
+        dashDistance = data.value("dashDistance", dashDistance);
+        dashCooldown = data.value("dashCooldown", dashCooldown);
+
+        jumpForce = data.value("jumpForce", jumpForce);
+        gravity = data.value("gravity", gravity);
+    }
+
+}  // namespace gameplay

src/game/components/player-movement.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <ecs/component.hpp>
+#include <glm/glm.hpp>
+
+namespace gameplay {
+
+    class PlayerMovementComponent : public our::Component {
+    public:
+        float walkSpeed = 5.0f;
+        float groundLevel = 0.0f;
+        float playerHeight = 1.7f;
+
+        float sprintMultiplier = 2.0f;
+
+        float crouchSpeed = 3.0f;
+        float crouchHeight = 1.0f;
+
+        float slideSpeedMultiplier = 1.5f;
+        float slideDuration = 1.0f;
+        float slideCooldown = 0.3f;
+
+        float dashDistance = 5.0f;
+        float dashCooldown = 1.5f;
+
+        float jumpForce = 8.0f;
+        float gravity = 20.0f;  // decrease for floatiness, can be a powerup easily
+
+        glm::vec3 velocity = {0, 0, 0};
+        bool isSprinting = false;
+        bool isCrouching = false;
+        bool isSliding = false;
+        float slideTimer = 0.0f;
+        float slideCooldownTimer = 0.0f;
+        float dashCooldownTimer = 0.0f;
+        bool dashTriggeredThisFrame = false;
+        float verticalVelocity = 0.0f;
+        bool isGrounded = true;
+
+        static std::string getID() {
+            return "PlayerMovement";
+        }
+
+        void deserialize(const nlohmann::json& data) override;
+    };
+
+}  // namespace gameplay