RenderResource.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 "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/RenderAPI/GPUBuffer.hpp"
#include "CeresEngine/RenderAPI/GPUImage.hpp"
 
#include <iostream>
 
namespace CeresEngine {
 
    enum class RenderResourceType {
        Buffer,
        Image
    };
 
    class RenderResource : public RefCounted<RenderResource> {
        friend class RenderTask;
 
    protected:
        RenderGraph& mRenderGraph;
 
    private:
        Vector<RenderTask*> mReaders;
        Vector<RenderTask*> mWriters;
 
    public:
        explicit RenderResource(RenderGraph& renderGraph) : mRenderGraph(renderGraph) {}
        virtual ~RenderResource() = default;
 
    public: // Resource lifetime
        virtual void realize(GPUDevice& device) = 0;
 
        virtual void unrealize(GPUDevice& device) = 0;
 
    public: // Resource properties
        virtual bool isTransient() const = 0;
 
        virtual bool isExternal() const = 0;
 
        virtual bool isValid() const = 0;
 
    public: // Resource operator overloads
        explicit operator bool() const { return isValid(); }
 
    public:
        [[nodiscard]] const Vector<RenderTask*>& getReaders() const { return mReaders; }
        [[nodiscard]] const Vector<RenderTask*>& getWriters() const { return mWriters; }
    };
 
    template<typename R, typename D, RenderResourceType RT> class TRenderResource : public RenderResource {
    public:
        static const constexpr RenderResourceType resourceType = RT;
 
    public:
        using RenderResource::RenderResource;
 
    public:
        [[nodiscard]] virtual R* get() const = 0;
 
        [[nodiscard]] virtual const D& getDescriptor() const = 0;
 
        [[nodiscard]] bool isValid() const override { return get() != nullptr; }
 
    public:
        [[nodiscard]] R& operator*() const { return *get(); }
 
        [[nodiscard]] R* operator->() const { return get(); }
 
        [[nodiscard]] operator R&() const { return *get(); }
 
        [[nodiscard]] operator R*() const { return get(); }
 
        [[nodiscard]] operator RC<R>() const { return get(); }
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class ImageRenderResource : public TRenderResource<GPUImage, GPUImageDescriptor, RenderResourceType::Image> {
    public:
        using TRenderResource::TRenderResource;
    };
 
    class TransientImageRenderResource final : public ImageRenderResource {
    private:
        GPUImageDescriptor mDescriptor;
        GPUImagePtr mImage = nullptr;
 
    public:
        TransientImageRenderResource(RenderGraph& renderGraph, const GPUImageDescriptor& descriptor);
 
    public:
        void realize(GPUDevice& device) final;
 
        void unrealize(GPUDevice& device) final;
 
        [[nodiscard]] GPUImage* get() const final { return mImage.get(); }
 
        [[nodiscard]] const GPUImageDescriptor& getDescriptor() const final { return mDescriptor; }
 
    public:
        [[nodiscard]] bool isTransient() const final { return true; }
 
        [[nodiscard]] bool isExternal() const final { return false; }
 
    public:
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(mDescriptor);
            CE_REFL_DATA(mImage);
            CE_REFL_FUNC(realize);
            CE_REFL_FUNC(unrealize);
        }
    };
 
    class ExternalImageRenderResource final : public ImageRenderResource {
    private:
        GPUImagePtr mImage = nullptr;
 
    public:
        ExternalImageRenderResource(RenderGraph& renderGraph, GPUImage& image);
        ExternalImageRenderResource(RenderGraph& renderGraph, const GPUImagePtr& image);
 
    public:
        void realize(GPUDevice& device) final;
 
        void unrealize(GPUDevice& device) final;
 
        [[nodiscard]] GPUImage* get() const final { return mImage.get(); }
 
        void set(GPUImage& image) { mImage = &image; }
 
        [[nodiscard]] const GPUImageDescriptor& getDescriptor() const final { return mImage->descriptor; }
 
    public:
        [[nodiscard]] bool isTransient() const final { return false; }
 
        [[nodiscard]] bool isExternal() const final { return true; }
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class BufferRenderResource : public TRenderResource<GPUBuffer, GPUBufferDescriptor, RenderResourceType::Buffer> {
    public:
        using TRenderResource::TRenderResource;
    };
 
    class TransientBufferRenderResource final : public BufferRenderResource {
    private:
        GPUBufferDescriptor mDescriptor;
        GPUBufferPtr mBuffer = nullptr;
 
    public:
        TransientBufferRenderResource(RenderGraph& renderGraph, const GPUBufferDescriptor& descriptor);
 
    public:
        void realize(GPUDevice& device) final;
 
        void unrealize(GPUDevice& device) final;
 
        [[nodiscard]] GPUBuffer* get() const final { return mBuffer.get(); }
 
        [[nodiscard]] const GPUBufferDescriptor& getDescriptor() const final { return mDescriptor; }
 
    public:
        [[nodiscard]] bool isTransient() const final { return true; }
 
        [[nodiscard]] bool isExternal() const final { return false; }
    };
 
    class ExternalBufferRenderResource final : public BufferRenderResource {
    private:
        GPUBufferPtr mBuffer = nullptr;
 
    public:
        ExternalBufferRenderResource(RenderGraph& renderGraph, GPUBuffer& buffer);
        ExternalBufferRenderResource(RenderGraph& renderGraph, const GPUBufferPtr& buffer);
 
    public:
        void realize(GPUDevice& device) final;
 
        void unrealize(GPUDevice& device) final;
 
        [[nodiscard]] GPUBuffer* get() const final { return mBuffer.get(); }
 
        [[nodiscard]] const GPUBufferDescriptor& getDescriptor() const final { return mBuffer->descriptor; }
 
    public:
        [[nodiscard]] bool isTransient() const final { return false; }
 
        [[nodiscard]] bool isExternal() const final { return true; }
    };
 
    template<typename T = RenderResource> class RenderResourceRef {
    private:
        T* mResource = nullptr;
 
    public:
        RenderResourceRef() = default;
 
        RenderResourceRef(T& resource) : RenderResourceRef(&resource) {}
        RenderResourceRef& operator=(T& resource) {
            mResource = &resource;
            return *this;
        }
 
        RenderResourceRef(T* resource) : mResource(resource) {}
        RenderResourceRef& operator=(T* resource) {
            mResource = resource;
            return *this;
        }
 
        RenderResourceRef(const RenderResourceRef& other) = default;
        RenderResourceRef& operator=(const RenderResourceRef& other) = default;
 
    public:
        [[nodiscard]] T& get() const { return *mResource; }
        [[nodiscard]] bool valid() const { return mResource != nullptr; }
 
        T& operator*() const { return get(); }
        T* operator->() const { return &get(); }
        operator T&() const { return get(); }
    };
 
    using ImageRenderResourceRef = RenderResourceRef<ImageRenderResource>;
    using BufferRenderResourceRef = RenderResourceRef<BufferRenderResource>;
 
} // namespace CeresEngine