OpenGLCommandBuffer.hpp

Go to the documentation of this file.

#pragma once
 
#include "../Interface/CommandBuffer.hpp"
 
#include <vector>
#include <glad/glad.h>
 
namespace Video {
 
class OpenGLRenderer;
class OpenGLRenderPassAllocator;
class OpenGLShaderProgram;
 
class OpenGLCommandBuffer : public CommandBuffer {
  public:
    struct Timing {
        std::string name;
 
        GLuint startQuery;
 
        GLuint endQuery;
    };
 
 
    OpenGLCommandBuffer(OpenGLRenderer& openGLRenderer, OpenGLRenderPassAllocator& renderPassAllocator);
 
    ~OpenGLCommandBuffer() final;
 
    void BeginRenderPass(RenderPass* renderPass, const std::string& name) final;
    void BeginRenderPass(Texture* colorAttachment, RenderPass::LoadOperation colorLoadOperation, Texture* depthAttachment, RenderPass::LoadOperation depthLoadOperation, const std::string& name) final;
    void BeginAttachmentlessRenderPass(const glm::uvec2& size, uint32_t msaaSamples, const std::string& name) final;
    void EndRenderPass() final;
    void BindGraphicsPipeline(GraphicsPipeline* graphicsPipeline) final;
    void SetViewport(const glm::uvec2& origin, const glm::uvec2& size) final;
    void SetScissor(const glm::uvec2& origin, const glm::uvec2& size) final;
    void SetLineWidth(float width) final;
    void BindGeometry(GeometryBinding* geometryBinding) final;
    void BindUniformBuffer(ShaderProgram::BindingType bindingType, Buffer* uniformBuffer) final;
    void BindStorageBuffers(std::initializer_list<Buffer*> buffers) final;
    void BindMaterial(std::initializer_list<std::pair<Texture*, const Sampler*>> textures) final;
    void PushConstants(const void* data) final;
    void Draw(unsigned int vertexCount, unsigned int firstVertex) final;
    void DrawIndexed(unsigned int indexCount, unsigned int firstIndex, unsigned int baseVertex) final;
    void DrawIndexedInstanced(unsigned int indexCount, unsigned int instanceCount, unsigned int firstIndex, unsigned int baseVertex) final;
    void BlitToSwapChain(Texture* texture) final;
    void BindComputePipeline(ComputePipeline* computePipeline) final;
    void Dispatch(const glm::uvec3& numGroups, const std::string& name) final;
    void ClearBuffer(Buffer* buffer) final;
 
    void Submit();
 
 
    const std::vector<Timing>& GetTimings() const;
 
  private:
    OpenGLCommandBuffer(const OpenGLCommandBuffer& other) = delete;
 
    struct BeginRenderPassCommand {
        GLuint frameBuffer;
        GLbitfield clearMask;
        unsigned int timingIndex;
    };
 
    struct BindGraphicsPipelineCommand {
        GLuint program;
        GLenum polygonMode;
        bool cullFaceEnabled;
        GLenum cullFace;
        bool blendingEnabled;
        GLenum blendingSourceFactor;
        GLenum blendingDestinationFactor;
        bool depthTestEnabled;
        GLboolean depthMaskEnabled;
        GLenum depthFunction;
        bool depthClampEnabled;
        bool conservativeRasterizationEnabled;
    };
 
    struct SetViewportCommand {
        unsigned int origin[2];
        unsigned int size[2];
    };
 
    struct SetScissorCommand {
        unsigned int origin[2];
        unsigned int size[2];
    };
 
    struct SetLineWidthCommand {
        float width;
    };
 
    struct BindGeometryCommand {
        GLuint vertexArray;
    };
 
    struct SetUniformIntegerCommand {
        unsigned int location;
        int32_t value;
    };
 
    struct SetUniformUnsignedIntegerCommand {
        unsigned int location;
        uint32_t value;
    };
 
    struct SetUniformFloatCommand {
        unsigned int location;
        float value;
    };
 
    struct SetUniformVector2Command {
        unsigned int location;
        float value[2];
    };
 
    struct SetUniformIVector2Command {
        unsigned int location;
        int32_t value[2];
    };
 
    struct SetUniformUVector2Command {
        unsigned int location;
        uint32_t value[2];
    };
 
    struct SetUniformVector3Command {
        unsigned int location;
        float value[3];
    };
 
    struct SetUniformIVector3Command {
        unsigned int location;
        int32_t value[3];
    };
 
    struct SetUniformUVector3Command {
        unsigned int location;
        uint32_t value[3];
    };
 
    struct SetUniformVector4Command {
        unsigned int location;
        float value[4];
    };
 
    struct SetUniformIVector4Command {
        unsigned int location;
        int32_t value[4];
    };
 
    struct SetUniformUVector4Command {
        unsigned int location;
        uint32_t value[4];
    };
 
    struct SetUniformMatrix3Command {
        unsigned int location;
        float value[3 * 3];
    };
 
    struct SetUniformMatrix4Command {
        unsigned int location;
        float value[4 * 4];
    };
 
    struct BindTextureCommand {
        GLenum slot;
        GLuint texture;
        GLuint sampler;
    };
 
    struct BindUniformBufferCommand {
        GLuint index;
        GLuint uniformBuffer;
        GLintptr offset;
        GLsizeiptr size;
    };
 
    struct BindStorageBufferCommand {
        GLuint index;
        GLuint storageBuffer;
        GLintptr offset;
        GLsizeiptr size;
    };
 
    struct DrawCommand {
        GLenum mode;
        GLint first;
        GLsizei count;
    };
 
    struct DrawIndexedCommand {
        GLenum mode;
        GLsizei count;
        GLenum type;
        GLvoid* indices;
        GLint baseVertex;
    };
 
