ComputeRingDispatcher.hpp

Go to the documentation of this file.

#pragma once
 
#include <Gfx/Graph/encoders/ComputeEncoder.hpp>
#include <Gfx/Graph/interop/ImportedGpuBufferRing.hpp>
#include <Gfx/Graph/interop/InteropFence.hpp>
 
#include <functional>
#include <memory>
#include <vector>
 
class QRhiTexture;
 
namespace score::gfx
{
struct RenderState;
}
 
namespace score::gfx::interop
{
 
struct ComputeRingDispatcherConfig
{
  QRhi* rhi{};
  const score::gfx::RenderState* state{};
  ImportedGpuBufferRing* ring{};
  QRhiTexture* sourceTexture{};
  int width{};
  int height{};
  std::function<std::unique_ptr<score::gfx::ComputeEncoder>()> encoderFactory;
  QString colorConversion;
  InteropFence* fence{};
};
 
class ComputeRingDispatcher
{
public:
  ComputeRingDispatcher() = default;
  ~ComputeRingDispatcher() { release(); }
 
  ComputeRingDispatcher(const ComputeRingDispatcher&) = delete;
  ComputeRingDispatcher& operator=(const ComputeRingDispatcher&) = delete;
 
  bool init(const ComputeRingDispatcherConfig& cfg)
  {
    if(!cfg.rhi || !cfg.state || !cfg.ring || !cfg.ring->valid()
       || !cfg.sourceTexture || !cfg.encoderFactory)
      return false;
    release();
    m_cfg = cfg;
    m_encoders.resize(cfg.ring->slotCount());
    for(std::size_t i = 0; i < m_encoders.size(); ++i)
    {
      m_encoders[i] = cfg.encoderFactory();
      if(!m_encoders[i])
        return false;
      if(!m_encoders[i]->init(
             *cfg.rhi, *cfg.state, cfg.sourceTexture, cfg.width, cfg.height,
             cfg.ring->slot(i).qrhiBuffer, cfg.colorConversion))
        return false;
    }
    return true;
  }
 
  void release()
  {
    for(auto& e : m_encoders)
    {
      if(e)
      {
        e->release();
        e.reset();
      }
    }
    m_encoders.clear();
    m_cfg = {};
  }
 
  void encode(QRhiCommandBuffer& cb, std::uint64_t fenceValue)
  {
    if(!m_cfg.ring || !m_cfg.rhi)
      return;
    auto* res = m_cfg.rhi->nextResourceUpdateBatch();
    const auto idx = m_cfg.ring->writeIndex();
    if(idx < m_encoders.size() && m_encoders[idx])
      m_encoders[idx]->exec(*m_cfg.rhi, cb, res);
    if(m_cfg.fence)
      m_cfg.fence->signalAfterEncode(cb, fenceValue);
  }
 
  bool waitOnCuda(std::uint64_t fenceValue)
  {
    if(m_cfg.fence)
      return m_cfg.fence->waitOnCuda(fenceValue);
    return true; // no fence configured — caller assumes implicit ordering
  }
 
  GpuRingBufferSlot& finishedSlot() noexcept
  {
    return m_cfg.ring->slot(m_cfg.ring->writeIndex());
  }
 
  void advance() noexcept
  {
    if(m_cfg.ring)
      m_cfg.ring->advance();
  }
 
private:
  ComputeRingDispatcherConfig m_cfg{};
  std::vector<std::unique_ptr<score::gfx::ComputeEncoder>> m_encoders;
};
 
} // namespace score::gfx::interop