rhi_device.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <chrono>
#include <optional>
#include <utility>
#include <rhi/rhi_types.h>
#include <rhi/rhi_handle.h>
#include <rhi/rhi_deferred_release.h>
#include <rhi/rhi_buffer.h>
#include <rhi/rhi_compute.h>
#include <rhi/rhi_texture.h>
#include <rhi/rhi_shader.h>
#include <rhi/rhi_pipeline.h>
#include <rhi/rhi_render_pass.h>
#include <rhi/rhi_command.h>
#include <rhi/rhi_surface.h>

#undef ERROR

enum class RHI_FRAME_OP_RESULT
{
    OK,
    OUT_OF_DATE,
    SURFACE_LOST,
    DEVICE_LOST,
    ERROR
};
 
 
enum class RHI_SURFACE_EXTENT_POLL_RESULT
{
    IDLE,
    WAITING,
    RESIZED,
    FAILED
};

class RHI_DEVICE
{
public:
    virtual ~RHI_DEVICE() = default;

    virtual bool                        SupportsCompute() const { return false; }
    virtual RHI_COMPUTE_DEVICE_LIMITS   ComputeDeviceLimits() const { return {}; }
    virtual RHI_ComputePipelineHandle   CreateComputePipeline( const RHI_COMPUTE_PIPELINE_DESC& ) { return {}; }
    virtual void                        DestroyComputePipeline( RHI_ComputePipelineHandle ) {}
    virtual RHI_COMPUTE_PIPELINE_LIMITS ComputePipelineLimits( RHI_ComputePipelineHandle ) const { return {}; }

    virtual RHI_COMPUTE_RESULT ExecuteCompute( const RHI_COMPUTE_JOB& ) { return RHI_COMPUTE_RESULT::INVALID; }

    virtual const char* GetName() const = 0;
 
    virtual RHI_BACKEND GetBackend() const = 0;

    virtual uint32_t MaxTextureSize() const { return 16384; }
 
    virtual bool IsInitialized() const = 0;

    RHI_BufferHandle CreateBuffer( const RHI_BUFFER_DESC& desc )
    {
        RHI_BufferHandle handle = ReserveBufferHandle();
        return handle && RealizeBuffer( handle, desc ) ? handle : RHI_BufferHandle{};
    }

    virtual RHI_BufferHandle ReserveBufferHandle() = 0;

    virtual bool RealizeBuffer( RHI_BufferHandle handle, const RHI_BUFFER_DESC& desc ) = 0;

    virtual void DestroyBuffer( RHI_BufferHandle handle ) = 0;

    virtual void UpdateBuffer( RHI_BufferHandle handle, const void* data,
                               size_t sizeBytes, size_t offset = 0 ) = 0;

    RHI_TextureHandle CreateTexture( const RHI_TEXTURE_DESC& desc )
    {
        RHI_TextureHandle handle = ReserveTextureHandle();
        return handle && RealizeTexture( handle, desc ) ? handle : RHI_TextureHandle{};
    }

    virtual RHI_TextureHandle ReserveTextureHandle() = 0;

    virtual bool RealizeTexture( RHI_TextureHandle handle, const RHI_TEXTURE_DESC& desc ) = 0;

    virtual void DestroyTexture( RHI_TextureHandle handle ) = 0;

    virtual void UploadTexture( RHI_TextureHandle handle, const void* data, size_t sizeBytes ) = 0;

    virtual void BeginUploadBatch() {}
    virtual void EndUploadBatch() {}

    virtual RHI_ShaderHandle CreateShader( const RHI_SHADER_DESC& desc ) = 0;
 
    virtual void DestroyShader( RHI_ShaderHandle handle ) = 0;

    virtual RHI_PipelineHandle CreatePipeline( const RHI_PIPELINE_DESC& desc ) = 0;
 
    virtual void DestroyPipeline( RHI_PipelineHandle handle ) = 0;

    virtual RHI_RenderPassHandle CreateRenderPass( const RHI_RENDER_PASS_DESC& desc ) = 0;
 
    virtual void DestroyRenderPass( RHI_RenderPassHandle handle ) = 0;

    virtual RHI_FramebufferHandle CreateFramebuffer( const RHI_FRAMEBUFFER_DESC& desc ) = 0;
 
    virtual void DestroyFramebuffer( RHI_FramebufferHandle handle ) = 0;

    virtual RHI_TextureHandle GetFramebufferColorTexture(
            RHI_FramebufferHandle handle, uint32_t attachmentIndex = 0 ) const = 0;

    virtual RHI_BindGroupLayoutHandle CreateBindGroupLayout(
            const RHI_BIND_GROUP_LAYOUT_DESC& desc ) = 0;
 
    virtual void DestroyBindGroupLayout( RHI_BindGroupLayoutHandle handle ) = 0;

    virtual RHI_BindGroupHandle CreateBindGroup( const RHI_BIND_GROUP_DESC& desc ) = 0;
 
    virtual void DestroyBindGroup( RHI_BindGroupHandle handle ) = 0;

    virtual void BindGroup( uint32_t groupIndex, RHI_BindGroupHandle group ) = 0;

    virtual bool BeginRenderPass( const RHI_RENDER_PASS_BEGIN_DESC& desc ) = 0;

    virtual bool EndRenderPass() = 0;

