LowLevelRenderer.hpp

Go to the documentation of this file.

#pragma once
 
#include "Buffer.hpp"
#include "VertexDescription.hpp"
#include "GeometryBinding.hpp"
#include "RenderPass.hpp"
#include "Shader.hpp"
#include "Texture.hpp"
#include "Sampler.hpp"
#include "GraphicsPipeline.hpp"
 
#include <glm/glm.hpp>
#include <initializer_list>
#include <vector>
#include <Utility/Profiling/Event.hpp>
 
struct ShaderSource;
 
namespace Video {
 
class CommandBuffer;
class ShaderProgram;
class Texture;
class ComputePipeline;
 
class LowLevelRenderer {
  public:
    struct OptionalFeatures {
        bool fillModeNonSolid;
 
        bool wideLines;
 
        bool timestamps;
 
        bool conservativeRasterization;
 
        uint32_t attachmentlessMsaaSamples;
 
        bool shaderAtomics;
    };
 
    LowLevelRenderer() {}
 
    virtual ~LowLevelRenderer() {}
 
 
    virtual CommandBuffer* CreateCommandBuffer() = 0;
 
    virtual void BeginFrame() = 0;
 
 
    virtual void Submit(CommandBuffer* commandBuffer) = 0;
 
    virtual void Present() = 0;
 
 
    virtual Buffer* CreateBuffer(Buffer::BufferUsage bufferUsage, unsigned int size, const void* data = nullptr) = 0;
 
 
    virtual Buffer* CreateTemporaryBuffer(Buffer::BufferUsage bufferUsage, unsigned int size, const void* data = nullptr) = 0;
 
 
    virtual VertexDescription* CreateVertexDescription(unsigned int attributeCount, const VertexDescription::Attribute* attributes, bool indexBuffer = false) = 0;
 
 
    virtual GeometryBinding* CreateGeometryBinding(const VertexDescription* vertexDescription, Buffer* vertexBuffer, GeometryBinding::IndexType indexType = GeometryBinding::IndexType::NONE, const Buffer* indexBuffer = nullptr) = 0;
 
 
    virtual Shader* CreateShader(const ShaderSource& shaderSource, Shader::Type type) = 0;
 
 
    virtual ShaderProgram* CreateShaderProgram(std::initializer_list<const Shader*> shaders) = 0;
 
 
    virtual Texture* CreateTexture(const glm::uvec2 size, Texture::Format format, int components, unsigned char* data) = 0;
 
 
    virtual const Sampler* GetSampler(Sampler::Filter filter, Sampler::Clamping clamping) const = 0;
 
 
    virtual Texture* CreateRenderTarget(const glm::uvec2& size, Texture::Format format) = 0;
 
 
    virtual void FreeRenderTarget(Texture* renderTarget) = 0;
 
 
    virtual GraphicsPipeline* CreateGraphicsPipeline(const ShaderProgram* shaderProgram, const GraphicsPipeline::Configuration& configuration, const VertexDescription* vertexDescription = nullptr) = 0;
 
 
    virtual ComputePipeline* CreateComputePipeline(const ShaderProgram* shaderProgram) = 0;
 
    virtual void Wait() = 0;
 
 
    virtual unsigned char* ReadImage(Texture* texture) = 0;
 
 
    void SetProfiling(bool profiling) {
        this->profiling = profiling;
    }
 
 
    bool IsProfiling() const {
        return profiling;
    }
 
 
    virtual const std::vector<Profiling::Event>& GetTimeline() const = 0;
 
 
    virtual const OptionalFeatures& GetOptionalFeatures() const = 0;
 
  private:
    LowLevelRenderer(const LowLevelRenderer& other) = delete;
 
    bool profiling = false;
};
 
} // namespace Video