    struct DrawIndexedInstancedCommand {
        GLenum mode;
        GLsizei count;
        GLenum type;
        GLvoid* indices;
        GLsizei instanceCount;
        GLint baseVertex;
    };
 
    struct BlitToSwapChainCommand {
        GLuint texture;
    };
 
    struct BindComputePipelineCommand {
        GLuint program;
    };
 
    struct DispatchCommand {
        GLuint groupsX;
        GLuint groupsY;
        GLuint groupsZ;
        unsigned int timingIndex;
    };
 
    struct ClearBufferCommand {
        GLenum target;
        GLuint buffer;
        GLintptr offset;
        GLsizeiptr size;
    };
 
    struct Command {
        union {
            BeginRenderPassCommand beginRenderPassCommand;
            BindGraphicsPipelineCommand bindGraphicsPipelineCommand;
            SetViewportCommand setViewportCommand;
            SetScissorCommand setScissorCommand;
            SetLineWidthCommand setLineWidthCommand;
            BindGeometryCommand bindGeometryCommand;
            SetUniformIntegerCommand setUniformIntegerCommand;
            SetUniformUnsignedIntegerCommand setUniformUnsignedIntegerCommand;
            SetUniformFloatCommand setUniformFloatCommand;
            SetUniformVector2Command setUniformVector2Command;
            SetUniformIVector2Command setUniformIVector2Command;
            SetUniformUVector2Command setUniformUVector2Command;
            SetUniformVector3Command setUniformVector3Command;
            SetUniformIVector3Command setUniformIVector3Command;
            SetUniformUVector3Command setUniformUVector3Command;
            SetUniformVector4Command setUniformVector4Command;
            SetUniformIVector4Command setUniformIVector4Command;
            SetUniformUVector4Command setUniformUVector4Command;
            SetUniformMatrix3Command setUniformMatrix3Command;
            SetUniformMatrix4Command setUniformMatrix4Command;
            BindTextureCommand bindTextureCommand;
            BindUniformBufferCommand bindUniformBufferCommand;
            BindStorageBufferCommand bindStorageBufferCommand;
            DrawCommand drawCommand;
            DrawIndexedCommand drawIndexedCommand;
            DrawIndexedInstancedCommand drawIndexedInstancedCommand;
            BlitToSwapChainCommand blitToSwapChainCommand;
            BindComputePipelineCommand bindComputePipelineCommand;
            DispatchCommand dispatchCommand;
            ClearBufferCommand clearBufferCommand;
        };
 
        enum class Type {
            BEGIN_RENDER_PASS,
            END_RENDER_PASS,
            BIND_GRAPHICS_PIPELINE,
            SET_VIEWPORT,
            SET_SCISSOR,
            SET_LINE_WIDTH,
            BIND_GEOMETRY,
            SET_UNIFORM_INTEGER,
            SET_UNIFORM_UNSIGNED_INTEGER,
            SET_UNIFORM_FLOAT,
            SET_UNIFORM_VECTOR2,
            SET_UNIFORM_IVECTOR2,
            SET_UNIFORM_UVECTOR2,
            SET_UNIFORM_VECTOR3,
            SET_UNIFORM_IVECTOR3,
            SET_UNIFORM_UVECTOR3,
            SET_UNIFORM_VECTOR4,
            SET_UNIFORM_IVECTOR4,
            SET_UNIFORM_UVECTOR4,
            SET_UNIFORM_MATRIX3,
            SET_UNIFORM_MATRIX4,
            BIND_TEXTURE,
            BIND_UNIFORM_BUFFER,
            BIND_STORAGE_BUFFER,
            DRAW,
            DRAW_INDEXED,
            DRAW_INDEXED_INSTANCED,
            BLIT_TO_SWAP_CHAIN,
            BIND_COMPUTE_PIPELINE,
            DISPATCH,
            CLEAR_BUFFER,
            MEMORY_BARRIER
        } type;
    };
 
    void SetUniformInteger(unsigned int location, int32_t value);
    void SetUniformUnsignedInteger(unsigned int location, uint32_t value);
    void SetUniformFloat(unsigned int location, float value);
    void SetUniformVector2(unsigned int location, const glm::vec2& value);
    void SetUniformIVector2(unsigned int location, const glm::ivec2& value);
    void SetUniformUVector2(unsigned int location, const glm::uvec2& value);
    void SetUniformVector3(unsigned int location, const glm::vec3& value);
    void SetUniformIVector3(unsigned int location, const glm::ivec3& value);
    void SetUniformUVector3(unsigned int location, const glm::uvec3& value);
    void SetUniformVector4(unsigned int location, const glm::vec4& value);
    void SetUniformIVector4(unsigned int location, const glm::ivec4& value);
    void SetUniformUVector4(unsigned int location, const glm::uvec4& value);
    void SetUniformMatrix3(unsigned int location, const glm::mat3& value);
    void SetUniformMatrix4(unsigned int location, const glm::mat4& value);
 
    void AddCommand(const Command& command);
    void SubmitCommand(const Command& command);
 
    OpenGLRenderer& openGLRenderer;
    OpenGLRenderPassAllocator& renderPassAllocator;
 
    std::vector<Command> commands;
    GLenum primitiveType;
    GLenum indexType;
    uint32_t indexSize;
    uint32_t frameBufferHeight;
    uintptr_t indexBufferOffset;
 
    bool inRenderPass = false;
 
    const OpenGLShaderProgram* currentShaderProgram = nullptr;
 
    const OpenGLShaderProgram* blitShaderProgram;
    GLuint blitSampler;
 
    bool writesStorageBuffer = false;
 
    std::vector<Timing> timings;
    unsigned int timingIndex;
};
 
} // namespace Video