NodeRenderer.hpp

#pragma once
#include <Gfx/Graph/Node.hpp>
 
namespace score::gfx
{
 
class SCORE_PLUGIN_GFX_EXPORT NodeRenderer
{
public:
  explicit NodeRenderer(const Node& node)
      : node{node}
  {
  }
  virtual ~NodeRenderer();
 
  virtual TextureRenderTarget renderTargetForInput(const Port& input);
  virtual BufferView bufferForInput(const Port& input);
  virtual BufferView bufferForOutput(const Port& output);
 
  virtual QRhiTexture* textureForOutput(const Port& output);
 
  virtual void updateInputTexture(const Port& input, QRhiTexture* tex, QRhiTexture* depthTex = nullptr);
 
  virtual void updateInputSamplerFilter(
      const Port& input, const RenderTargetSpecs& spec);
 
  virtual void
  inputAboutToFinish(RenderList& renderer, const Port& p, QRhiResourceUpdateBatch*&);
 
  virtual void init(RenderList& renderer, QRhiResourceUpdateBatch& res) = 0;
  virtual void update(RenderList& renderer, QRhiResourceUpdateBatch& res, Edge* edge)
      = 0;
 
  virtual void runInitialPasses(
      RenderList&, QRhiCommandBuffer& commands, QRhiResourceUpdateBatch*& res,
      Edge& edge);
 
  virtual void runRenderPass(RenderList&, QRhiCommandBuffer& commands, Edge& edge);
 
  virtual QRhiGraphicsPipeline::CompareOp depthCompare() const noexcept
  {
    return QRhiGraphicsPipeline::Greater;
  }
 
  virtual void release(RenderList&) = 0;
 
  virtual void initState(RenderList& renderer, QRhiResourceUpdateBatch& res);
 
  virtual void releaseState(RenderList& renderer);
 
  virtual void addOutputPass(
      RenderList& renderer, Edge& edge, QRhiResourceUpdateBatch& res);
 
  virtual void removeOutputPass(RenderList& renderer, Edge& edge) = 0;
 
  virtual void
  addInputEdge(RenderList& renderer, Edge& edge, QRhiResourceUpdateBatch& res);
 
  virtual void removeInputEdge(RenderList& renderer, Edge& edge);
 
  virtual bool hasOutputPassForEdge(Edge& edge) const;
 
  virtual void seedInitialOutputs(RenderList& renderer);
 
  virtual bool followsRenderSize() const noexcept { return false; }
 
  void checkForChanges()
  {
    // Use |= to preserve flags set externally (e.g. by reconciliation
    // or maybeRebuild). The flag is cleared by the renderer's update()
    // after processing, preventing infinite re-uploads.
    materialChanged |= node.hasMaterialChanged(materialChangedIndex);
    renderTargetSpecsChanged |= node.hasRenderTargetChanged(renderTargetSpecsChangedIndex);
  }
 
  void syncRenderTargetIndex()
  {
    node.hasRenderTargetChanged(renderTargetSpecsChangedIndex);
    renderTargetSpecsChanged = false;
  }
 
  void process(int32_t port, const ossia::geometry_spec& v);
  void process(int32_t port, const ossia::scene_spec& v);
  virtual void process(int32_t port, const ossia::transform3d& v);
 
  void process(int32_t port, const ossia::geometry_spec& v, const void* source_key);
  void process(int32_t port, const ossia::scene_spec& v, const void* source_key);
 
  const ossia::geometry_spec* findGeometryByPort(int32_t port) const
  {
    for(const auto& [k, v] : m_portGeometries)
      if(k.first == port)
        return &v;
    return nullptr;
  }
 
  template <typename F>
  void forEachSceneOnPort(int32_t port, F&& fn) const
  {
    for(const auto* kv : portScenesInEdgeOrder())
      if(kv->first.first == port && kv->second.state)
        fn(kv->second);
  }
 
private:
  void rebuildMergedScene();
 
