GPUCommandBuffer.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 "Common.hpp"
#include "Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/ScopeExit.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
 
#include "CeresEngine/Math/Extent.hpp"
#include "CeresEngine/Mesh/IndexType.hpp"
 
#include <cstdint>
#include <functional>
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT() GPUCommandBufferDescriptor final {
        CE_SCRIPT_EXPORT()
        String name;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) { CE_REFL_DATA(name); }
    };
 
    struct GPUDrawIndirectCommand {
        UInt32 vertexCount = 0;
 
        UInt32 instanceCount = 1;
 
        UInt32 firstVertex = 0;
 
        UInt32 firstInstance = 0;
    };
 
    struct GPUDrawIndexedIndirectCommand {
        UInt32 indexCount = 0;
 
        UInt32 instanceCount = 1;
 
        UInt32 firstIndex = 0;
 
        Int32 vertexOffset = 0;
 
        UInt32 firstInstance = 0;
    };
 
    class CE_SCRIPT_EXPORT() GPUCommandBuffer : public TDeviceObject<GPUCommandBufferDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUCommandBuffer(const GPUCommandBuffer&) = delete;
        GPUCommandBuffer& operator=(const GPUCommandBuffer&) = delete;
 
        GPUCommandBuffer(GPUCommandBuffer&&) = delete;
        GPUCommandBuffer& operator=(GPUCommandBuffer&&) = delete;
 
    public: // Events
        Event<void()> didFinish;
 
    public: // Drawing
        CE_SCRIPT_EXPORT()
        virtual void bindResourceSet(GPUResourceSet& resourceSet, UInt32 firstSet = 0, Int32 offset = -1) = 0;
 
        void bindResourceSet(const GPUResourceSetPtr& resourceSet, const UInt32 firstSet = 0, const Int32 offset = -1) { bindResourceSet(*resourceSet, firstSet, offset); }
 
        CE_SCRIPT_EXPORT()
        virtual void bindVertexBuffer(GPUBuffer& vertexBuffer, UInt32 offset = 0, UInt32 slot = 0) = 0;
 
        void bindVertexBuffer(const GPUBufferPtr& vertexBuffer, const UInt32 offset = 0, const UInt32 slot = 0) { bindVertexBuffer(*vertexBuffer, offset, slot); }
 
        virtual void bindVertexBuffer(const GPUVertexBuffer& vertexBuffer);
 
        CE_SCRIPT_EXPORT()
        virtual void bindIndexBuffer(GPUBuffer& indexBuffer, UInt32 offset = 0, IndexType indexType = IndexType::UInt32) = 0;
 
        void bindIndexBuffer(const GPUBufferPtr& indexBuffer, const UInt32 offset = 0, const IndexType indexType = IndexType::UInt32) {
            bindIndexBuffer(*indexBuffer, offset, indexType);
        }
 
        virtual void bindIndexBuffer(const GPUIndexBuffer& indexBuffer);
 
        CE_SCRIPT_EXPORT()
        virtual void draw(UInt32 vertexCount, UInt32 instanceCount = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0) = 0;
 
        virtual void draw(GPUBuffer& buffer, UInt32 drawCount, UInt32 bufferOffset = 0, UInt32 stride = sizeof(GPUDrawIndirectCommand)) = 0;
 
        void draw(const GPUIndirectBuffer& buffer, UInt32 drawCount, UInt32 stride = sizeof(GPUDrawIndirectCommand));
 
        CE_SCRIPT_EXPORT()
        virtual void drawIndexed(UInt32 indexCount, UInt32 instanceCount = 1, UInt32 firstVertex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) = 0;
 
        virtual void drawIndexed(GPUBuffer& buffer, UInt32 drawCount, UInt32 bufferOffset = 0, UInt32 stride = sizeof(GPUDrawIndexedIndirectCommand)) = 0;
 
        void drawIndexed(const GPUIndirectBuffer& buffer, UInt32 drawCount, UInt32 stride = sizeof(GPUDrawIndexedIndirectCommand));
 
        CE_SCRIPT_EXPORT()
        virtual void dispatch(UInt32 groupCountX, UInt32 groupCountY, UInt32 groupCountZ) = 0;
 
    public: // Dynamic States
        CE_SCRIPT_EXPORT(property = "none")
        virtual void setViewport(const Viewport& viewport);
 
        virtual void setViewports(const SmallVector<Viewport, 16>& viewports) = 0;
 
        CE_SCRIPT_EXPORT(property = "none")
        virtual void setScissor(const Scissor& scissor);
 
        virtual void setScissors(const SmallVector<Scissor, 16>& scissors) = 0;
 
    public: // Ray-Tracing
        void buildAccelerationStructures();
        void buildAccelerationStructuresIndirect();
 
        void copyAccelerationStructure();
        void copyAccelerationStructureToMemory();
        void copyMemoryToAccelerationStructure();
        void writeAccelerationStructuresProperties();
 
        void setRayTracingPipelineStackSize();
 
        void traceRays();
        void traceRaysIndirect();
 
    public: // Mesh-shaders
        virtual void drawMeshTasks(UInt32 groupCountX, UInt32 groupCountY, UInt32 groupCountZ) = 0;
 
        virtual void drawMeshTasksIndirect(GPUBuffer& buffer, UInt64 offset, UInt32 drawCount, UInt32 stride) = 0;
 
        virtual void drawMeshTasksIndirect(GPUBuffer& buffer, UInt64 offset, GPUBuffer& countBuffer, UInt64 countBufferOffset, uint32_t maxDrawCount, uint32_t stride) = 0;
 
    public: // Buffer
        virtual void updateBuffer(GPUBuffer& dstBuffer, std::uint64_t dstOffset, const void* data, std::uint16_t dataSize) = 0;
 
        virtual void copyBuffer(GPUBuffer& dstBuffer, std::uint64_t dstOffset, GPUBuffer& srcBuffer, std::uint64_t srcOffset, std::uint64_t size) = 0;
 
        virtual void fillBuffer(GPUBuffer& dstBuffer, std::uint64_t dstOffset, std::uint32_t value, std::uint64_t fillSize = ~0u) = 0;
 
    public: // Image read, write & copy.
        virtual void copyBufferFromImage(GPUBuffer& dstBuffer, std::uint64_t dstOffset, GPUImage& srcImage, const GPUImageRegion& srcImageRegion,
            std::uint32_t rowStride = 0, std::uint32_t layerStride = 0) = 0;
 
        virtual void copyImage(GPUImage& dstImage, const GPUImageLocation& dstLocation, GPUImage& srcImage, const GPUImageLocation& srcLocation,
            const TExtent3<UInt32>& extent) = 0;
 
        virtual void copyImageFromBuffer(GPUImage& dstImage, const GPUImageRegion& dstRegion, GPUBuffer& srcBuffer, std::uint64_t srcOffset,
            std::uint32_t rowStride = 0, std::uint32_t layerStride = 0) = 0;
 
        // TODO: Write docs.
        virtual void resolveImage(GPUImage& dstImage, const GPUImageLocation& dstLocation, GPUImage& srcImage, const GPUImageLocation& srcLocation,
            const TExtent3<UInt32>& extent) = 0;
 
        CE_SCRIPT_EXPORT()
        virtual void clear(GPUImage& image) = 0;
 
        CE_SCRIPT_EXPORT()
        virtual void generateMips(GPUImage& image) = 0;
 
        virtual void generateMips(GPUImage& texture, const GPUImageSubresource& subresource) = 0;
 
    public: // Synchronization
        CE_SCRIPT_EXPORT()
        virtual void barrier(GPUImage& image, GPUImageLayout layout) = 0;
 
    public: // Recording
        virtual void begin() = 0;
 
        virtual void end() = 0;
 
        virtual void wait() = 0;
 
        template<typename Func> decltype(auto) record(Func&& recorder) {
            begin();
            CE_SCOPE_EXIT { end(); };
            return recorder();
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUCommandBufferDescriptor);