WebGPURenderer.hpp

Go to the documentation of this file.

#pragma once
 
#include "../Interface/LowLevelRenderer.hpp"
 
#include "WebGPU.hpp"
#include <glm/glm.hpp>
#include <vector>
 
namespace Utility {
class Window;
}
 
namespace Video {
 
class WebGPUBuffer;
class WebGPUBufferAllocator;
class WebGPUSampler;
class WebGPURenderTargetAllocator;
class WebGPUTexture;
 
class WebGPURenderer : public LowLevelRenderer {
  public:
 
    explicit WebGPURenderer(::Utility::Window* window);
 
    ~WebGPURenderer() final;
 
    CommandBuffer* CreateCommandBuffer() final;
    void BeginFrame() final;
    void Submit(CommandBuffer* commandBuffer) final;
    void Present() final;
    Buffer* CreateBuffer(Buffer::BufferUsage bufferUsage, uint32_t size, const void* data = nullptr) final;
    Buffer* CreateTemporaryBuffer(Buffer::BufferUsage bufferUsage, uint32_t size, const void* data = nullptr) final;
    VertexDescription* CreateVertexDescription(unsigned int attributeCount, const VertexDescription::Attribute* attributes, bool indexBuffer = false) final;
    GeometryBinding* CreateGeometryBinding(const VertexDescription* vertexDescription, Buffer* vertexBuffer, GeometryBinding::IndexType indexType = GeometryBinding::IndexType::NONE, const Buffer* indexBuffer = nullptr) final;
    Shader* CreateShader(const ShaderSource& shaderSource, Shader::Type type) final;
    ShaderProgram* CreateShaderProgram(std::initializer_list<const Shader*> shaders) final;
    Texture* CreateTexture(const glm::uvec2 size, Texture::Format format, int components, unsigned char* data) final;
    const Sampler* GetSampler(Sampler::Filter filter, Sampler::Clamping clamping) const final;
    Texture* CreateRenderTarget(const glm::uvec2& size, Texture::Format format) final;
    void FreeRenderTarget(Texture* renderTarget) final;
    GraphicsPipeline* CreateGraphicsPipeline(const ShaderProgram* shaderProgram, const GraphicsPipeline::Configuration& configuration, const VertexDescription* vertexDescription = nullptr) final;
    ComputePipeline* CreateComputePipeline(const ShaderProgram* shaderProgram) final;
    void Wait() final;
    unsigned char* ReadImage(Texture* texture) final;
    const std::vector<Profiling::Event>& GetTimeline() const final;
    const OptionalFeatures& GetOptionalFeatures() const final;
 
 
    WebGPUTexture* CreateAttachmentlessRenderTarget(const glm::uvec2& size, uint32_t sampleCount);
 
 
    void FreeAttachmentlessRenderTarget(WebGPUTexture* renderTarget);
 
 
    WGPUDevice GetDevice() const;
 
 
    WGPUQueue GetQueue() const;
 
 
    WGPUTextureView GetCurrentFrame() const;
 
 
    GraphicsPipeline* GetBlitGraphicsPipeline() const;
 
 
    bool HasDepthClipControl() const;
 
 
    bool HasR11G11B10() const;
 
 
    WGPUTextureFormat GetSwapChainFormat() const;
 
  private:
    WebGPURenderer(const WebGPURenderer& other) = delete;
 
    void InitializeWebGPUBackend();
    void CreateInstance();
    void CreateSurface(::Utility::Window* window);
    void RequestAdapter();
    void CreateDevice();
    void CreateSwapChain(::Utility::Window* window);
    void CreateSamplers();
 
    WGPUInstance instance;
    WGPUSurface surface;
    WGPUAdapter adapter;
    WGPUDevice device;
    WGPUSwapChain swapChain;
    WGPUQueue queue;
    WGPUTextureView currentFrame;
 
    WebGPUSampler* samplers[static_cast<uint32_t>(Sampler::Filter::COUNT) * static_cast<uint32_t>(Sampler::Clamping::COUNT)];
    
    WebGPUBufferAllocator* bufferAllocator;
    WebGPURenderTargetAllocator* renderTargetAllocator;
 
    OptionalFeatures optionalFeatures;
 
    glm::uvec2 swapChainSize;
    WGPUTextureFormat swapChainFormat;
 
    // Blitting to swap chain.
    Shader* blitVertexShader;
    Shader* blitFragmentShader;
    ShaderProgram* blitShaderProgram;
    GraphicsPipeline* blitGraphicsPipeline;
 
    std::vector<Profiling::Event> finishedEvents;
 
    bool depthClipControlEnabled;
    bool r11g11b10Enabled;
};
 
} // namespace Video