CameraComponent.cpp

Go to the documentation of this file.

#include "Engine/Component/CameraComponent.h"
#include "Engine/World/SceneGraph.h"
#include "Engine/Ecs/RegistryManager.h"
#include "Engine/Ecs/EcsData.h"
#include <glm/gtc/matrix_transform.hpp>
#include <plog/Log.h>
 
namespace EngineCore {
 
    // Static pointer to track the active camera
    static CameraComponent* s_activeCamera = nullptr;
 
    CameraComponent::CameraComponent(Scene* owningScene,
                                     std::shared_ptr<SceneNode> sceneNode,
                                     float fov,
                                     float nearPlane,
                                     float farPlane)
        : LogicComponent(owningScene)
        , sceneNode_(std::move(sceneNode))
        , fov_(fov)
        , nearPlane_(nearPlane)
        , farPlane_(farPlane)
    {
        setCanTick(false);  // Camera doesn't need to tick by default
    }
 
    void CameraComponent::beginPlay() {
        LogicComponent::beginPlay();
 
        auto& registry = Ecs::RegistryManager::get();
        cameraEntity_ = registry.create();
 
        // Store camera properties in ECS for easy querying
        auto& props = registry.emplace<Ecs::CameraProperties>(cameraEntity_);
        props.fov = fov_;
        props.nearPlane = nearPlane_;
        props.farPlane = farPlane_;
        props.aspectRatio = aspectRatio_;
 
        updateProjectionMatrix();
 
        PLOGD << "CameraComponent initialized with FOV=" << fov_ << " near=" << nearPlane_ << " far=" << farPlane_;
    }
 
    void CameraComponent::tick(double /*deltaTime*/) {
        // Camera component doesn't need to tick - view matrix is computed on demand from SceneNode
        // Projection matrix is only updated when parameters change
    }
 
    void CameraComponent::endPlay() {
        // Clear the static pointer if this was the active camera
        if (s_activeCamera == this) {
            s_activeCamera = nullptr;
        }
 
        if (cameraEntity_ != entt::null) {
            auto& registry = Ecs::RegistryManager::get();
            // Remove active tag if present
            registry.remove<Ecs::ActiveCamera>(cameraEntity_);
            registry.destroy(cameraEntity_);
            cameraEntity_ = entt::null;
        }
 
        LogicComponent::endPlay();
    }
 
    void CameraComponent::setActive(bool active) {
        auto& registry = Ecs::RegistryManager::get();
 
        if (active) {
            // First, remove ActiveCamera tag from any other cameras
            auto view = registry.view<Ecs::ActiveCamera>();
            for (auto entity : view) {
                registry.remove<Ecs::ActiveCamera>(entity);
            }
 
            // Clear previous active camera pointer
            s_activeCamera = nullptr;
 
            // Add ActiveCamera tag to this camera's entity
            if (cameraEntity_ != entt::null && !registry.all_of<Ecs::ActiveCamera>(cameraEntity_)) {
                registry.emplace<Ecs::ActiveCamera>(cameraEntity_);
            }
 
            // Set this as the active camera
            s_activeCamera = this;
            PLOGD << "Camera set as active";
        } else {
            // Remove ActiveCamera tag from this camera
            if (cameraEntity_ != entt::null) {
                registry.remove<Ecs::ActiveCamera>(cameraEntity_);
            }
 
            // Clear the static pointer if this was the active camera
            if (s_activeCamera == this) {
                s_activeCamera = nullptr;
            }
        }
    }
 
    bool CameraComponent::isActive() const {
        if (cameraEntity_ == entt::null) {
            return false;
        }
        auto& registry = Ecs::RegistryManager::get();
        return registry.all_of<Ecs::ActiveCamera>(cameraEntity_);
    }
 
    glm::mat4 CameraComponent::getViewMatrix() const {
        if (!sceneNode_) {
            return glm::mat4(1.0f);
        }
 
        // The view matrix is the inverse of the camera's world transform
        // Camera looks down -Z in its local space (OpenGL/Vulkan convention)
        return glm::inverse(sceneNode_->getWorldMatrix());
    }
 
    glm::mat4 CameraComponent::getProjectionMatrix() const {
        if (projectionDirty_) {
            const_cast<CameraComponent*>(this)->updateProjectionMatrix();
        }
        return cachedProjectionMatrix_;
    }
 