    virtual void SetViewport( const RHI_VIEWPORT& viewport ) = 0;

    virtual void SetScissor( const RHI_SCISSOR_RECT& scissor ) = 0;

    virtual void BindPipeline( RHI_PipelineHandle pipeline ) = 0;

    virtual void SetPushConstants( const void* data, size_t sizeBytes ) = 0;

    virtual void BindVertexBuffer( uint32_t slot, RHI_BufferHandle buffer ) = 0;

    virtual void BindIndexBuffer( RHI_BufferHandle buffer ) = 0;

    virtual void Draw( uint32_t vertexCount, uint32_t firstVertex = 0 ) = 0;

    virtual void DrawInstanced( uint32_t vertexCount, uint32_t instanceCount,
                                uint32_t firstVertex = 0, int32_t vertexOffset = 0,
                                uint32_t firstInstance = 0 ) = 0;

    virtual void DrawIndexedInstanced( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex = 0,
                                       int32_t vertexOffset = 0, uint32_t firstInstance = 0 ) = 0;

    virtual RHI_SurfaceHandle CreateSurface( const RHI_SURFACE_DESC& desc ) = 0;

    virtual void DestroySurface( RHI_SurfaceHandle handle ) = 0;

    virtual RHI_SwapchainHandle CreateSwapchain( const RHI_SWAPCHAIN_DESC& desc ) = 0;

    virtual bool ResizeSwapchain( RHI_SwapchainHandle handle, uint32_t width,
                                  uint32_t height, float dpiScale ) = 0;
 
    virtual void DestroySwapchain( RHI_SwapchainHandle handle ) = 0;

    void Release( RHI_BufferHandle& aHandle ) { DestroyBuffer( std::exchange( aHandle, {} ) ); }
    void Release( RHI_TextureHandle& aHandle ) { DestroyTexture( std::exchange( aHandle, {} ) ); }
    void Release( RHI_ShaderHandle& aHandle ) { DestroyShader( std::exchange( aHandle, {} ) ); }
    void Release( RHI_PipelineHandle& aHandle ) { DestroyPipeline( std::exchange( aHandle, {} ) ); }
    void Release( RHI_BindGroupLayoutHandle& aHandle ) { DestroyBindGroupLayout( std::exchange( aHandle, {} ) ); }
    void Release( RHI_RenderPassHandle& aHandle ) { DestroyRenderPass( std::exchange( aHandle, {} ) ); }
    void Release( RHI_FramebufferHandle& aHandle ) { DestroyFramebuffer( std::exchange( aHandle, {} ) ); }
    void Release( RHI_BindGroupHandle& aHandle ) { DestroyBindGroup( std::exchange( aHandle, {} ) ); }
    void Release( RHI_SurfaceHandle& aHandle ) { DestroySurface( std::exchange( aHandle, {} ) ); }
    void Release( RHI_SwapchainHandle& aHandle ) { DestroySwapchain( std::exchange( aHandle, {} ) ); }

    virtual RHI_FRAME_OP_RESULT Present( RHI_SwapchainHandle handle, RHI_FramebufferHandle aSrcFBO = {},
                                          const RHI_SCISSOR_RECT* aSourceRect = nullptr ) = 0;

    virtual bool ReadbackFramebufferPixels( RHI_FramebufferHandle handle,
                                            uint32_t attachmentIndex,
                                            void* buffer, size_t bufferSize ) = 0;

    virtual bool CopyFramebufferDepth( RHI_FramebufferHandle aSource, RHI_FramebufferHandle aDestination,
                                       uint32_t aSourceX = 0, uint32_t aSourceY = 0 )
    {
        return false;
    }

    virtual bool WaitForPresentSlot( RHI_SwapchainHandle aSwapchain, std::chrono::milliseconds aTimeout,
                                     int aAllowed )
    {
        return false;
    }

    virtual RHI_SURFACE_EXTENT_POLL_RESULT PollSurfaceExtent( RHI_SwapchainHandle aSwapchain )
    {
        return RHI_SURFACE_EXTENT_POLL_RESULT::IDLE;
    }

    virtual bool PresentWaitsForDisplay( RHI_SwapchainHandle aSwapchain ) const { return true; }

    virtual bool PresentReplacesQueued( RHI_SwapchainHandle aSwapchain ) const { return false; }

    virtual std::optional<std::chrono::steady_clock::time_point>
    LastDisplayRefresh( RHI_SwapchainHandle aSwapchain ) const
    {
        return std::nullopt;
    }
 

    virtual void EndFrame()
    {
        m_frameCounter++;
        ExecuteDeferredReleases();
    }

    size_t PendingDeferredReleases() const { return m_deferredReleaseQueue.PendingCount(); }
 
protected:
    virtual void ExecuteDeferredReleases() = 0;

    template <typename Tag>
    void deferDestroy( RHI_HANDLE_POOL<Tag>& aPool, RHI_DEFERRED_RESOURCE_TYPE aType,
                       RHI_HANDLE<Tag> aHandle )
    {
        if( aPool.MarkPendingDestroy( aHandle ) )
            m_deferredReleaseQueue.Enqueue( aType, aHandle.value, m_frameCounter );
    }
 
    uint64_t                   m_frameCounter = 0;
    RHI_DEFERRED_RELEASE_QUEUE m_deferredReleaseQueue;
};