RenderList.hpp

#pragma once
#include <Gfx/Graph/CommonUBOs.hpp>
#include <Gfx/Graph/GpuTiming.hpp>
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/Quirks.hpp>
#include <Gfx/Graph/TextureKind.hpp>
 
#include <ossia/detail/flat_map.hpp>
#include <ossia/detail/flat_set.hpp>
#include <ossia/detail/hash_map.hpp>
 
#include <array>
#include <chrono>
#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) noexcept;
 
  QRhiCommandBuffer* currentCommandBuffer() const noexcept
  {
    return m_currentCommands;
  }
 
  bool rendering() const noexcept { return m_rendering; }
 
  void release();
 
  void releaseBuffer(QRhiBuffer* buf);
 
  static void adoptBuffer(QRhiBuffer* buf);
  static void dropAdoptedBuffer(QRhi& rhi, QRhiBuffer* buf);
 
  static void releaseResource(QRhi& rhi, QRhiResource* res);
  static int adoptedBufferCount() noexcept;
 
  static bool isRetiredBuffer(const QRhiBuffer* buf) noexcept;
  static bool isRetiringBuffer(const QRhiBuffer* buf) noexcept;
  static QByteArray retiredBufferName(const QRhiBuffer* buf);
  static int retiredBufferCount() noexcept;
  static void noteBufferLive(const QRhiBuffer* buf) noexcept;
  static void noteFrameCompleted() noexcept;
 
  bool checkBindingsLive(
      const QRhiShaderResourceBindings& srb, const char* where) const noexcept;
 
  static bool hasRetiredBinding(const QRhiShaderResourceBindings& srb) noexcept;
 
  static bool strictBindingsEnabled() noexcept;
 
  static int staleBindingCount() noexcept;
  static void resetStaleBindingCount() noexcept;
 
  bool maybeRebuild(bool force = false);
 
  bool resizeSwapchainSizedTargets(QSize newOutputSize, QSize newRenderSize);
 
  TextureRenderTarget renderTargetForOutput(const Edge& edge) const noexcept;
 
  QRhiTexture* previewSource(const Node& node, int port) const noexcept;
 
  static const RenderList* previewHost(const Node& node, int port) noexcept;
 
  bool rendersLive() 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;
 
private:
  void sweepMeshCache() noexcept;
 
public:
 
  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; }
 
  QRhiTexture& whiteTexture() const noexcept { return *m_whiteTexture; }
 
  QRhiTexture& emptyTextureFor(const Port& in) const noexcept;
 
  QRhiTexture* selfFeedbackGrab(const Port& in) const noexcept;
 
  QRhiBuffer& outputUBO() const noexcept { return *m_outputUBO; }
 
  QRhiBuffer& outputUBO(int sampleCount) const noexcept;
 
  GpuResourceRegistry& registry() noexcept { return *m_registry; }
 
  void releaseRendererState(NodeRenderer& r);
 
  void releaseOwnedTarget(TextureRenderTarget& rt);
  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; }
 
  const Quirks& quirks() const noexcept { return m_quirks; }
 
  void isolateFollowingPasses() noexcept;
 
  bool canRender() const noexcept { return m_ready; }
 
  QSize renderSize(const Edge* e) const noexcept;
 
  int64_t frame = 0;
  // Year, month, day, seconds since midnight: the ISF DATE uniform.
  float currentDate[4]{};
  // Set by GfxContext::renderFrames, which then writes currentDate from its
  // step clock, until the next GfxContext::updateGraph(): keeps DATE off the
  // wall clock so a step renders deterministically.
  bool dateFromStepClock{false};
 
  void createAllInputRenderTargets();
 
  void markBuilt() noexcept { m_built = true; m_lastSize = state.renderSize; }
 
  [[nodiscard]] bool isBuilt() const noexcept { return m_built; }
 
  [[nodiscard]] bool outputTargetsStale() const noexcept { return m_outputTargetsStale; }
 
  void markOutputTargetsStale() noexcept
  {
    if(m_built)
      m_outputTargetsStale = true;
  }
 
  void markRequiresDepth(bool value) noexcept
  {
    if(value != m_requiresDepth && m_built)
      m_outputTargetsStale = true;
    m_requiresDepth = value;
  }
 
  void
  onEdgeRemoved(Edge& edge, const ossia::hash_set<const Port*>* preserveSinks = nullptr);
 
  void removeInputRenderTarget(const Port* port);
 
  void ensureSelfFeedbackTargets();
 
  QSize resolveDownstreamSize(
      const Node* node,
      const ossia::small_flat_map<const Port*, RenderTargetSpecs, 16>& resolvedSpecs)
      const noexcept;
 
  RenderTargetSpecs resolveInputRenderTargetSpecs(const Node& node, int32_t port) noexcept;
 
  RenderTargetSpecs resolveInputRenderTargetSpecs(
      const Node& node, int32_t port,
      const ossia::small_flat_map<const Port*, RenderTargetSpecs, 16>& resolvedSpecs) noexcept;
 
