Details.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Core.hpp>
#include <Core/Pool.hpp>
 
namespace Foundation::RHI {
    using Handle = uint64_t;
    constexpr static Handle kInvalidHandle = static_cast<Handle>(-1);
    class RHIObject {
    public:
        RHIObject() = default;
        RHIObject(RHIObject const&) = delete;
        RHIObject& operator=(const RHIObject&) = delete;
        RHIObject(RHIObject&&) = delete;
        RHIObject& operator=(RHIObject&&) = delete;
 
        virtual ~RHIObject() = default;
    };
    template<typename Factory, std::derived_from<RHIObject> T>
    struct RHIObjectTraits;
    template<typename Factory, typename T> class RHIHandle {
    public:
        Factory* mFactory{ nullptr };
        Handle mHandle{ kInvalidHandle };
        template<typename U = T> [[nodiscard]] U* Get() const {
            CHECK(IsValid() && "RHIHandle::Get called on an invalid handle");
            auto ptr = RHIObjectTraits<Factory, T>::Get(mFactory, mHandle);
            CHECK(ptr != nullptr);
            return static_cast<U*>(ptr);
        }
        T* operator->() const {
            return Get();
        }
 
        constexpr Handle operator()() const { return mHandle; }
        constexpr operator bool() const noexcept { return IsValid(); }
        bool operator==(const RHIHandle& other) const { return mFactory == other.mFactory && mHandle == other.mHandle; }
 
        [[nodiscard]] bool IsValid() const { return mFactory != nullptr && mHandle != kInvalidHandle; }
        void Invalidate() { mFactory = nullptr, mHandle = kInvalidHandle; }
    };
    template<typename Factory, typename T> class RHIScopedHandle : public RHIHandle<Factory, T> {
    public:
        using RHIHandle<Factory, T>::mFactory;
        using RHIHandle<Factory, T>::mHandle;
        using RHIHandle<Factory, T>::Get;
        using RHIHandle<Factory, T>::IsValid;
        using RHIHandle<Factory, T>::Invalidate;
 
        RHIScopedHandle() = default;
        RHIScopedHandle(Factory* factory, Handle handle) : RHIHandle<Factory, T>(factory, handle) {}
        RHIScopedHandle(RHIScopedHandle&& other) noexcept
            : RHIHandle<Factory, T>(std::move(other)) {
            other.Invalidate();
        }
        RHIScopedHandle& operator=(RHIScopedHandle&& other) noexcept {
            if (this != &other) {
                mFactory = other.mFactory;
                mHandle = other.mHandle;
                other.Invalidate();
            }
            return *this;
        }
        [[nodiscard]] RHIHandle<Factory, T> View() const {
            return *this;
        }
        RHIHandle<Factory, T> Release() {
            RHIHandle<Factory, T> handle = *this;
            Invalidate();
            return handle;
        }
        void Reset() {
            if (IsValid()) {
                RHIObjectTraits<Factory, T>::Destroy(mFactory, mHandle);
                Invalidate();
            }            
        }
        RHIScopedHandle(const RHIScopedHandle&) = delete;
        RHIScopedHandle& operator=(const RHIScopedHandle&) = delete;
        ~RHIScopedHandle() {
            if (IsValid())
                RHIObjectTraits<Factory, T>::Destroy(mFactory, mHandle);
        }
    };
    template<typename Base = RHIObject> class RHIObjectPool {
        Core::Allocator* mAllocator;
        Core::Pool<Handle, Base> mObjects;
    public:
        RHIObjectPool(Core::Allocator* allocator) :
            mAllocator(allocator), mObjects(allocator) {
        };
        template<typename U, typename ...Args> Handle CreateObject(Args&&... args) {
#ifdef _MSC_VER
            // Motherfucker.
            // https://stackoverflow.com/questions/77144003/use-of-template-keyword-before-dependent-template-name
            return mObjects.PopBase<U>(std::forward<Args>(args)...);
#else
            return mObjects.template PopBase<U>(std::forward<Args>(args)...);
#endif
        }
        template<typename U = Base> U* GetObjectPtr(Handle handle) const {
            if (!mObjects.Contains(handle))
                throw std::out_of_range("invalid handle");
            return static_cast<U*>(mObjects.At(handle));
        }
        void DestroyObject(Handle handle) {
            mObjects.Free(handle);
        }
    };
}
 
 
namespace Foundation::RHI {
    class RHIApplication;
    template<typename T> using RHIApplicationScopedObjectHandle = RHIScopedHandle<RHIApplication, T>;
    template<typename T> using RHIApplicationObjectHandle = RHIHandle<RHIApplication, T>;
 
    class RHIDevice;
    template<typename T> using RHIDeviceScopedObjectHandle = RHIScopedHandle<RHIDevice, T>;
    template<typename T> using RHIDeviceObjectHandle = RHIHandle<RHIDevice, T>;
}