Details.hpp

Go to the documentation of this file.

#pragma once
#include <Core/AtomicPool.hpp>
namespace Foundation::RHI
{
    using Handle = uintptr_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
        {
            if (!IsValid())
                throw std::runtime_error("RHIHandle::Get called on an invalid handle");
            T* ptr = RHIObjectTraits<Factory, T>::Get(mFactory, mHandle);
            if (!ptr)
                throw std::runtime_error("RHIHandle::Get got nullptr");
            return static_cast<U*>(ptr);
        }
        T* operator->() const { return Get(); }
 
        constexpr Handle operator()() const { return mHandle; }
        constexpr operator bool() const noexcept { return IsValid(); }
        constexpr T* operator*() noexcept { return Get(); }
        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
    {
        using PointerType = Core::UniquePtr<Base>;
 
        Core::Allocator* mAllocator;
        Core::DynamicPool<PointerType> mPool;
 
    public:
        RHIObjectPool(Core::Allocator* allocator) : mAllocator(allocator), mPool(allocator) {}
        template <typename U, typename... Args>
        Handle CreateObject(Args&&... args)
        {
            Base* obj = Core::ConstructBase<Base, U>(mAllocator, std::forward<Args>(args)...);
            PointerType owned(obj, Core::StlDeleter<Base>(mAllocator));
            PointerType* pointer = mPool.Construct(std::move(owned));
            return reinterpret_cast<Handle>(pointer);
        }
        template <typename U = Base>
        static U* GetObjectPtr(Handle handle) noexcept
        {
            PointerType& pointer = *reinterpret_cast<PointerType*>(handle);
            Base* obj = pointer.get();
            return reinterpret_cast<U*>(obj);
        }
        void DestroyObject(Handle handle)
        {
            auto* pointer = reinterpret_cast<PointerType*>(handle);
            mPool.Destruct(pointer);
        }
        void Destroy()
        {
            mPool.Collect();
        }
    };
} // namespace Foundation::RHI
 
 
namespace Foundation::RHI
{
    class RHIApplication;
    template <typename T>
    using RHIApplicationScopedHandle = RHIScopedHandle<RHIApplication, T>;
    template <typename T>
    using RHIApplicationHandle = RHIHandle<RHIApplication, T>;
 
    class RHIDevice;
    template <typename T>
    using RHIDeviceScopedHandle = RHIScopedHandle<RHIDevice, T>;
    template <typename T>
    using RHIDeviceHandle = RHIHandle<RHIDevice, T>;
} // namespace Foundation::RHI