score-plugin-gfx/Gfx/Graph/Graph.hpp

#pragma once
#include <Process/Dataflow/CableData.hpp>
 
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/RenderList.hpp>
 
#include <ossia/detail/algorithms.hpp>
 
#include <score_plugin_gfx_export.h>
namespace Gfx
{
class AssetTable;
}
namespace score::gfx
{
class OutputNode;
class Window;
struct SCORE_PLUGIN_GFX_EXPORT Graph
{
  explicit Graph();
 
  ~Graph();
 
  void addNode(score::gfx::Node* n);
 
  void removeNode(score::gfx::Node* n);
 
  void addEdge(Port* source, Port* sink, Process::CableType t);
 
  void removeEdge(Port* source, Port* sink);
 
  Edge* findEdge(Port* source, Port* sink);
 
  void removeNodeFromRenderLists(Node* node);
 
  void removeNodeAndEdges(Node* node);
 
  void
  onEdgeRemoved(Edge& edge, const ossia::hash_set<const Port*>* preserveSinks = nullptr);
 
  void updateSinkSampler(Edge& edge);
 
  void createAllMissingPasses();
  void updateAllSinkSamplers();
 
  void createPassForEdgeIfMissing(Edge& edge);
 
  void reconcileAllRenderLists();
 
  void clearEdges();
 
  void createAllRenderLists(GraphicsApi graphicsApi);
 
  void createSingleRenderList(score::gfx::OutputNode& node, GraphicsApi graphicsApi);
 
  void destroyOutputRenderList(score::gfx::OutputNode& node);
 
  void releaseOutputRenderList(score::gfx::OutputNode& node);
 
  void relinkGraph();
 
  bool canDoVSync() const noexcept;
 
  void createMissingRenderLists();
 
  const std::vector<std::shared_ptr<RenderList>>& renderLists() const noexcept
  {
    return m_renderers;
  }
 
  std::span<OutputNode* const> outputs() const noexcept
  {
    return m_outputs;
  }
 
  void setAssetTable(Gfx::AssetTable* a) noexcept { m_assetTable = a; }
  Gfx::AssetTable* assetTable() const noexcept { return m_assetTable; }
 
private:
  void retopologicalSort(RenderList& rl);
 
  void initializeOutput(OutputNode* output, GraphicsApi graphicsApi);
  void createOutputRenderList(OutputNode& output);
  void recreateOutputRenderList(OutputNode& output);
  std::shared_ptr<RenderList>
  createRenderList(OutputNode*, std::shared_ptr<RenderState> state);
 
  std::vector<std::shared_ptr<RenderList>> m_renderers;
  std::vector<std::shared_ptr<Window>> m_unused_windows;
 
  std::vector<score::gfx::Node*> m_nodes;
  std::vector<Edge*> m_edges;
 
  std::vector<OutputNode*> m_outputs;
 
  // Session-wide decode cache. Non-owning; GfxContext owns the
  // actual AssetTable. May be null in tests or during teardown.
  Gfx::AssetTable* m_assetTable{};
};
}