Camera.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/RenderAPI/Forward.hpp"
 
#include "SceneObject.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/ScopeExit.hpp"
 
#include "CeresEngine/Entity/Component.hpp"
#include "CeresEngine/Entity/Entity.hpp"
#include "CeresEngine/Entity/Event.hpp"
#include "CeresEngine/Entity/System.hpp"
#include "CeresEngine/Input/Action.hpp"
#include "CeresEngine/Input/Range.hpp"
#include "CeresEngine/Math/Extent.hpp"
#include "CeresEngine/Math/Geometry.hpp"
#include "CeresEngine/Math/Math.hpp"
#include "CeresEngine/Math/Rect.hpp"
#include "CeresEngine/Math/Offset.hpp"
#include "CeresEngine/Renderer/RendererCameraSettings.hpp"
#include "CeresEngine/Renderer/RendererSettings.hpp"
 
namespace CeresEngine {
 
    enum class CameraProjection {
        Perspective,
 
        Orthographic,
    };
 
    struct CameraSettings {
        double focalLength;
 
        double orthographicScale;
 
        Extent2 sensorSize;
 
        Offset2 lensShift;
 
        double nearPlane = 0.1;
 
        double farPlane = std::numeric_limits<double>::infinity();
    };
 
    struct CE_SCRIPT_EXPORT() CameraComponent final : public Component<CameraComponent> {
        CE_REFLECTABLE_STRUCT
        struct Accessor;
 
        CE_SCRIPT_EXPORT()
        double fieldOfView = 45.0;
 
        CE_SCRIPT_EXPORT()
        double nearPlane = 0.1;
 
        CE_SCRIPT_EXPORT()
        double farPlane = std::numeric_limits<double>::infinity();
 
        CE_SCRIPT_EXPORT()
        double aspectRatio = 4.0 / 3.0;
 
        GPUImagePtr renderImage;
 
        RendererCameraSettings rendererSettings;
 
        CE_SCRIPT_EXPORT()
        CameraComponent();
 
        // Destroys the camera component.
        ~CameraComponent() noexcept final;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(fieldOfView);
            CE_REFL_DATA(nearPlane);
            CE_REFL_DATA(farPlane);
            CE_REFL_DATA(aspectRatio);
            CE_REFL_DATA(renderImage);
            CE_REFL_DATA(rendererSettings);
        }
    };
 
    struct CE_SCRIPT_EXPORT() CameraComponent::Accessor : public Component<CameraComponent>::Accessor {
        using Component<CameraComponent>::Accessor::Accessor;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getFieldOfView() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setFieldOfView(double fieldOfView) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getNearPlane() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setNearPlane(double nearPlane) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getFarPlane() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setFarPlane(double farPlane) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getAspectRatio() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setAspectRatio(double aspectRatio) noexcept;
 
        [[nodiscard]] const GPUImagePtr& getRenderImage() const;
 
        void setRenderImage(GPUImagePtr renderImage);
 
        [[nodiscard]] const RendererCameraSettings& getRendererSettings() const;
 
        void setRendererSettings(const RendererCameraSettings& rendererSettings);
 
        template<CInvocable<RendererCameraSettings&> Func> decltype(auto) updateRendererSettings(Func&& func) noexcept {
            RendererCameraSettings settings = getRendererSettings();
            const ScopeExit commitSettings([&]() { setRendererSettings(settings); });
            return func(settings);
        }
 
        CE_SCRIPT_EXPORT()
        void changeViewportAspectRatio(double width, double height) noexcept;
 
    public: // Transforms
        [[nodiscard]] Matrix4 getProjection() const noexcept;
 
        [[nodiscard]] Transform getView() const noexcept;
 
        [[nodiscard]] Vector3 unproject(Vector3 screenSpaceVector) const noexcept;
 
        //                              transformed
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 project(Vector3 worldSpaceVector) const noexcept;
 
        [[nodiscard]] Ray toRay(const Point2& point) const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool visible(Vector3 worldSpaceVector) const noexcept;
 
        [[nodiscard]] bool visible(const AABox& boundingBox) const noexcept;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA_GETSET(fieldOfView, getFieldOfView, setFieldOfView);
            CE_REFL_DATA_GETSET(nearPlane, getNearPlane, setNearPlane);
            CE_REFL_DATA_GETSET(farPlane, getFarPlane, setFarPlane);
            CE_REFL_DATA_GETSET(aspectRatio, getAspectRatio, setAspectRatio);
            CE_REFL_DATA_GETSET(renderImage, getRenderImage, setRenderImage);
            CE_REFL_DATA_GETSET(rendererSettings, getRendererSettings, setRendererSettings);
        }
    };
 
    class CE_SCRIPT_EXPORT() Camera final : public TSceneObject<CameraComponent> {
    public:
        using TSceneObject::TSceneObject;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static Camera find(const EntityManager& entityManager) noexcept;
    };
 
} // namespace CeresEngine
 
CE_EXTERN_COMPONENT(CeresEngine::CameraComponent);
 
CE_REFLECT_HASH(CeresEngine::CameraComponent);
 
CE_ENTITY_OBJECT_HASH(CeresEngine::Camera);