  ossia::small_vector<const std::pair<std::pair<int32_t, const void*>, ossia::scene_spec>*, 4>
  portScenesInEdgeOrder() const;
 
public:
 
  const Node& node;
 
  ossia::geometry_spec geometry;
 
  using PortSourceKey = std::pair<int32_t, const void*>;
  ossia::small_flat_map<PortSourceKey, ossia::geometry_spec, 4> m_portGeometries;
 
  ossia::scene_spec scene;
 
  ossia::small_flat_map<PortSourceKey, ossia::scene_spec, 4> m_portScenes;
 
  using MergeCacheKey = std::pair<const ossia::scene_state*, int64_t>;
  ossia::small_vector<MergeCacheKey, 4> m_mergeCacheInputs;
  ossia::scene_spec m_mergeCacheOutput;
 
  ossia::small_flat_map<
      PortSourceKey, std::pair<ossia::geometry_spec, ossia::scene_spec>, 4>
      m_wrapCache;
 
  int32_t nodeId{-1};
  bool materialChanged{false};
  bool geometryChanged{false};
  bool sceneChanged{false};
  bool renderTargetSpecsChanged{false};
 
  bool m_initialized{false};
 
private:
  int64_t materialChangedIndex{-1};
  int64_t renderTargetSpecsChangedIndex{-1};
};
 
struct Pass
{
  // User-declared ctors (including the implicit ones spelled out here)
  // suppress -Wmissing-field-initializers on the many call sites that
  // brace-init this struct with three arguments.
  Pass() = default;
  Pass(TextureRenderTarget rt, Pipeline pi, QRhiBuffer* ubo)
      : renderTarget{std::move(rt)}, p{pi}, processUBO{ubo} {}
  // Compat for addons that build a pass from a bare Pipeline; such passes
  // fetch their render target through renderer.renderTargetForOutput(edge)
  // at draw time.
  Pass(Pipeline pi)
      : p{pi} {}
 
  TextureRenderTarget renderTarget;
  Pipeline p;
  QRhiBuffer* processUBO{};
 
  void release()
  {
    p.release();
    if(processUBO)
    {
      processUBO->deleteLater();
      processUBO = nullptr;
    }
    // renderTarget NOT released here — owned by RenderList
  }
};
 
using PassMap = ossia::small_vector<std::pair<Edge*, Pass>, 2>;
SCORE_PLUGIN_GFX_EXPORT
void defaultPassesInit(
    PassMap& passes, const std::vector<Edge*>& edges, RenderList& renderer,
    const Mesh& mesh, const QShader& v, const QShader& f, QRhiBuffer* processUBO,
    QRhiBuffer* matUBO, std::span<const Sampler> samplers,
    std::span<QRhiShaderResourceBinding> additionalBindings = {});
 
SCORE_PLUGIN_GFX_EXPORT
void defaultPassesInit(
    PassMap& passes, const std::vector<Edge*>& edges, RenderList& renderer,
    const Mesh& mesh, const QShader& v, const QShader& f, QRhiBuffer* processUBO,
    QRhiBuffer* matUBO, std::span<const Sampler> samplers,
    const QRhiGraphicsPipeline::TargetBlend& blend,
    std::span<QRhiShaderResourceBinding> additionalBindings = {});
 
SCORE_PLUGIN_GFX_EXPORT
void defaultRenderPass(
    RenderList& renderer, const Mesh& mesh, const MeshBuffers& bufs,
    QRhiCommandBuffer& cb, Edge& edge, PassMap& passes);
 
SCORE_PLUGIN_GFX_EXPORT
void quadRenderPass(
    RenderList& renderer, const MeshBuffers& bufs, QRhiCommandBuffer& cb, Edge& edge,
    PassMap& passes);
 
class SCORE_PLUGIN_GFX_EXPORT GenericNodeRenderer : public score::gfx::NodeRenderer
{
public:
  GenericNodeRenderer(const NodeModel& node) noexcept
      : NodeRenderer{node}
  {
  }
 
