VKCommandBuffer.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 "VKCommon.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Deque.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
 
#include "CeresEngine/RenderAPI/GPUCommandBuffer.hpp"
 
namespace CeresEngine {
 
    class VKCommandBufferTracker {
        using Allocator = VKAllocator;
 
//        Allocator mAllocator{
//            sizeof(RC<GPUObject>) * 200,
//            gVKAllocator(),
//        };
        Allocator mAllocator;
 
//        Allocator::marker mMarker = mAllocator.top();
 
        Deque<RC<GPUObject>, Allocator> mResources{mAllocator};
 
    public:
        VKCommandBufferTracker() = default;
 
        VKCommandBufferTracker(const VKCommandBufferTracker&) = delete;
        VKCommandBufferTracker& operator=(const VKCommandBufferTracker&) = delete;
        VKCommandBufferTracker(VKCommandBufferTracker&&) = default;
        VKCommandBufferTracker& operator=(VKCommandBufferTracker&&) = default;
 
        ~VKCommandBufferTracker() { reset(); }
 
    public:
        void track(GPUObject* resource) { mResources.emplace_back(resource); }
 
        void track(GPUObject& resource) { track(&resource); }
 
        void reset() {
            mResources.clear();
//            mAllocator.unwind(mMarker);
        }
    };
 
    class VKCommandBuffer final : public GPUCommandBuffer, public VKDeviceObject<VKCommandBuffer, GPUCommandBuffer> {
        friend class VKCommandQueue;
        friend class VKGraphicsPipeline;
        friend class VKComputePipeline;
        friend class VKRenderPass;
        friend class VKTimerQuery;
 
    private:
        const GPUCommandBufferDescriptor mDescriptorVK;
 
        VKCommandQueue& mCommandQueue;
 
        VkCommandPool mCommandPool = VK_NULL_HANDLE;
 
        VkCommandBuffer mCommandBuffer;
 
        VkFence mCompletionFence;
 
        VKCommandBufferTracker mTrackedState;
 
        VkPipelineBindPoint mPipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
 
        Promise<> mCompletionPromise;
 
    private:
        SmallVector<VKImage*, 16, VKAllocator> mImages{gVKAllocator()};
 
        Vector<VKTimerQuery*, VKAllocator> mTimerQueries{gVKAllocator()};
 
    private: // Current State
        VKRenderTarget* mRenderTarget = nullptr;
        VKRenderPass* mRenderPass = nullptr;
        VKGraphicsPipeline* mGraphicsPipeline = nullptr;
        VKComputePipeline* mComputePipeline = nullptr;
 
    public:
        VKCommandBuffer(VKDevice& device, VKCommandQueue& commandQueue, const GPUCommandBufferDescriptor& descriptor);
        ~VKCommandBuffer() final;
 
        using Allocator = VKObjectAllocator;
 
        static Allocator& getAllocator() noexcept;
 
        static void* operator new(size_t size) noexcept;
 
        static void operator delete(void* p, std::size_t size) noexcept;
 
        [[nodiscard]] CE_EXPLICIT_FALSE operator VkCommandBuffer() const noexcept { return mCommandBuffer; }
 
    public:
        void bindResourceSet(GPUResourceSet& resourceSet, UInt32 firstSet = 0, Int32 offset = -1) final;
 
        void bindVertexBuffer(GPUBuffer& vertexBuffer, UInt32 offset = 0, UInt32 slot = 0) final;
 
        void bindIndexBuffer(GPUBuffer& indexBuffer, UInt32 offset = 0, IndexType indexType = IndexType::UInt32) final;
 
        void draw(UInt32 vertexCount, UInt32 instanceCount = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0) final;
 
        void draw(GPUBuffer& buffer, UInt32 drawCount, UInt32 bufferOffset = 0, UInt32 stride = sizeof(GPUDrawIndirectCommand)) final;
 
        void drawIndexed(UInt32 indexCount, UInt32 instanceCount = 1, UInt32 firstVertex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) final;
 
        void drawIndexed(GPUBuffer& buffer, UInt32 drawCount, UInt32 bufferOffset = 0, UInt32 stride = sizeof(GPUDrawIndexedIndirectCommand)) final;
 
        void dispatch(UInt32 groupCountX, UInt32 groupCountY, UInt32 groupCountZ) final;
 
    public: // Dynamic States
        void setViewport(const Viewport& viewport) final;
 
        void setViewports(const SmallVector<Viewport, 16>& viewports) final;
 
        void setScissor(const Scissor& scissor) final;
 
        void setScissors(const SmallVector<Scissor, 16>& scissors) final;
 
    public: // Mesh-shaders
        void drawMeshTasks(UInt32 groupCountX, UInt32 groupCountY, UInt32 groupCountZ) final;
 
        void drawMeshTasksIndirect(GPUBuffer& buffer, UInt64 offset, UInt32 drawCount, UInt32 stride) final;
 
        void drawMeshTasksIndirect(GPUBuffer& buffer, UInt64 offset, GPUBuffer& countBuffer, UInt64 countBufferOffset, uint32_t maxDrawCount, uint32_t stride) final;
 
    public: // Buffer read, write & copy.
        void updateBuffer(GPUBuffer& dstBuffer, std::uint64_t dstOffset, const void* data, std::uint16_t dataSize) final;
 
        void copyBuffer(GPUBuffer& dstBuffer, std::uint64_t dstOffset, GPUBuffer& srcBuffer, std::uint64_t srcOffset, std::uint64_t size) final;
 
        void fillBuffer(GPUBuffer& dstBuffer, std::uint64_t dstOffset, std::uint32_t value, std::uint64_t fillSize = ~0u) final;
 
    public: // Image read, write & copy.
        void copyBufferFromImage(GPUBuffer& dstBuffer, std::uint64_t dstOffset, GPUImage& srcImage, const GPUImageRegion& srcImageRegion,
            std::uint32_t rowStride = 0, std::uint32_t layerStride = 0) final;
 
        void copyImage(GPUImage& dstImage, const GPUImageLocation& dstLocation, GPUImage& srcImage, const GPUImageLocation& srcLocation,
            const TExtent3<UInt32>& extent) final;
 
        void copyImageFromBuffer(GPUImage& dstImage, const GPUImageRegion& dstRegion, GPUBuffer& srcBuffer, std::uint64_t srcOffset,
            std::uint32_t rowStride = 0, std::uint32_t layerStride = 0) final;
 
        void resolveImage(GPUImage& dstImage, const GPUImageLocation& dstLocation, GPUImage& srcImage, const GPUImageLocation& srcLocation,
            const TExtent3<UInt32>& extent) final;
 
        void clear(GPUImage& image) final;
 
        void generateMips(GPUImage& image) final;
 
        void generateMips(GPUImage& image, const GPUImageSubresource& subresource) final;
 
    public:
        void barrier(GPUImage& image, GPUImageLayout layout) final;
 
    public:
        void begin() final;
 
        void end() final;
 
        void wait() final;
 
    public:
        [[nodiscard]] bool isReady() const;
 
        void reset();
 
        [[nodiscard]] bool tryFinish();
    };
 
} // namespace CeresEngine