    glm::mat4 CameraComponent::getViewProjectionMatrix() const {
        return getProjectionMatrix() * getViewMatrix();
    }
 
    void CameraComponent::setFov(float fov) {
        fov_ = fov;
        projectionDirty_ = true;
 
        if (cameraEntity_ != entt::null) {
            auto& registry = Ecs::RegistryManager::get();
            if (auto* props = registry.try_get<Ecs::CameraProperties>(cameraEntity_)) {
                props->fov = fov;
            }
        }
    }
 
    void CameraComponent::setAspectRatio(float aspectRatio) {
        aspectRatio_ = aspectRatio;
        projectionDirty_ = true;
 
        if (cameraEntity_ != entt::null) {
            auto& registry = Ecs::RegistryManager::get();
            if (auto* props = registry.try_get<Ecs::CameraProperties>(cameraEntity_)) {
                props->aspectRatio = aspectRatio;
            }
        }
    }
 
    void CameraComponent::setNearPlane(float nearPlane) {
        nearPlane_ = nearPlane;
        projectionDirty_ = true;
 
        if (cameraEntity_ != entt::null) {
            auto& registry = Ecs::RegistryManager::get();
            if (auto* props = registry.try_get<Ecs::CameraProperties>(cameraEntity_)) {
                props->nearPlane = nearPlane;
            }
        }
    }
 
    void CameraComponent::setFarPlane(float farPlane) {
        farPlane_ = farPlane;
        projectionDirty_ = true;
 
        if (cameraEntity_ != entt::null) {
            auto& registry = Ecs::RegistryManager::get();
            if (auto* props = registry.try_get<Ecs::CameraProperties>(cameraEntity_)) {
                props->farPlane = farPlane;
            }
        }
    }
 
    glm::vec3 CameraComponent::getWorldPosition() const {
        if (!sceneNode_) {
            return glm::vec3(0.0f);
        }
        const auto& worldMatrix = sceneNode_->getWorldMatrix();
        return glm::vec3(worldMatrix[3]);
    }
 
    glm::vec3 CameraComponent::getForwardVector() const {
        if (!sceneNode_) {
            return glm::vec3(0.0f, 0.0f, -1.0f);
        }
        const auto& worldMatrix = sceneNode_->getWorldMatrix();
        // Forward is -Z in camera space
        return -glm::normalize(glm::vec3(worldMatrix[2]));
    }
 
    glm::vec3 CameraComponent::getRightVector() const {
        if (!sceneNode_) {
            return glm::vec3(1.0f, 0.0f, 0.0f);
        }
        const auto& worldMatrix = sceneNode_->getWorldMatrix();
        // Right is +X in camera space
        return glm::normalize(glm::vec3(worldMatrix[0]));
    }
 
    glm::vec3 CameraComponent::getUpVector() const {
        if (!sceneNode_) {
            return glm::vec3(0.0f, 1.0f, 0.0f);
        }
        const auto& worldMatrix = sceneNode_->getWorldMatrix();
        // Up is +Y in camera space
        return glm::normalize(glm::vec3(worldMatrix[1]));
    }
 
    void CameraComponent::updateProjectionMatrix() {
        // Reverse-Z perspective projection for better depth precision
        // Near plane maps to 1.0, far plane maps to 0.0
        float fovRadians = glm::radians(fov_);
        float tanHalfFov = glm::tan(fovRadians * 0.5f);
 
        cachedProjectionMatrix_ = glm::mat4(0.0f);
        cachedProjectionMatrix_[0][0] = 1.0f / (aspectRatio_ * tanHalfFov);
        cachedProjectionMatrix_[1][1] = 1.0f / tanHalfFov;
        cachedProjectionMatrix_[2][2] = nearPlane_ / (farPlane_ - nearPlane_);
        cachedProjectionMatrix_[2][3] = -1.0f;
        cachedProjectionMatrix_[3][2] = (nearPlane_ * farPlane_) / (farPlane_ - nearPlane_);
 
        // Vulkan uses a different clip space convention - flip Y
        cachedProjectionMatrix_[1][1] *= -1.0f;
 
        projectionDirty_ = false;
    }
 
    CameraComponent* getActiveCamera() {
        return s_activeCamera;
    }
 
    bool hasActiveCamera() {
        return s_activeCamera != nullptr;
    }
}