render_thread.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/>.
 */
 
#ifndef RHI_RENDER_THREAD_H
#define RHI_RENDER_THREAD_H
 
#include <rhi/rhi_control_commands.h>
#include <rhi/rhi_upload_commands.h>
 
#include <rhi/render_thread_window_state.h>
#include <rhi/rhi_gal_pipelines.h>
#include <rhi/rhi_glyph_atlas.h>
#include <rhi/rhi_compositor.h>
 
#include <core/sync_queue.h>
 
#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <deque>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <optional>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
 
class RHI_DEVICE;
class wxImage;
 
 
namespace KIGFX
{

using RHI_DEVICE_FACTORY = std::function<std::unique_ptr<RHI_DEVICE>()>;
 

class RENDER_THREAD
{
public:
    explicit RENDER_THREAD( RHI_DEVICE_FACTORY aDeviceFactory );
 
    ~RENDER_THREAD();
 
    RENDER_THREAD( const RENDER_THREAD& ) = delete;
    RENDER_THREAD& operator=( const RENDER_THREAD& ) = delete;

    bool Start();
 
    bool IsRunning() const;

    void SetGlyphAtlas( std::shared_ptr<const RHI_GLYPH_ATLAS_DATA> aAtlas );

    bool SubmitControl( RHI_CONTROL_COMMAND aCmd );

    void SubmitUpload( RHI_UPLOAD_COMMAND aCmd );

    bool WaitForFence( std::chrono::milliseconds aTimeout = std::chrono::milliseconds( 2000 ) );

    void Shutdown();

    RHI_BACKEND GetBackendType() const { return m_backendType.load( std::memory_order_acquire ); }

    uint32_t GetMaxTextureSize() const { return m_maxTextureSize.load( std::memory_order_acquire ); }

    RHI_BufferHandle  ReserveBufferHandle();
    RHI_TextureHandle ReserveTextureHandle();

    bool ReadbackWindowPixels( RHI_WINDOW_ID aWindowId, wxImage& aImage );

    int GetLoopPhase() const { return m_loopPhase.load( std::memory_order_relaxed ); }

    bool IsDeviceLost() const { return m_deviceLost.load( std::memory_order_acquire ); }

    bool HasPresented( RHI_WINDOW_ID aWindowId ) const;

    void AddDeviceLostListener( const void* aOwner, std::function<void()> aListener );

    void RemoveDeviceLostListener( const void* aOwner );

    static void ComputeBackingResolution( uint32_t aLogicalW, uint32_t aLogicalH, float aDpiScale,
                                          uint32_t& aBackingW, uint32_t& aBackingH );

    void OnDeviceLost();
 
private:
    void ThreadMain( std::promise<bool> aStarted );
    void DrainControlQueue();
    void DrainUploadQueue();
 
    void HandleFrameRequest( const RHI_CMD_FRAME_REQUEST& aCmd );
    void HandleSwapchainCreate( const RHI_CMD_SWAPCHAIN_CREATE& aCmd );
    void HandleSwapchainResize( const RHI_CMD_SWAPCHAIN_RESIZE& aCmd );
    void HandleSwapchainDestroy( const RHI_CMD_SWAPCHAIN_DESTROY& aCmd );
    void HandleFence( const RHI_CMD_FENCE& aCmd );

    void ProcessActiveWindows( bool aIgnorePacing = false );
 
    bool EnsureSwapchain( WINDOW_STATE& aWS, const char* aReason );

    void recreateSwapchainAfterOutOfDate( WINDOW_STATE& aWS, bool aSurfaceLost = false );

    bool RenderWindow( WINDOW_STATE& aWS );
    void RenderGeometry( WINDOW_STATE& aWS );
    enum class GEOMETRY_RANGES : uint8_t
    {
        ALL,
        NOT_OVERLAY,
        OVERLAY
    };

    void RenderGeometryInto( WINDOW_STATE& aWS, const FRAME_DRAW_DESC& aDesc, RHI_FramebufferHandle aFBO,
                             bool aLogSummary, GEOMETRY_RANGES aRanges = GEOMETRY_RANGES::ALL,
                             uint32_t aStaticDrawMargin = 0 );
    bool prepareCursor( WINDOW_STATE& aWS );

