CameraManager.hpp

Go to the documentation of this file.

#pragma once
 
#include <GLFW/glfw3.h>
#include <memory>
 
#include "component/Camera.hpp"
#include "component/Transform.hpp"
#include "core/Core.hpp"
#include "entity/Entity.hpp"
#include "exception/CameraMovementError.hpp"
 
namespace CameraMovement::Utils {
class ICameraBehavior;
}
 
namespace CameraMovement::Resource {

class CameraManager {
  public:
    explicit CameraManager(Engine::Core &core) : _core(core) {}
 
    ~CameraManager() = default;

    void SetActiveCamera(Engine::Entity entity)
    {
        if (!entity.IsAlive())
        {
            throw CameraMovementError("Camera entity is invalid");
        }
 
        if (!entity.HasComponents<Object::Component::Transform, Object::Component::Camera>())
        {
            throw CameraMovementError("Camera entity must have both Transform and Camera components");
        }
 
        _cameraEntity = entity;
    }

    Engine::Entity GetActiveCamera() const
    {
        if (!_cameraEntity.has_value() || !_cameraEntity->IsAlive())
        {
            throw CameraMovementError(
                fmt::format("Camera entity is invalid: {}", _cameraEntity.has_value() ? "not alive" : "not set"));
        }
 
        auto &registry = _core.GetRegistry();
        if (!_cameraEntity->HasComponents<Object::Component::Transform, Object::Component::Camera>())
        {
            throw CameraMovementError("Camera entity is missing required components");
        }
 
        return *_cameraEntity;
    }

    bool HasValidCamera() const
    {
        if (!_cameraEntity.has_value() || !_cameraEntity->IsAlive())
        {
            return false;
        }
 
        auto &registry = _core.GetRegistry();
        return _cameraEntity->HasComponents<Object::Component::Transform, Object::Component::Camera>();
    }

    void SetMovementSpeed(float speed) { _movementSpeed = speed; }

    float GetMovementSpeed() const { return _movementSpeed; }

    void SetMouseSensitivity(float sensitivity) { _mouseSensitivity = sensitivity; }

    float GetMouseSensitivity() const { return _mouseSensitivity; }

    void SetLastMousePosition(double x, double y)
    {
        _lastMouseX = x;
        _lastMouseY = y;
    }

    double GetLastMouseX() const { return _lastMouseX; }

    double GetLastMouseY() const { return _lastMouseY; }

    void SetMouseDragging(bool dragging) { _isMouseDragging = dragging; }

    bool IsMouseDragging() const { return _isMouseDragging; }

    void SetOriginRotation(const glm::quat &rotation) { _originRotation = rotation; }

    const glm::quat &GetOriginRotation() const { return _originRotation; }

    void SetWasCursorMasked(bool masked) { _wasCursorMasked = masked; }

    bool WasCursorMasked() const { return _wasCursorMasked; }

    Engine::Core &GetCore() { return _core; }

    void SetJoystickId(int joystickId) { _joystickId = joystickId; }

    int GetJoystickId() const { return _joystickId; }

    void SetBehavior(std::shared_ptr<CameraMovement::Utils::ICameraBehavior> behavior)
    {
        _behavior = std::move(behavior);
    }

    std::shared_ptr<CameraMovement::Utils::ICameraBehavior> GetBehavior() const { return _behavior; }
 
  private:
    Engine::Core &_core;
    std::optional<Engine::Entity> _cameraEntity = std::nullopt;
    float _movementSpeed = 5.0f;
    float _mouseSensitivity = 0.002f;
    double _lastMouseX = 0.0;
    double _lastMouseY = 0.0;
    bool _isMouseDragging = false;
    bool _wasCursorMasked = false;
    glm::quat _originRotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
    int _joystickId = GLFW_JOYSTICK_1;
    std::shared_ptr<CameraMovement::Utils::ICameraBehavior> _behavior = nullptr;
};
 
} // namespace CameraMovement::Resource