RendererScene.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 "RendererGeometry.hpp"
#include "RendererObject.hpp"
#include "RendererSceneSettings.hpp"
 
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
 
#include "CeresEngine/Scene/Environment.hpp"
#include "CeresEngine/Scene/Scene.hpp"
 
namespace CeresEngine {
 
    class RendererSceneManager;
    CE_DECL_RENDERER_OBJECT(RendererScene);
 
    struct RendererSceneParams {};
 
    struct RendererSceneInfo {};
 
    class RendererScene final : public TRendererObject<RendererScene> {
        using super = TRendererObject<RendererScene>;
 
    private:
        bool mDirty = true;
 
        RendererSceneInfo mInfo;
 
        GPUDynamicUniformBuffer<RendererSceneParams> mUniformBuffer;
 
    private:
        Vector<RendererCamera*> mCameras;
 
        Vector<RendererLight*> mLights;
 
        Vector<RendererRenderable*> mRenderables;
 
        Vector<RendererTerrain*> mTerrains;
 
        Vector<RendererEnvironment*> mEnvironments;
 
    public:
        using super::super;
        ~RendererScene() final;
 
    public:
        void prepare(RendererContext& context);
 
    public:
        [[nodiscard]] RendererEnvironment* getEnvironment() const noexcept {
            if(mEnvironments.empty()) {
                return nullptr;
            }
            return mEnvironments.front();
        }
 
    public: // Scene Object management
        template<typename T> T& create();
 
    private:
        template<typename, typename> friend class TRendererSceneObject;
 
        template<typename T> void add(T& object);
 
        template<typename T> void remove(T& object);
 
    public:
        [[nodiscard]] const Vector<RendererCamera*>& getCameras() { return mCameras; }
 
        [[nodiscard]] const Vector<RendererLight*>& getLights() { return mLights; }
 
        [[nodiscard]] const Vector<RendererRenderable*>& getRenderables() { return mRenderables; }
 
        [[nodiscard]] const Vector<RendererTerrain*>& getTerrains() { return mTerrains; }
 
        [[nodiscard]] const Vector<RendererEnvironment*>& getEnvironments() { return mEnvironments; }
 
    public: // Render Elements
        Generator<RendererGeometry> enumerateGeometry(const RendererGeometryEnumerationRequest& enumerationRequest = RendererGeometryEnumerationRequest()) const;
 
    public:
        [[nodiscard]] Renderer& getRenderer() const;
 
        //        /// \copydoc Scene::Scene::getRendererSettings
        //        [[nodiscard]] const RendererSceneSettings& getSettings() const { return mScene->getRendererSettings(); }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirty; }
 
        void markAsDirty() noexcept { mDirty = true; }
 
        [[nodiscard]] const RendererSceneInfo& getInfo() const { return mInfo; }
 
        [[nodiscard]] RendererSceneInfo& getInfo() { return mInfo; }
 
        [[nodiscard]] const GPUUniformBuffer& getUniformBuffer() const { return mUniformBuffer; }
 
    private:
        void onSkyTextureChanged();
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class RendererSceneManager final : public TRendererObjectManager<RendererSceneManager, RendererScene> {
        using super = TRendererObjectManager<RendererSceneManager, RendererScene>;
 
    private:
        Vector<UPtr<RendererScene>> mScenes;
 
    public:
        explicit RendererSceneManager(Renderer& renderer);
 
        ~RendererSceneManager() final;
 
    public:
        Async<> prepare(RendererContext& context);
 
    public:
        [[nodiscard]] Generator<RendererScene&> enumerateScenes();
    };
 
} // namespace CeresEngine