MTCommandBuffer.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 "Metal.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/RenderAPI/GPUCommandBuffer.hpp"
 
namespace CeresEngine {
 
    class MTDevice;
    class MTCommandQueue;
 
    class MTGraphicsPipeline;
 
    class MTCommandBuffer final : public GPUCommandBuffer, public MTDeviceObject<MTCommandBuffer, GPUCommandBuffer> {
        friend class MTCommandQueue;
 
    public:
        using MTLCommandBufferType = CE_MT_HANDLE(MTLCommandBuffer);
        using MTLRenderCommandEncoderType = CE_MT_HANDLE(MTLRenderCommandEncoder);
        using MTLComputeCommandEncoderType = CE_MT_HANDLE(MTLComputeCommandEncoder);
        using MTLBlitCommandEncoderType = CE_MT_HANDLE(MTLBlitCommandEncoder);
 
    private:
        const GPUCommandBufferDescriptor mDescriptor;
 
        MTLCommandBufferType mCommandBuffer;
 
        MTLRenderCommandEncoderType mRenderCommandEncoder;
 
        MTLComputeCommandEncoderType mComputeCommandEncoder;
 
        MTLBlitCommandEncoderType mBlitCommandEncoder;
 
    private: // State
        MTBufferPtr mIndexBuffer;
 
        UInt32 mIndexBufferOffset = 0;
 
        IndexType mIndexBufferType = IndexType::UInt32;
 
    public:
        MTCommandBuffer(MTDevicePtr device, const GPUCommandBufferDescriptor& descriptor);
        ~MTCommandBuffer() final;
 
        [[nodiscard]] CE_EXPLICIT_FALSE operator MTLCommandBufferType() 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: // Synchronization
        void barrier(GPUImage& image, GPUImageLayout layout) final;
 
    public:
        void begin() final;
 
        void end() final;
 
        void wait() final;
 
    private: // Encoders
        MTLRenderCommandEncoderType getRenderCommandEncoder();
        MTLComputeCommandEncoderType getComputeCommandEncoder();
        MTLBlitCommandEncoderType getBlitCommandEncoder();
    };
 
} // namespace CeresEngine