GfxContext.hpp

#pragma once
#include <span>
#include <Process/Dataflow/CableData.hpp>
 
#include <Gfx/AssetTable.hpp>
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/RenderClock.hpp>
 
#include <score/tools/Timers.hpp>
 
#include <ossia/dataflow/nodes/media.hpp>
#include <ossia/dataflow/token_request.hpp>
#include <ossia/detail/buffer_pool.hpp>
#include <ossia/detail/flat_map.hpp>
#include <ossia/detail/flat_set.hpp>
#include <ossia/detail/hash_map.hpp>
#include <ossia/detail/mutex.hpp>
#include <ossia/detail/small_flat_map.hpp>
#include <ossia/detail/variant.hpp>
#include <ossia/gfx/port_index.hpp>
#include <ossia/network/value/value.hpp>
 
#include <concurrentqueue.h>
#include <score_plugin_gfx_export.h>
class QTimer;
namespace score {
class HighResolutionTimer;
class Timers;
}
struct QRhiReadbackResult;
namespace score::gfx
{
struct PreviewTap;
struct PreviewHubNode;
struct BackgroundNode;
struct Graph;
class OutputNode;
}
namespace score
{
struct DocumentContext;
}
namespace Gfx
{
using port_index = ossia::gfx::port_index;
struct EdgeSpec
{
  port_index first{};
  port_index second{};
  Process::CableType type{};
 
  // type takes part in identity: the exec thread republishes the full edge
  // set every tick and endTick dedups against prev_edges, so a comparison that
  // ignored the cable type would make an Immediate/Delayed flip invisible. As
  // it stands a type flip diffs as remove(old) + add(new) in the incremental
  // path.
  bool operator==(const EdgeSpec& other) const noexcept
  {
    return first == other.first && second == other.second && type == other.type;
  }
  bool operator!=(const EdgeSpec& other) const noexcept { return !(*this == other); }
  bool operator<(const EdgeSpec& other) const noexcept
  {
    if(first != other.first)
      return first < other.first;
    if(second != other.second)
      return second < other.second;
    return type < other.type;
  }
};
 
class GfxExecutionAction;
class SCORE_PLUGIN_GFX_EXPORT GfxContext : public QObject
{
  friend class GfxExecutionAction;
 
public:
  using NodePtr = std::unique_ptr<score::gfx::Node>;
 
  explicit GfxContext(const score::DocumentContext& ctx);
  ~GfxContext();
 
  int32_t register_node(NodePtr node);
  int32_t register_preview_node(std::unique_ptr<score::gfx::OutputNode> node);
  void connect_preview_node(EdgeSpec e);
  void disconnect_preview_node(EdgeSpec e);
  void unregister_node(int32_t idx);
  void unregister_preview_node(int32_t idx);
 
  int32_t add_preview(
      port_index producer, QSize size, std::shared_ptr<QRhiReadbackResult> readback);
  void set_preview_producer(int32_t id, port_index producer);
  void set_preview_size(int32_t id, QSize size);
  void remove_preview(int32_t id);
  bool preview_is_tapped(int32_t id) const noexcept;
  bool preview_is_on_hub(int32_t id) const noexcept;
  void want_preview_frame(int32_t id) const noexcept;
  static constexpr int max_preview_size = 1024;
 
  // Synchronously tear down an output node's render list and drop it from the
  // graph. Used by device-owned outputs (e.g. the offscreen BackgroundNode)
  // whose destructor runs during shutdown before the async node-command queue
  // is drained — without this the graph is left with a dangling output pointer
  // and a RenderList referencing an already-freed QRhi.
  void destroyOutput(score::gfx::OutputNode* node);
 
  std::span<score::gfx::OutputNode* const> outputs() const noexcept;
 
  void recompute_edges();
  void recompute_graph();
  void recompute_connections();
  void recomputeTimers();
  void recomputeGraphTopology();
  void incrementalEdgeUpdate(
      const ossia::flat_set<EdgeSpec>& old_edges,
      const ossia::flat_set<EdgeSpec>& cur_edges);
 
  void update_inputs();
  void updateGraph();
 
  void renderFrames(int frames);
 
  double stepRate() const noexcept { return m_stepRate; }
 
  void setStepRate(double fps);
 
  bool executionStepped() const noexcept;
 
  bool renderInProgress() const noexcept;
 
  void send_message(score::gfx::Message&& msg) noexcept
  {
    tick_messages.enqueue(std::move(msg));
  }
 