    bool runFenced( std::function<void()> aWork, std::chrono::milliseconds aTimeout );

    bool writeUniform( RHI_BufferHandle& aUBO, RHI_BindGroupHandle& aBG, RHI_BindGroupLayoutHandle aLayout,
                       const void* aData, size_t aSize );

    void drawCursor( WINDOW_STATE& aWS );
 
    void DestroyAllWindows();

    void destroyWindow( WINDOW_STATE& aWS );
 
    bool InitRenderInfrastructure();
    void DestroyRenderInfrastructure();
 
    void CreateWindowFBOs( WINDOW_STATE& aWS );
    void DestroyWindowFBOs( WINDOW_STATE& aWS );
    void DestroyWindowUniforms( WINDOW_STATE& aWS );
 
    void wakeRenderThread();
 
    RHI_DEVICE_FACTORY m_deviceFactory;
 
    std::unique_ptr<RHI_DEVICE> m_device;

    mutable std::mutex          m_deviceMutex;
 
    std::atomic<RHI_BACKEND>    m_backendType{ RHI_BACKEND::NONE };
    std::atomic<uint32_t>       m_maxTextureSize{ 0 };
 
    SYNC_QUEUE<RHI_CONTROL_COMMAND> m_controlQueue;
    SYNC_QUEUE<RHI_UPLOAD_COMMAND>  m_uploadQueue;
 
    std::thread             m_thread;
 
    std::mutex              m_workMutex;
    std::condition_variable m_workCV;
 
    std::atomic<bool> m_running{ false };
    std::atomic<bool> m_shutdownRequested{ false };

    bool              m_acceptingWork = false;

    std::atomic<bool> m_uploadsPending{ false };
    std::atomic<bool> m_deviceLost{ false };

    std::mutex                                             m_deviceLostMutex;
    std::unordered_map<const void*, std::function<void()>> m_deviceLostListeners;

    mutable std::mutex                m_presentedMutex;
    std::unordered_set<RHI_WINDOW_ID> m_presentedWindows;
 
    std::atomic<int>  m_loopPhase{ 0 };     
 
    std::unordered_map<RHI_WINDOW_ID, WINDOW_STATE> m_windows;
 
    std::vector<WINDOW_STATE*> m_activeWindowOrder;

    std::optional<WINDOW_STATE::Clock::time_point> m_deferredFrameDue;
 
    void deferFrameUntil( WINDOW_STATE::Clock::time_point aDue )
    {
        m_deferredFrameDue = m_deferredFrameDue ? std::min( *m_deferredFrameDue, aDue ) : aDue;
    }

    std::unique_ptr<RHI_GAL_PIPELINES> m_pipelines;
    std::unique_ptr<RHI_COMPOSITOR>    m_compositor;
    RHI_BufferHandle                   m_unitQuadBuffer;
    RHI_BufferHandle                   m_quadCornerBuffer;   
    RHI_BufferHandle                   m_quadIndexBuffer;    

    RHI_TextureHandle   m_glyphTexture;
    RHI_BufferHandle    m_glyphTable;
    RHI_BindGroupHandle m_glyphBG;
    bool                m_glyphBGHasAtlas = false;
 
    mutable std::mutex                          m_glyphAtlasMutex;
    std::shared_ptr<const RHI_GLYPH_ATLAS_DATA> m_glyphAtlas;
 
    RHI_BindGroupHandle glyphBindGroup();
    void                destroyGlyphResources();
 
    RHI_RenderPassHandle               m_geometryRenderPass;
    RHI_RenderPassHandle               m_geometryLoadRenderPass;
    RHI_RenderPassHandle               m_geometryDepthLoadRenderPass;   

    RHI_RenderPassHandle               m_geometryDepthDiscardRenderPass;
    RHI_RenderPassHandle               m_geometryDepthLoadDiscardRenderPass;
};
 
 
} // namespace KIGFX
 
#endif // RHI_RENDER_THREAD_H