  virtual ~GenericNodeRenderer() { }
 
  score::gfx::Port* imageOutlet() const noexcept;
 
  virtual std::span<const Sampler> samplersForOutputEdge(const Edge& edge) const noexcept
  {
    return m_samplers;
  }
 
  ossia::small_vector<Sampler, 8> m_samplers;
 
  QShader m_vertexS;
  QShader m_fragmentS;
 
  bool m_outputPremultiplied{false};
 
  // Pipeline
  PassMap m_p;
 
  // Per-renderer pipeline cache, keyed by the rp-desc's serializedFormat().
  // QRhi guarantees a pipeline can be used with any render target whose
  // rp-desc isCompatible with the pipeline's, and serializedFormat() is
  // documented as the in-memory comparison key for exactly that relation —
  // identical blobs ⇔ isCompatible. Keying by pointer instead would be
  // ABA-unsafe: a freshly allocated rp-desc can reuse the address of one
  // just destroyed, silently serving a pipeline built for a dead layout.
  //
  // Ownership: Pass::p.pipeline is NON-OWNING — the actual QRhiGraphicsPipeline
  // lives in this cache. Pass::p.srb is still per-edge and owned by the Pass.
  // GenericNodeRenderer::removeOutputPass and releaseState take care of
  // nulling Pass::p.pipeline before calling Pipeline::release() so it
  // does not try to deleteLater() a pointer we still own here.
  ossia::small_vector<
      std::pair<QVector<quint32>, QRhiGraphicsPipeline*>, 2>
      m_pipelineCache;
 
  // The vertex-binding plan every cached pipeline was built with. The cache
  // stores bare pipelines, so without this a hit would hand the Pass an empty
  // plan and the draw would bind the geometry's streams one-to-one against a
  // layout that was compacted.
  FallbackBindingPlan m_pipelinePlan;
 
  MeshBuffers m_meshbufs;
 
  QRhiBuffer* m_processUBO{};
 
  DefaultShaderMaterial m_material;
 
  const score::gfx::Mesh* m_mesh{};
 
  // Render loop
  void
  defaultMeshInit(RenderList& renderer, const Mesh& mesh, QRhiResourceUpdateBatch& res);
  void processUBOInit(RenderList& renderer);
  void defaultPassesInit(RenderList& renderer, const Mesh& mesh);
  void defaultPassesInit(
      RenderList& renderer, const Mesh& mesh, const QShader& v, const QShader& f,
      std::span<QRhiShaderResourceBinding> additionalBindings = {});
 
  void init(RenderList& renderer, QRhiResourceUpdateBatch& res) override;
 
  void initState(RenderList& renderer, QRhiResourceUpdateBatch& res) override;
  void releaseState(RenderList& renderer) override;
  void addOutputPass(
      RenderList& renderer, Edge& edge, QRhiResourceUpdateBatch& res) override;
  void removeOutputPass(RenderList& renderer, Edge& edge) override;
  bool hasOutputPassForEdge(Edge& edge) const override;
 
  void defaultUBOUpdate(RenderList& renderer, QRhiResourceUpdateBatch& res);
  void defaultMeshUpdate(RenderList& renderer, QRhiResourceUpdateBatch& res);
  void update(RenderList& renderer, QRhiResourceUpdateBatch& res, Edge* edge) override;
 
  void defaultRelease(RenderList&);
  void release(RenderList&) override;
 
  void defaultRenderPass(
      RenderList&, const Mesh& mesh, QRhiCommandBuffer& commands, Edge& edge);
 
  void defaultRenderPass(
      RenderList&, const Mesh& mesh, QRhiCommandBuffer& commands, Edge& edge,
      PassMap& passes);
 
  void runRenderPass(RenderList&, QRhiCommandBuffer& commands, Edge& edge) override;
 
  void updateInputTexture(const Port& input, QRhiTexture* tex, QRhiTexture* depthTex = nullptr) override;
};
 
}