RendererObject.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/Renderer/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine {
 
    template<typename T> struct RendererObjectTrait;
 
#define CE_DECL_RENDERER_OBJECT(T)             \
    template<> struct RendererObjectTrait<T> { \
        using Type = T;                        \
        using Manager = T##Manager;            \
    }
 
    template<typename T> using RendererObjectManagerType = typename RendererObjectTrait<T>::Manager;
 
    using RendererObjectID = UInt32;
 
    class RendererObject {
        friend class RendererObjectManager;
        template<typename, typename, typename> friend class TRendererObjectManager;
 
    protected:
        RendererObjectID mID;
 
    public:
        Event<void(RendererObjectID newID)> willChangeID;
 
        Event<void(RendererObjectID oldID)> didChangeID;
 
    public:
        explicit RendererObject() = default;
 
        virtual ~RendererObject() noexcept = default;
 
        virtual void destroy() = 0;
 
    public:
        [[nodiscard]] RendererObjectID getID() const noexcept { return mID; }
 
    private:
        void changeID(RendererObjectID newID) noexcept;
    };
 
    template<typename SelfType, typename BaseType = RendererObject> class TRendererObject : public BaseType {
        using ManagerType = RendererObjectManagerType<SelfType>;
        friend ManagerType;
 
    protected:
        ManagerType& mManager;
 
    public:
        template<typename... Args> explicit TRendererObject(ManagerType& manager, Args&&... args) : BaseType(std::forward<Args>(args)...), mManager(manager) {}
 
        void destroy() noexcept override { mManager.destroy(static_cast<SelfType&>(*this)); }
 
    public:
        [[nodiscard]] ManagerType& getManager() const noexcept { return mManager; }
    };
 
    class RendererObjectManager {
    protected:
        Renderer& mRenderer;
 
    public:
        explicit RendererObjectManager(Renderer& renderer) noexcept;
 
        virtual ~RendererObjectManager() noexcept = default;
 
    public:
        [[nodiscard]] Renderer& getRenderer() const noexcept { return mRenderer; }
 
    protected:
        void notifyChangeID(RendererObject& object, const RendererObjectID newID) noexcept {
            object.changeID(newID);
        }
    };
 
    template<typename SelfType, typename ObjectType, typename BaseType = RendererObjectManager> class TRendererObjectManager : public BaseType {
        friend ObjectType;
        friend RendererObject;
 
    private:
        Vector<UPtr<ObjectType>>& mObjects;
 
    public:
        template<typename... Args>
        explicit TRendererObjectManager(Vector<UPtr<ObjectType>>& objects, Args&&... args) : BaseType(std::forward<Args>(args)...), mObjects(objects) {}
 
    public:
        template<typename... Args> ObjectType& create(Args&&... args) {
            const RendererObjectID objectID = RendererObjectID(mObjects.size());
 
            const UPtr<ObjectType>& object = mObjects.emplace_back(ce_unique_new<ObjectType>( //
                static_cast<SelfType&>(*this), std::forward<Args>(args)...));
            CE_ASSERT(object != nullptr);
 
            // NOTE: Directly setting the ID as nothing should be
            //       subscribing to the ID change event yet.
            object->mID = objectID;
 
            return *object;
        }
 
        void destroy(ObjectType& object) {
            const RendererObjectID objectID = object.mID;
            std::swap(mObjects[objectID], mObjects.back());
            mObjects[objectID]->changeID(objectID);
 
            mObjects.pop_back();
        }
    };
 
} // namespace CeresEngine