WGCommandBuffer.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 "WebGPU.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/RenderAPI/GPUCommandBuffer.hpp"
 
namespace CeresEngine {
 
    class WGDevice;
    class WGCommandQueue;
 
    class WGGraphicsPipeline;
 
    class WGCommandBuffer final : public GPUCommandBuffer, public WGDeviceObject<WGCommandBuffer, GPUCommandBuffer> {
        friend class WGCommandQueue;
 
    public:
        using WGLCommandBufferType = CE_WG_HANDLE(WGLCommandBuffer);
        using WGLRenderCommandEncoderType = CE_WG_HANDLE(WGLRenderCommandEncoder);
        using WGLComputeCommandEncoderType = CE_WG_HANDLE(WGLComputeCommandEncoder);
        using WGLBlitCommandEncoderType = CE_WG_HANDLE(WGLBlitCommandEncoder);
 
    private:
        const GPUCommandBufferDescriptor mDescriptor;
 
        WGLCommandBufferType mCommandBuffer;
 
        WGLRenderCommandEncoderType mRenderCommandEncoder;
 
        WGLComputeCommandEncoderType mComputeCommandEncoder;
 
        WGLBlitCommandEncoderType mBlitCommandEncoder;
 
    private: // State
        WGBufferPtr mIndexBuffer;
 
        UInt32 mIndexBufferOffset = 0;
 
        IndexType mIndexBufferType = IndexType::UInt32;
 
    public:
        WGCommandBuffer(WGDevicePtr device, const GPUCommandBufferDescriptor& descriptor);
        ~WGCommandBuffer() final;
 
        [[nodiscard]] CE_EXPLICIT_FALSE operator WGLCommandBufferType() 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: // 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) final;
 
    public:
        void begin() final;
 
        void end() final;
 
        void wait() final;
 
    private: // Encoders
        WGLRenderCommandEncoderType getRenderCommandEncoder();
        WGLComputeCommandEncoderType getComputeCommandEncoder();
        WGLBlitCommandEncoderType getBlitCommandEncoder();
    };
 
} // namespace CeresEngine