RendererEnvironment.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 "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/Environment.hpp"
 
namespace CeresEngine {
 
    CE_DECL_RENDERER_OBJECT(RendererEnvironment);
 
    enum class RendererEnvironmentType {
        Skybox,
 
        Baked,
 
        Probe
    };
 
    enum class RendererEnvironmentDirtyFlag {
        None = 0,
 
        Component = (1u << 1u),
 
        UniformBuffer = (1u << 2u),
 
        Flags = (1u << 3u),
 
        All = 0xFFFF,
    };
 
    using RendererEnvironmentDirtyFlags = Flags<RendererEnvironmentDirtyFlag>;
    CE_FLAGS_OPERATORS(RendererEnvironmentDirtyFlag)
 
    
    class RendererEnvironment : public TRendererSceneObject<RendererEnvironment> {
        using super = TRendererSceneObject<RendererEnvironment>;
        friend class RendererEnvironmentManager;
 
    protected:
        EnvironmentComponent mComponent;
 
        RendererEnvironmentDirtyFlags mDirtyFlags = RendererEnvironmentDirtyFlag::All;
 
    public:
        explicit RendererEnvironment(RendererEnvironmentManager& manager, RendererScene& scene);
 
        virtual ~RendererEnvironment();
 
    public:
        void synchronize(const EnvironmentComponent& component);
 
        virtual void prepare(RendererContext& context);
 
    protected:
        [[nodiscard]] GPUImagePtr equirectangularToCubeMap(RendererContext& context, const GPUImagePtr& environmentMap);
 
        [[nodiscard]] GPUImagePtr prefilterIrradianceMap(RendererContext& context, const GPUImagePtr& environmentMap);
 
        [[nodiscard]] GPUImagePtr prefilterRadianceMap(RendererContext& context, const GPUImagePtr& environmentMap);
 
    public:
        [[nodiscard]] virtual const GPUUniformBuffer& getUniformBuffer() const = 0;
 
        [[nodiscard]] virtual RendererEnvironmentType getType() const noexcept = 0;
 
        [[nodiscard]] const RendererEnvironmentDirtyFlags& getDirtyFlags() const noexcept { return mDirtyFlags; }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirtyFlags != RendererEnvironmentDirtyFlag::None; }
 
        void markAsDirty(const RendererEnvironmentDirtyFlags& flags = RendererEnvironmentDirtyFlag::All) noexcept;
    };
 
    struct RendererSkyboxEnvironmentParams {
        UInt32 prefilteredMipLevels;
    };
 
    class RendererSkyboxEnvironment : public RendererEnvironment {
        using super = RendererEnvironment;
        friend class RendererEnvironmentManager;
 
    private:
        RendererTexturePtr mOriginalSkyboxTexture;
 
        RendererTexturePtr mSkyboxTexture;
 
        RendererTexturePtr mIrradianceMap;
 
        RendererTexturePtr mRadianceMap;
 
        GPUDynamicUniformBuffer<RendererSkyboxEnvironmentParams> mUniformBuffer;
 
    public:
        explicit RendererSkyboxEnvironment(RendererEnvironmentManager& manager, RendererScene& scene);
 
        ~RendererSkyboxEnvironment() override;
 
    public:
        void prepare(RendererContext& context) override;
 
    public:
        [[nodiscard]] RendererEnvironmentType getType() const noexcept final { return RendererEnvironmentType::Skybox; }
 
        [[nodiscard]] const GPUUniformBuffer& getUniformBuffer() const final { return mUniformBuffer; }
 
        [[nodiscard]] const RendererTexturePtr& getSkyboxTexture() const noexcept { return mSkyboxTexture; }
 
        [[nodiscard]] const RendererTexturePtr& getIrradianceMap() const noexcept { return mIrradianceMap; }
 
        [[nodiscard]] const RendererTexturePtr& getRadianceMap() const noexcept { return mRadianceMap; }
    };
 
    class RendererEnvironmentManager final : public RendererSceneObjectManager {
        using super = RendererSceneObjectManager;
 
    private:
        Vector<UPtr<RendererSkyboxEnvironment>> mEnvironments;
 
    public:
        explicit RendererEnvironmentManager(Renderer& renderer);
 
        ~RendererEnvironmentManager();
 
    public:
        Async<> prepare(RendererContext& context);
 
    public:
        using ObjectType = RendererEnvironment;
 
        template<typename... Args> ObjectType& create(Args&&... args) {
            const RendererObjectID objectID = RendererObjectID(mEnvironments.size());
 
            ObjectType* const object = mEnvironments.emplace_back(ce_unique_new<RendererSkyboxEnvironment>(*this, std::forward<Args>(args)...)).get();
            CE_ASSERT(object != nullptr);
 
            // NOTE: Directly setting the ID as nothing should be
            //       subscribing to the ID change event yet.
            notifyChangeID(*object, objectID);
            // object->mID = objectID;
 
            return *object;
        }
 
        void destroy(const ObjectType& object) {
            const RendererObjectID objectID = object.mID;
            std::swap(mEnvironments[objectID], mEnvironments.back());
            notifyChangeID(*mEnvironments[objectID], objectID);
 
            mEnvironments.pop_back();
        }
 
    private: // Environment interface
        friend class RendererEnvironment;
 
        void markAsDirty(RendererEnvironment* const environment);
    };
 
} // namespace CeresEngine