RenderList.hpp

#pragma once
#include <Gfx/Graph/CommonUBOs.hpp>
#include <Gfx/Graph/GpuTiming.hpp>
#include <Gfx/Graph/Node.hpp>
 
#include <ossia/detail/hash_map.hpp>
 
#include <memory>
 
namespace Gfx
{
class AssetTable;
}
namespace score::gfx
{
 
class GpuResourceRegistry;
class OutputNode;
class VertexFallbackPool;
class SCORE_PLUGIN_GFX_EXPORT RenderList
{
  friend struct Graph;
private:
  QRhiCommandBuffer* m_currentCommands{};
  std::shared_ptr<RenderState> m_state;
 
public:
  explicit RenderList(OutputNode& output, const std::shared_ptr<RenderState>& state);
  ~RenderList();
 
  void init();
 
  [[nodiscard]] QRhiResourceUpdateBatch* initialBatch() const noexcept;
 
  void setInitialBatch(QRhiResourceUpdateBatch* batch) noexcept { m_initialBatch = batch; }
 
  void flushInitialBatch();
 
  MeshBuffers initMeshBuffer(const Mesh& mesh, QRhiResourceUpdateBatch& res);
 
  void update(QRhiResourceUpdateBatch& res);
 
  void render(QRhiCommandBuffer& commands, bool force = false);
 
  QRhiCommandBuffer* currentCommandBuffer() const noexcept
  {
    return m_currentCommands;
  }
 
  void release();
 
  void releaseBuffer(QRhiBuffer* buf);
 
  bool maybeRebuild(bool force = false);
 
  bool resizeSwapchainSizedTargets(QSize newOutputSize, QSize newRenderSize);
 
  TextureRenderTarget renderTargetForOutput(const Edge& edge) const noexcept;
 
  TextureRenderTarget renderTargetForInputPort(const Port& p) const noexcept;
 
  BufferView bufferForInput(const Edge& edge) const noexcept;
  BufferView bufferForOutput(const Edge& edge) const noexcept;
 
  QImage adaptImage(const QImage& in);
 
  OutputNode& output;
 
  RenderState& state;
 
  using Buffers = std::pair<const Mesh* const, MeshBuffers>;
  Buffers acquireMesh(
      const ossia::geometry_spec&, QRhiResourceUpdateBatch& res, const Mesh* current,
      MeshBuffers currentbufs) noexcept;
 
  std::vector<score::gfx::Node*> nodes;
 
  std::vector<score::gfx::NodeRenderer*> renderers;
 
  void clearRenderers();
 
  QRhiTexture& emptyTexture() const noexcept { return *m_emptyTexture; }
 
  QRhiTexture& emptyTexture3D() const noexcept { return *m_emptyTexture3D; }
 
  QRhiTexture& emptyTextureCube() const noexcept { return *m_emptyTextureCube; }
 
  QRhiTexture& emptyTextureArray() const noexcept { return *m_emptyTextureArray; }
 
  QRhiBuffer& outputUBO() const noexcept { return *m_outputUBO; }
 
  GpuResourceRegistry& registry() noexcept { return *m_registry; }
  const GpuResourceRegistry& registry() const noexcept { return *m_registry; }
 
  VertexFallbackPool& vertexFallbackPool() noexcept { return *m_vertexFallbackPool; }
 
  GpuTimings& gpuTimings() noexcept { return m_gpuTimings; }
  const GpuTimings& gpuTimings() const noexcept { return m_gpuTimings; }
 
  Gfx::AssetTable* assetTable() const noexcept { return m_assetTable; }
  void setAssetTable(Gfx::AssetTable* t) noexcept { m_assetTable = t; }
 
  const score::gfx::Mesh& defaultQuad() const noexcept;
 
  const score::gfx::Mesh& defaultTriangle() const noexcept;
 
  bool requiresDepth(const score::gfx::Port& p) const noexcept;
  bool anyNodeRequiresDepth() const noexcept { return m_requiresDepth; }
 
  int samples() const noexcept { return m_samples; }
 
  bool canRender() const noexcept { return m_ready; }
 
  QSize renderSize(const Edge* e) const noexcept;
 
  int64_t frame = 0;
  float currentDate[4]{};
 
  void createAllInputRenderTargets();
 
  void markBuilt() noexcept { m_built = true; m_lastSize = state.renderSize; }
 
  [[nodiscard]] bool isBuilt() const noexcept { return m_built; }
 
  void markRequiresDepth(bool value) noexcept { m_requiresDepth = value; }
 
  void
  onEdgeRemoved(Edge& edge, const ossia::hash_set<const Port*>* preserveSinks = nullptr);
 
  void removeInputRenderTarget(const Port* port);
 
  QSize resolveDownstreamSize(
      const Node* node,
      const ossia::small_flat_map<const Port*, RenderTargetSpecs, 16>& resolvedSpecs)
      const noexcept;
 
private:
  OutputUBO m_outputUBOData;
 
 
  QRhiResourceUpdateBatch* m_initialBatch{};
 
  // Scene-graph arena store (camera / light / material / per_draw buffers).
  // Persist-across-rebuild contract: ownership is on the OutputNode
  // (OutputNode::m_registry), so the registry — and all its arena
  // buffers, mesh slabs, texture-array channels, ScenePreprocessor
  // material/env slots — survives `Graph::recreateOutputRenderList`
  // (viewport resize / fallback rebuild). RenderList::init() either
  // calls GpuResourceRegistry::init() once (first RL on this output)
  // or adopts the populated state as-is (every subsequent rebuild).
  // RenderList::release() does NOT destroy it. OutputNode::releaseRegistry()
  // tears it down via destroyOwned() when its QRhi goes away.
  GpuResourceRegistry* m_registry{};
 
  // Pool of tiny shared vertex buffers used to satisfy "REQUIRED: false"
  // VERTEX_INPUTS whose upstream geometry is missing an attribute.
  // Same lifetime as m_registry.
  std::unique_ptr<VertexFallbackPool> m_vertexFallbackPool;
 
  // GPU-timing collector. Lives as long as the RenderList — outlives
  // individual renderers so per-pass measurements survive node churn.
  GpuTimings m_gpuTimings;
 
  // Session-wide asset decode cache. Non-owning; GfxContext is the
  // owner. May be null.
  Gfx::AssetTable* m_assetTable{};
 
  // Material
  QRhiBuffer* m_outputUBO{};
  QRhiTexture* m_emptyTexture{};
  QRhiTexture* m_emptyTexture3D{};
  QRhiTexture* m_emptyTextureCube{};
  QRhiTexture* m_emptyTextureArray{};
 
  ossia::flat_map<Mesh*, MeshBuffers> m_vertexBuffers;
 
  ossia::flat_map<ossia::geometry_spec, Mesh*> m_customMeshCache;
 
  ossia::small_flat_map<const Port*, TextureRenderTarget, 8> m_inputRenderTargets;
 
  QSize m_lastSize{};
 
  int m_minTexSize{};
  int m_maxTexSize{};
  int m_samples{1};
 
  bool m_requiresDepth{};
  bool m_ready{};
  bool m_built{};
};
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture::Format imageTextureFormat(const QRhi& rhi) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
QImage adaptImageFormat(QImage img, QRhiTexture::Format fmt);
}