fps_camera.h

#ifndef OE_COMPONENT_FPS_CAMERA_H
#define OE_COMPONENT_FPS_CAMERA_H
 
#include <chrono>
#include <glm/gtx/vector_angle.hpp>
 
#include "../scene/camera.h"
#include "../core/event_handler.h"
 
namespace oe::component
{
    struct FpsCamera
    {
        FpsCamera(oe::scene::Camera* camera) noexcept:
            ptr_camera(camera)
        {}

        void update(const core::EventHandler& event_handler, const std::chrono::nanoseconds delta)
        {
            assert(ptr_camera);
 
            auto& camera = *ptr_camera;
 
            glm::vec2 offset = event_handler.getCursorOffset();
            float delta_nanoseconds = std::chrono::duration_cast<std::chrono::duration<float>>(delta).count();
 
            static constexpr float min_pitch_angle = -glm::half_pi<float>(); // Should not go below -pi/2, (must be clamped in setter)
            static constexpr float max_pitch_angle = glm::half_pi<float>(); // Should not go above pi/2, (must be clamped in setter)
 
            glm::vec3 forward = camera.getRotation() * glm::vec3{0.0f, 0.0f, 1.0f};
            // Take the orientation of the player node into account
            glm::vec3 local_up = glm::vec3{0.0f, -1.0f, 0.0f};
            // Cannot use cross product here since forward and local_up are almost colinear when looking strait up or down
            glm::vec3 sideway = camera.getRotation() * glm::vec3{1.0f, 0.0f, 0.0f};
 
            float delta_yaw   = sensitivity * offset.x;
            float delta_pitch = sensitivity * offset.y;
 
            float pitch_before = glm::half_pi<float>() - glm::orientedAngle(forward, local_up, sideway);
            float pitch_after = std::clamp(pitch_before + delta_pitch, min_pitch_angle, max_pitch_angle);
            delta_pitch = pitch_after - pitch_before;
 
            // Apply the rotation
            camera.relativeRotate(glm::angleAxis(delta_yaw, local_up) * glm::angleAxis(delta_pitch, sideway));
 
            // Compute translation amount based on inputs
            bool move_forward  = event_handler.isKeyPressed(controls.forward);
            bool move_backward = event_handler.isKeyPressed(controls.backward);
            bool move_left = event_handler.isKeyPressed(controls.left);
            bool move_right = event_handler.isKeyPressed(controls.right);
            bool move_upward = event_handler.isKeyPressed(controls.up);
            bool move_downward = event_handler.isKeyPressed(controls.down);
 
            bool move_walk = event_handler.isKeyPressed(controls.walk);
            bool move_run = event_handler.isKeyPressed(controls.run);
 
            // -1.0f or +1.0f depending on the inputs for a given axis
            float front_direction = static_cast<float>(move_forward) - static_cast<float>(move_backward);
            float strafe_direction = static_cast<float>(move_left) - static_cast<float>(move_right);
            float upward_direction = static_cast<float>(move_upward) - static_cast<float>(move_downward);
 
            float camera_speed = default_speed * delta_nanoseconds;
 
            if (move_walk)
            {
                camera_speed *= slow_factor;
            }
 
            if (move_run)
            {
                camera_speed *= speed_factor;
            }
 
            float forward_delta = front_direction * camera_speed;
            float sideway_delta = strafe_direction * camera_speed;
            float upward_delta = upward_direction * camera_speed;
 
            glm::vec3 translation = forward_delta * forward + sideway_delta * sideway + upward_delta * local_up;
 
            camera.relativeTranslate(-translation);
        }

        struct KeyBindings
        {
            std::uint32_t forward = core::KeyboardKey::KEY_W;
            std::uint32_t backward = core::KeyboardKey::KEY_S;
            std::uint32_t left = core::KeyboardKey::KEY_A;
            std::uint32_t right = core::KeyboardKey::KEY_D;
            std::uint32_t up = core::KeyboardKey::KEY_Q;
            std::uint32_t down = core::KeyboardKey::KEY_Z;
            std::uint32_t walk = core::KeyboardKey::KEY_LEFT_SHIFT;
            std::uint32_t run = core::KeyboardKey::KEY_LEFT_CONTROL;
        };

        KeyBindings controls;

        float default_speed = 6.0f;

        float sensitivity = 0.001f;

        float speed_factor = 4.f;

        float slow_factor = 0.05f;

        oe::scene::Camera* ptr_camera;
    };
}
 
#endif