RendererLight.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 "RendererLightSettings.hpp"
#include "RendererSceneObject.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/Light.hpp"
 
namespace CeresEngine {
 
    CE_DECL_RENDERER_OBJECT(RendererLight);
 
    enum class RendererLightFlag {
    };
 
    using RendererLightFlags = Flags<RendererLightFlag>;
    CE_FLAGS_OPERATORS(RendererLightFlag)
 
    
    enum class RendererLightDirtyFlag {
        None = 0,
 
        Transform = (1u << 0u),
 
        Component = (1u << 1u),
 
        UniformBuffer = (1u << 2u),
 
        Flags = (1u << 3u),
 
        All = 0xFFFF,
    };
 
    using RendererLightDirtyFlags = Flags<RendererLightDirtyFlag>;
    CE_FLAGS_OPERATORS(RendererLightDirtyFlag)
 
    
    struct RendererLightParams {
        alignas(4) UInt32 type;
 
        alignas(16) Vector3f position;
        alignas(16) Vector3f direction;
 
        alignas(16) Matrix4f transform;
        alignas(16) Matrix4f invTransform;
 
        alignas(16) Matrix4f lightSpaceMatrix;
        alignas(16) Matrix4f invLightSpaceMatrix;
 
        alignas(4) float cutOff;
        alignas(4) float outerCutOff;
 
        alignas(4) float constant;
        alignas(4) float linear;
        alignas(4) float quadratic;
 
        alignas(16) Vector3f color;
        alignas(4) float strength;
 
        alignas(4) UInt32 shouldCastShadows;
        alignas(4) float shadowOcclusionStrength;
 
        alignas(4) UInt32 usePCF;
        alignas(4) float shadowPCFBias;
        alignas(4) UInt32 shadowPCFSamples;
        alignas(4) float shadowPCFSamplingDistance;
    };
 
    struct RendererLightInfo {
        bool needsShadowMapUpdate = true;
 
        Matrix4 lightSpaceMatrix;
    };
 
    class RendererLight final : public TRendererSceneObject<RendererLight> {
        using super = TRendererSceneObject<RendererLight>;
        friend class RendererLightManager;
 
    private:
        LightComponent mComponent;
 
        RendererLightFlags mFlags;
 
        RendererLightDirtyFlags mDirtyFlags = RendererLightDirtyFlag::All;
 
        bool mDirty = true;
 
        RendererLightInfo mInfo;
 
        RendererLightParams mParameters;
 
        GPUDynamicBindlessBuffer<RendererLightParams> mUniformBuffer;
 
        GPUImagePtr mShadowMap = nullptr;
 
    public:
        explicit RendererLight(RendererLightManager& manager, RendererScene& scene);
 
        ~RendererLight() noexcept final;
 
    public:
        void synchronize(const Transform& transform, const LightComponent& component);
 
        void prepare(RendererContext& context);
 
        void renderShadow(GPUCommandBuffer& commandBuffer);
 
    public:
        [[nodiscard]] LightComponent getComponent() const { return mComponent; }
 
        [[nodiscard]] const RendererLightSettings& getSettings() const { return mComponent.rendererSettings; }
 
        [[nodiscard]] const RendererLightFlags& getFlags() const noexcept { return mFlags; }
 
        void setFlags(const RendererLightFlags& flags);
 
        [[nodiscard]] const RendererLightDirtyFlags& getDirtyFlags() const noexcept { return mDirtyFlags; }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirtyFlags != RendererLightDirtyFlag::None; }
 
        void markAsDirty(const RendererLightDirtyFlags& flags = RendererLightDirtyFlag::All) noexcept;
 
        [[nodiscard]] const RendererLightInfo& getInfo() const { return mInfo; }
 
        [[nodiscard]] RendererLightInfo& getInfo() { return mInfo; }
 
        [[nodiscard]] const GPUBindlessBuffer& getUniformBuffer() const { return mUniformBuffer; }
 
        [[nodiscard]] Sphere getBoundingSphere() const;
 
        [[nodiscard]] const GPUImagePtr& getShadowMap() const { return mShadowMap; }
 
        void setShadowMap(const GPUImagePtr& shadowMap);
    };
 
    class RendererLightManager final : public TRendererSceneObjectManager<RendererLightManager, RendererLight> {
        using super = TRendererSceneObjectManager<RendererLightManager, RendererLight>;
 
    private:
        using UniformBufferType = GPUDynamicStridedBindlessBufferArray<RendererLightParams>;
 
        Vector<UPtr<RendererLight>> mLights;
 
        UniformBufferType mUniformBuffer;
 
    public:
        explicit RendererLightManager(Renderer& renderer);
 
        ~RendererLightManager() noexcept final;
 
    public:
        Async<> prepare(RendererContext& context);
 
        Async<> renderShadows(RendererContext& context);
 
    private: // Light interface
        friend class RendererLight;
 
        void markAsDirty(RendererLight* const light);
    };
 
} // namespace CeresEngine