  AssetTable& assets() noexcept { return m_assets; }
  const AssetTable& assets() const noexcept { return m_assets; }
 
private:
  void updatePreviews();
  struct Preview
  {
    port_index producer{-1, -1};
    QSize size;
    std::shared_ptr<QRhiReadbackResult> readback;
    std::shared_ptr<score::gfx::PreviewTap> tap;
    int32_t tappedNode{-1};
    int hubInput{-1};
    port_index hubProducer{-1, -1};
    bool hubUnreadable{};
    int32_t fallbackId{-1};
    score::gfx::BackgroundNode* fallback{};
    port_index fallbackProducer{-1, -1};
  };
  bool joinPreviewHub(Preview& p);
  void releaseUnusedPreviewHub();
  void leavePreviewHub(Preview& p);
  void startPreviewFallback(Preview& p);
  void stopPreviewFallback(Preview& p);
  score::gfx::PreviewHubNode* m_previewHub{};
  int32_t m_previewHubId{-1};
  ossia::flat_map<int32_t, Preview> m_previews;
  int32_t m_nextPreview{1};
 
  void run_commands();
  void add_preview_output(score::gfx::OutputNode& out);
  void remove_preview_output();
  void add_edge(EdgeSpec e);
  void remove_edge(EdgeSpec e);
  void forgetDeferredEdge(const EdgeSpec& spec) noexcept;
  void remove_node(std::vector<std::unique_ptr<score::gfx::Node>>& nursery, int32_t id);
 
  void on_no_vsync_timer(score::HighResolutionTimer* self);
  void on_watchdog_timer(score::HighResolutionTimer* self);
 
  bool frameInProgress() const noexcept;
  bool refuseNestedRender(const char* entry) noexcept;
 
  const score::DocumentContext& m_context;
  std::atomic_int32_t index{1};
  ossia::hash_map<int32_t, NodePtr> nodes;
 
  score::gfx::Graph* m_graph{};
  QThread m_thread;
 
  double m_stepRate{60.};
  int64_t m_stepFrame{};
  int64_t m_stepPlayCount{-1};
 
  struct NodeCommand
  {
    enum
    {
      ADD_NODE,
      ADD_PREVIEW_NODE,
      REMOVE_NODE,
      REMOVE_PREVIEW_NODE,
      RELINK
    } cmd{};
    int32_t index{};
    std::unique_ptr<score::gfx::Node> node;
  };
 
  struct EdgeCommand
  {
    enum
    {
      CONNECT_PREVIEW_NODE,
      DISCONNECT_PREVIEW_NODE
    } cmd{};
    EdgeSpec edge;
  };
 
  using Command = ossia::variant<NodeCommand, EdgeCommand>;
  moodycamel::ConcurrentQueue<Command> tick_commands;
  moodycamel::ConcurrentQueue<score::gfx::Message> tick_messages;
  std::vector<std::pair<score::gfx::Message, int>> m_deferredMessages;
  std::vector<score::gfx::Message> m_drainedMessages;
  std::vector<std::pair<EdgeSpec, int>> m_deferredEdges;
 
  std::mutex m_disownedLock;
  ossia::flat_set<int32_t> m_disownedPending;
  bool isDisownedPending(int32_t index);
 
  std::mutex edges_lock;
  ossia::flat_set<EdgeSpec> new_edges TS_GUARDED_BY(edges_lock);
  ossia::flat_set<EdgeSpec> edges TS_GUARDED_BY(edges_lock);
  ossia::flat_set<EdgeSpec> preview_edges TS_GUARDED_BY(edges_lock);
  std::atomic_bool edges_changed{};
  bool m_fullRebuildThisFrame{};
 
  score::HighResolutionTimer* m_no_vsync_timer{};
  score::HighResolutionTimer* m_watchdog_timer{};
  // Rate == 0 with vsync off: zero-interval timer, renders back-to-back.
  QTimer* m_freewheel_timer{};
 
  // Per-output render clocks (the render-clock / genlock abstraction).
  // Each TimerClock owns one shared HighResolutionTimer at a given
  // manualRenderingRate and the coalesced set of outputs driven by it
  // (clock #2, the default); the single DisplayVSyncClock wraps the
  // swap-chain vsync callback (clock #1).
  std::vector<std::unique_ptr<score::gfx::TimerClock>> m_renderClocks;
  std::unique_ptr<score::gfx::DisplayVSyncClock> m_vsyncClock;
 
  ossia::object_pool<std::vector<score::gfx::gfx_input>> m_buffers;
 
  AssetTable m_assets;
 
  score::Timers m_timers;
 
  int m_renderDepth{};
  int m_nestedRenders{};
};
 
}