GLCommandBuffer.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 "OpenGL.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/RenderAPI/GPUCommandBuffer.hpp"
 
namespace CeresEngine {
 
    class GLDevice;
    class GLCommandQueue;
 
    class GLGraphicsPipeline;
 
    class GLCommandBuffer final : public GPUCommandBuffer, public GLDeviceObject<GLCommandBuffer, GPUCommandBuffer> {
        friend class GLCommandQueue;
 
    private:
        const GPUCommandBufferDescriptor descriptorGL;
 
        GLuint mVAO = 0;
        GLGraphicsPipeline* mGraphicsPipeline = nullptr;
        IndexType indexType = IndexType::UInt32;
 
    public:
        GLCommandBuffer(GLDevicePtr device, const GPUCommandBufferDescriptor& descriptor);
        ~GLCommandBuffer() final;
 
    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;
 
    public:
        void bindVAO(GLuint vao);
        void bindGraphicsPipeline(GLGraphicsPipeline& graphicsPipeline);
    };
 
} // namespace CeresEngine