private:
  void resolveAllInletSpecs(
      ossia::small_flat_map<const Port*, RenderTargetSpecs, 16>& resolvedSpecs) noexcept;
  QSize resolveInletSize(
      const Port& in,
      const ossia::small_flat_map<const Port*, RenderTargetSpecs, 16>& resolvedSpecs,
      ossia::flat_set<const Node*>& visiting) const noexcept;
  QSize resolveDownstreamSize(
      const Node* node,
      const ossia::small_flat_map<const Port*, RenderTargetSpecs, 16>& resolvedSpecs,
      ossia::flat_set<const Node*>& visiting) const noexcept;
 
  void renderImpl(QRhiCommandBuffer& commands, bool force);
 
  // Rendering failures repeat every frame: report the first one per
  // RenderList, then one in 600, instead of a line per frame.
  int m_renderFailures{};
  int m_nestedRenders{};
  bool m_rendering{};
 
  OutputUBO m_outputUBOData;
 
 
  QRhiResourceUpdateBatch* m_initialBatch{};
  void retireResourcesReleasedOutsideFrame() noexcept;
 
  // Scene-graph arena store (camera / light / material / per_draws 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{};
  // outputUBO(int): one copy per other supported sample count.
  std::vector<std::pair<int, QRhiBuffer*>> m_outputUBOBySamples;
  QRhiTexture* m_emptyTexture{};
  QRhiTexture* m_emptyTexture3D{};
  QRhiTexture* m_emptyTextureCube{};
  QRhiTexture* m_emptyTextureArray{};
  QRhiTexture* m_whiteTexture{};
 
  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;
 
  struct SelfFeedbackTarget
  {
    TextureRenderTarget back;
    bool written{};
  };
  ossia::small_flat_map<const Port*, SelfFeedbackTarget, 2> m_selfFeedbackTargets;
 
  ossia::small_flat_map<const Port*, QRhiTexture*, 2> m_selfFeedbackGrabs;
 
  void renderPreviewTaps(QRhiCommandBuffer& commands, QRhiResourceUpdateBatch*& res);
  void releasePreviewTaps();
  struct PreviewTapTarget
  {
    std::weak_ptr<PreviewTap> tap;
    TextureRenderTarget rt;
    QRhiSampler* sampler{};
    Pipeline pipeline;
    MeshBuffers mesh;
    QRhiTexture* source{};
    TextureKind kind{};
    std::shared_ptr<QRhiReadbackResult> readback;
    int64_t visited{-1};
    void release();
  };
  std::vector<PreviewTapTarget> m_previewTaps;
  std::array<std::pair<QShader, QShader>, texture_kind_count> m_previewShaders;
  struct RetiredPreviewReadback
  {
    std::shared_ptr<QRhiReadbackResult> readback;
    int64_t until{};
  };
  std::vector<RetiredPreviewReadback> m_retiredPreviewReadbacks;
  void retirePreviewTap(PreviewTapTarget& t);
  std::chrono::steady_clock::time_point m_lastRender{std::chrono::steady_clock::now()};
  ossia::small_flat_map<const Port*, QRhiTexture*, 2> m_selfFeedbackPlaceholders;
  ossia::flat_set<const Port*> m_selfFeedbackWarned;
 
  ossia::flat_set<const QRhiTexture*> m_targetsToClear;
  void clearOnFirstUse(const TextureRenderTarget& rt);
  void clearNewTargets(QRhiCommandBuffer& commands, QRhiResourceUpdateBatch& res);
 
  void updateSelfFeedbackTargets(QRhiResourceUpdateBatch& res);
  void updateSelfFeedbackGrabs(QRhiResourceUpdateBatch& res);
  void removeSelfFeedbackTarget(const Port* port);
  bool ensureSelfFeedbackTarget(const Port& in);
 
  void rebuildOutputTargets(QRhiResourceUpdateBatch& res);
 
  QSize m_lastSize{};
 
  int m_minTexSize{};
  int m_maxTexSize{};
  int m_samples{1};
  Quirks m_quirks;
 
  bool m_warnedMixedDepthCompare = false;
  bool m_requiresDepth{};
  bool m_ready{};
  bool m_built{};
  bool m_outputTargetsStale{};
  bool m_renderSizeChanged{};
};
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture::Format imageTextureFormat(const QRhi& rhi) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
QImage adaptImageFormat(QImage img, QRhiTexture::Format fmt);
}