RendererCamera.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 "Forward.hpp"
#include "RenderGraph/Forward.hpp"
 
#include "RendererCameraSettings.hpp"
#include "RendererSceneObject.hpp"
#include "RendererView.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Math/Geometry.hpp"
#include "CeresEngine/Math/Transform.hpp"
#include "CeresEngine/RenderAPI/GPUBuffer.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
#include "CeresEngine/Scene/Camera.hpp"
 
namespace CeresEngine {
 
    CE_DECL_RENDERER_OBJECT(RendererCamera);
 
    enum class RendererCameraFlag {
    };
 
    using RendererCameraFlags = Flags<RendererCameraFlag>;
    CE_FLAGS_OPERATORS(RendererCameraFlag)
 
    
    enum class RendererCameraDirtyFlag {
        None = 0,
 
        Transform = (1u << 0u),
 
        Component = (1u << 1u),
 
        UniformBuffer = (1u << 2u),
 
        Flags = (1u << 3u),
 
        All = 0xFFFF,
    };
 
    using RendererCameraDirtyFlags = Flags<RendererCameraDirtyFlag>;
    CE_FLAGS_OPERATORS(RendererCameraDirtyFlag)
 
    
    struct RendererCameraParams {
        alignas(16) Matrix4f view;
        alignas(16) Matrix4f invView;
        alignas(16) Matrix4f projection;
        alignas(16) Matrix4f invProjection;
        alignas(16) Matrix4f viewProjection;
        alignas(16) Matrix4f invViewProjection;
        alignas(16) Matrix4f pivot;
        alignas(16) Matrix4f invPivot;
 
        alignas(16) Vector3f position;
        alignas(4) float fieldOfView;
        alignas(4) float nearPlane;
        alignas(4) float farPlane;
        alignas(4) float aspectRatio;
        alignas(4) float gamma;
        alignas(4) float exposure;
    };
 
    struct RendererCameraInfo : public RendererViewInfo {
        Any globalIlluminationContext;
    };
 
    class RendererCamera final : public RendererView, public TRendererSceneObject<RendererCamera> {
        using super = TRendererSceneObject<RendererCamera>;
        friend class RendererCameraManager;
 
    private:
        CameraComponent mComponent;
 
        RendererCameraFlags mFlags;
 
        RendererCameraDirtyFlags mDirtyFlags = RendererCameraDirtyFlag::All;
 
        bool mDirty = true;
 
        RendererCameraInfo mInfo;
 
        RendererCameraParams mParameters;
 
        GPUDynamicBindlessBuffer<RendererCameraParams> mUniformBuffer;
 
    public:
        explicit RendererCamera(RendererCameraManager& manager, RendererScene& scene);
 
        ~RendererCamera() noexcept override;
 
    public:
        void synchronize(const Transform& transform, const CameraComponent& component);
 
        void prepare(RendererContext& context) final;
 
    public:
        [[nodiscard]] RendererScene& getScene() const final { return super::getScene(); }
 
        [[nodiscard]] const CameraComponent& getComponent() const noexcept { return mComponent; }
 
        [[nodiscard]] const RendererCameraSettings& getSettings() const final { return mComponent.rendererSettings; }
 
        [[nodiscard]] const RendererCameraFlags& getFlags() const noexcept { return mFlags; }
 
        void setFlags(const RendererCameraFlags& flags);
 
        [[nodiscard]] const RendererCameraDirtyFlags& getDirtyFlags() const noexcept { return mDirtyFlags; }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirtyFlags != RendererCameraDirtyFlag::None; }
 
        void markAsDirty(const RendererCameraDirtyFlags& flags = RendererCameraDirtyFlag::All) noexcept;
 
        [[nodiscard]] const RendererCameraInfo& getViewInfo() const final { return mInfo; }
 
        [[nodiscard]] RendererCameraInfo& getViewInfo() final { return mInfo; }
 
        [[nodiscard]] const GPUBindlessBuffer& getUniformBuffer() const final { return mUniformBuffer; }
 
        [[nodiscard]] const GPUImagePtr& getRenderImage() const final { return mComponent.renderImage; }
 
        [[nodiscard]] const ConvexVolume& getFrustumVolume() const final { return mInfo.frustumVolume; }
    };
 
    class RendererCameraManager final : public TRendererSceneObjectManager<RendererCameraManager, RendererCamera> {
        using super = TRendererSceneObjectManager<RendererCameraManager, RendererCamera>;
 
    private:
        using UniformBufferType = GPUDynamicStridedBindlessBufferArray<RendererCameraParams>;
 
        Vector<UPtr<RendererCamera>> mCameras;
 
        UniformBufferType mUniformBuffer;
 
    public:
        explicit RendererCameraManager(Renderer& renderer);
 
        ~RendererCameraManager() noexcept final;
 
    public:
        Async<> prepare(RendererContext& context);
 
    private: // Camera interface
        friend class RendererCamera;
 
        void markAsDirty(RendererCamera* const camera);
    };
 
} // namespace CeresEngine