GpuUtils.hpp

#pragma once
 
#include <avnd/introspection/gfx.hpp>
#if SCORE_PLUGIN_GFX
#include <Process/ExecutionContext.hpp>
 
#include <Crousti/File.hpp>
#include <Crousti/GppCoroutines.hpp>
#include <Crousti/GppShaders.hpp>
#include <Crousti/MessageBus.hpp>
#include <Crousti/SceneConcepts.hpp>
#include <Crousti/TextureConversion.hpp>
#include <Crousti/TextureFormat.hpp>
#include <Crousti/WorkerBinding.hpp>
#include <Gfx/GfxExecNode.hpp>
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/OutputNode.hpp>
#include <Gfx/Graph/RenderList.hpp>
#include <Gfx/Graph/RenderState.hpp>
 
#include <score/tools/ThreadPool.hpp>
 
#include <ossia/detail/hash_map.hpp>
#include <ossia/detail/lockfree_queue.hpp>
#include <ossia/detail/small_flat_map.hpp>
#include <ossia/detail/small_vector.hpp>
 
#include <ossia-qt/invoke.hpp>
 
#include <QCoreApplication>
#include <QTimer>
#include <QtGui/private/qrhi_p.h>
 
#include <avnd/binding/ossia/metadatas.hpp>
#include <avnd/binding/ossia/port_run_postprocess.hpp>
#include <avnd/binding/ossia/port_run_preprocess.hpp>
#include <avnd/binding/ossia/soundfiles.hpp>
#include <avnd/concepts/parameter.hpp>
#include <avnd/introspection/input.hpp>
#include <avnd/introspection/output.hpp>
#include <fmt/format.h>
#include <gpp/layout.hpp>
#include <halp/texture.hpp>
 
#include <score_plugin_avnd_export.h>
 
#include <algorithm>
#include <atomic>
 
namespace oscr
{
struct GpuWorker
{
  struct WorkerResults
  {
    struct Result
    {
      uint64_t order{};
      std::function<void()> apply;
    };
    ossia::mpmc_queue<Result> queue;
    std::atomic<uint64_t> pushed{};
    std::atomic<int> inflight{};
 
    void push(std::function<void()> f)
    {
      queue.enqueue(Result{pushed.fetch_add(1, std::memory_order_relaxed), std::move(f)});
    }
 
    void drain()
    {
      ossia::small_vector<Result, 4> batch;
      Result r;
      while(queue.try_dequeue(r))
        batch.push_back(std::move(r));
      std::ranges::sort(batch, {}, &Result::order);
      for(auto& res : batch)
        res.apply();
    }
 
    // Waits for the jobs in flight, and for those that the results applied
    // meanwhile requested.
    void settle()
    {
      for(;;)
      {
        for(int n = inflight.load(); n > 0; n = inflight.load())
          inflight.wait(n);
        if(queue.size_approx() == 0)
          return;
        drain();
      }
    }
  };
 
  struct Delivery
  {
    std::weak_ptr<WorkerResults> results;
 
    struct Job
    {
      std::weak_ptr<WorkerResults> results;
      explicit Job(std::weak_ptr<WorkerResults> r) noexcept
          : results{std::move(r)}
      {
        if(auto p = results.lock())
          p->inflight.fetch_add(1);
      }
      Job(Job&& other) noexcept = default;
      Job& operator=(Job&&) = delete;
      ~Job()
      {
        if(auto p = results.lock())
        {
          p->inflight.fetch_sub(1);
          p->inflight.notify_all();
        }
      }
 
      template <typename F>
      void operator()(F&& apply)
      {
        auto r = results.lock();
        if(!r)
          return;
        r->push(std::forward<F>(apply));
        ossia::qt::run_async(QCoreApplication::instance(), [wr = results] {
          if(auto r = wr.lock())
            r->drain();
        });
      }
    };
    Job begin() const noexcept { return Job{results}; }
  };
 
  void drainWorker(bool settle = false) const
  {
    if(!m_workerResults)
      return;
    if(settle)
      m_workerResults->settle();
    else
      m_workerResults->drain();
  }
 
  template <typename T>
  void initWorker(this auto& self, std::shared_ptr<T>& state) noexcept
  {
    if constexpr(avnd::has_worker<T>)
    {
      if(!self.m_workerResults)
        self.m_workerResults = std::make_shared<WorkerResults>();
 
      bind_worker(*state, std::weak_ptr{state}, Delivery{self.m_workerResults});
    }
  }
 
  mutable std::shared_ptr<WorkerResults> m_workerResults;
};
 
#if defined(OSCR_HAS_MMAP_FILE_STORAGE)
// The file ports keep string_views into the raw_file_data, and there is one
// object instance per renderer (one renderer per RenderList, that is per
// output) and per instance in CustomGpuRenderer. Storing the handles on the
// node would thus free, on every load, the memory that the ports of all the
// other instances still point to.
template <typename T>
struct GpuRendererFiles
{
  template <std::size_t N, std::size_t NField>
  void file_loaded(
      T& state, const std::shared_ptr<oscr::raw_file_data>& hdl,
      avnd::predicate_index<N> pred, avnd::field_index<NField> field)
  {
    m_rawfiles[&state].load(state, hdl, pred, field);
  }
 
  void releaseFiles() noexcept { m_rawfiles.clear(); }
 
private:
  ossia::hash_map<const T*, oscr::raw_file_storage<T>> m_rawfiles;
};
 
template <typename T>
  requires(avnd::raw_file_input_introspection<T>::size == 0)
struct GpuRendererFiles<T>
{
  void releaseFiles() noexcept { }
};
#else
template <typename T>
struct GpuRendererFiles
{
  void releaseFiles() noexcept { }
};
#endif
 
struct SCORE_PLUGIN_AVND_EXPORT GpuMessageState
{
  score::gfx::Message message;
  std::vector<uint32_t> generation;
 
  void process(score::gfx::Message&& msg) noexcept;
};
 
template <typename GpuNodeRenderer, typename Node>
struct GpuProcessIns
{
  GpuProcessIns(
      GpuNodeRenderer& gpu, Node& state, const GpuMessageState& prev,
      const GpuMessageState& cur, const score::DocumentContext& ctx) noexcept
      : gpu{gpu}
      , state{state}
      , prev_mess{prev.message}
      , mess{cur.message}
      , prev_gen{prev.generation}
      , gen{cur.generation}
      , ctx{ctx}
  {
  }
 
  GpuNodeRenderer& gpu;
  Node& state;
  const score::gfx::Message& prev_mess;
  const score::gfx::Message& mess;
  const std::vector<uint32_t>& prev_gen;
  const std::vector<uint32_t>& gen;
  const score::DocumentContext& ctx;
 
  bool can_process_message(std::size_t N)
  {
    if(mess.input.size() <= N)
      return false;
 
    if(prev_mess.input.size() == mess.input.size())
    {
      auto& prev = prev_mess.input[N];
      auto& next = mess.input[N];
      if(prev.index() == 1 && next.index() == 1)
      {
        if(ossia::get<ossia::value>(prev) == ossia::get<ossia::value>(next))
        {
          return false;
        }
      }
    }
    return true;
  }
 
  // The node's message keeps the last value of every input, so the one-shot values in it are
  // applied once per arrival rather than once per value: a bang equal to the previous one is a
  // new event, the same one still sitting in the message is not.
  bool received_event(std::size_t N) const noexcept
  {
    if(mess.input.size() <= N || gen.size() <= N)
      return false;
    return prev_gen.size() <= N || prev_gen[N] != gen[N];
  }
 
  template <avnd::parameter_port Field, std::size_t NField>
  void operator()(Field& t, avnd::field_index<NField> field_index)
  {
    if constexpr(avnd::optional_ish<decltype(Field::value)>)
    {
      // Mirrors the CPU path, which sees each port's data stream once per tick.
      if(!received_event(NField))
        return;
    }
    else if(!can_process_message(field_index))
    {
      return;
    }
 
    if(auto val = ossia::get_if<ossia::value>(&mess.input[field_index]))
    {
      oscr::from_ossia_value(t, *val, t.value);
      if_possible(t.update(state));
    }
  }
 
#if OSCR_HAS_MMAP_FILE_STORAGE
  template <avnd::raw_file_port Field, std::size_t NField>
  void operator()(Field& t, avnd::field_index<NField> field_index)
  {
    // FIXME we should be loading a file there
    using file_ports = avnd::raw_file_input_introspection<Node>;
 
    if(!can_process_message(field_index))
      return;
 
    auto val = ossia::get_if<ossia::value>(&mess.input[field_index]);
    if(!val)
      return;
 
    static constexpr bool has_text = requires { decltype(Field::file)::text; };
    static constexpr bool has_mmap = requires { decltype(Field::file)::mmap; };
 
    // First we can load it directly since execution hasn't started yet
    if(auto hdl = loadRawfile(*val, ctx, has_text, has_mmap))
    {
      static constexpr auto N = file_ports::field_index_to_index(NField);
      if constexpr(avnd::port_can_process<Field>)
      {
        // FIXME also do it when we get a run-time message from the exec engine,
        // OSC, etc
        auto func = executePortPreprocess<Field>(*hdl);
        gpu.file_loaded(
            state, hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
        if(func)
          func(state);
      }
      else
      {
        gpu.file_loaded(
            state, hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
      }
    }
  }
#endif
 
  template <avnd::buffer_port Field, std::size_t NField>
  void operator()(Field& t, avnd::field_index<NField> field_index)
  {
    if(!can_process_message(field_index))
      return;
 
    using node_type = std::remove_cvref_t<decltype(gpu.node())>;
    auto& node = const_cast<node_type&>(gpu.node());
    if(field_index >= mess.input.size())
      return;
    auto val = ossia::get_if<ossia::render_target_spec>(&mess.input[field_index]);
    if(!val)
      return;
    static_cast<score::gfx::Node&>(node).process(int32_t(NField), *val);
  }
 
  template <avnd::texture_port Field, std::size_t NField>
  void operator()(Field& t, avnd::field_index<NField> field_index)
  {
    if(!can_process_message(field_index))
      return;
 
    using node_type = std::remove_cvref_t<decltype(gpu.node())>;
    auto& node = const_cast<node_type&>(gpu.node());
    if(field_index >= mess.input.size())
      return;
    auto val = ossia::get_if<ossia::render_target_spec>(&mess.input[field_index]);
    if(!val)
      return;
    static_cast<score::gfx::Node&>(node).process(int32_t(NField), *val);
  }
 
  template <avnd::geometry_port Field, std::size_t NField>
  void operator()(Field& t, avnd::field_index<NField> field_index)
  {
    // Intentional no-op: geometry is not in the control message, it flows
    // through geometry_inputs_storage::readInputGeometries. The empty body
    // keeps GpuProcessIns instantiable for nodes whose input list contains
    // geometry fields, which would otherwise hit the `= delete` catch-all
    // below.
  }
 
  template <scene_port Field, std::size_t NField>
  void operator()(Field& t, avnd::field_index<NField> field_index)
  {
    // Intentional no-op — same reasoning as the geometry_port overload above.
    // Scene data flows through scene_inputs_storage / scene_outputs_storage.
  }
 
  void operator()(auto& t, auto field_index) = delete;
};
 
struct GpuControlIns
{
  template <typename Self, typename Node_T>
  static void processControlIn(
      Self& self, Node_T& state, GpuMessageState& renderer_mess,
      const GpuMessageState& mess, const score::DocumentContext& ctx) noexcept
  {
    // Apply the controls
    avnd::input_introspection<Node_T>::for_all_n(
        avnd::get_inputs<Node_T>(state),
        GpuProcessIns<Self, Node_T>{self, state, renderer_mess, mess, ctx});
    renderer_mess = mess;
  }
 
  // Once the processor has run, the impulses and other one-shot values it received this tick are
  // consumed, exactly as oscr::process_after_run does on the CPU path. Without this an impulse
  // would stay set until the next message touches the port.
  template <typename Node_T>
  static void clearControlIn(Node_T& state) noexcept
  {
    avnd::parameter_input_introspection<Node_T>::for_all(
        avnd::get_inputs<Node_T>(state), []<typename Field>(Field& t) {
          if constexpr(avnd::optional_ish<decltype(Field::value)>)
            t.value.reset();
        });
  }
};
 
struct GpuControlOuts
{
  std::weak_ptr<Execution::ExecutionCommandQueue> queue;
  Gfx::exec_controls control_outs;
 
  int64_t instance{};
 
  template <typename Node_T>
  void processControlOut(Node_T& state) const noexcept
  {
    if(!this->control_outs.empty())
    {
      auto q = this->queue.lock();
      if(!q)
        return;
      auto& qq = *q;
      int parm_k = 0;
      avnd::parameter_output_introspection<Node_T>::for_all(
          avnd::get_outputs(state), [&]<avnd::parameter_port T>(const T& t) {
            qq.enqueue([v = oscr::to_ossia_value(t, t.value),
                        port = control_outs[parm_k]]() mutable {
              std::swap(port->value, v);
              port->changed = true;
            });
 
            parm_k++;
          });
    }
  }
};
 
template <typename T>
struct SCORE_PLUGIN_AVND_EXPORT GpuNodeElements
{
  [[no_unique_address]] oscr::soundfile_storage<T> soundfiles;
 
  [[no_unique_address]] oscr::midifile_storage<T> midifiles;
 
  // Raw file handles are stored per-state in the renderers, see GpuRendererFiles
};
 
struct SCORE_PLUGIN_AVND_EXPORT CustomGfxNodeBase : score::gfx::NodeModel
{
  explicit CustomGfxNodeBase(const score::DocumentContext& ctx)
      : score::gfx::NodeModel{}
      , m_ctx{ctx}
  {
  }
  virtual ~CustomGfxNodeBase();
  const score::DocumentContext& m_ctx;
  GpuMessageState last_message;
  void process(score::gfx::Message&& msg) override;
  using score::gfx::NodeModel::process;
};
struct SCORE_PLUGIN_AVND_EXPORT CustomGfxOutputNodeBase : score::gfx::OutputNode
{
  virtual ~CustomGfxOutputNodeBase();
 
  GpuMessageState last_message;
  void process(score::gfx::Message&& msg) override;
};
struct SCORE_PLUGIN_AVND_EXPORT CustomGpuNodeBase
    : score::gfx::Node
    , GpuWorker
    , GpuControlIns
    , GpuControlOuts
{
  CustomGpuNodeBase(
      std::weak_ptr<Execution::ExecutionCommandQueue>&& q, Gfx::exec_controls&& ctls,
      const score::DocumentContext& ctx)
      : GpuControlOuts{std::move(q), std::move(ctls)}
      , m_ctx{ctx}
  {
  }
 
  virtual ~CustomGpuNodeBase() = default;
 
  const score::DocumentContext& m_ctx;
  QString vertex, fragment, compute;
  GpuMessageState last_message;
  void process(score::gfx::Message&& msg) override;
};
 
struct SCORE_PLUGIN_AVND_EXPORT CustomGpuOutputNodeBase
    : score::gfx::OutputNode
    , GpuWorker
    , GpuControlIns
    , GpuControlOuts
{
  static constexpr QSize defaultRenderSize{200, 200};
 
  CustomGpuOutputNodeBase(
      std::weak_ptr<Execution::ExecutionCommandQueue> q, Gfx::exec_controls&& ctls,
      const score::DocumentContext& ctx);
  virtual ~CustomGpuOutputNodeBase();
 
  const score::DocumentContext& m_ctx;
  std::weak_ptr<score::gfx::RenderList> m_renderer{};
  std::shared_ptr<score::gfx::RenderState> m_renderState{};
 
  QString vertex, fragment, compute;
  GpuMessageState last_message;
  void process(score::gfx::Message&& msg) override;
  using score::gfx::Node::process;
 
  void setRenderer(std::shared_ptr<score::gfx::RenderList>) override;
  score::gfx::RenderList* renderer() const override;
 
  void startRendering() override;
  void render() override;
  void stopRendering() override;
  bool canRender() const override;
  void onRendererChange() override;
 
  void createOutput(score::gfx::OutputConfiguration) override;
 
  void destroyOutput() override;
  std::shared_ptr<score::gfx::RenderState> renderState() const override;
 
  Configuration configuration() const noexcept override;
};
 
template <typename Node_T, typename Node>
void prepareNewState(std::shared_ptr<Node_T>& eff, const Node& parent)
{
  if constexpr(avnd::has_worker<Node_T>)
  {
    parent.initWorker(eff);
  }
  if constexpr(avnd::has_processor_to_gui_bus<Node_T>)
  {
    auto& process = parent.processModel;
    eff->send_message = [ptr = QPointer{&process}](auto&& b) mutable {
      // FIXME right now all the rendering is done in the UI thread, which is very MEH
      //    this->in_edit([&process, bb = std::move(b)]() mutable {
 
      if(ptr && ptr->to_ui)
        MessageBusSender{ptr->to_ui}(std::move(b));
      //    });
    };
 
    // FIXME GUI -> engine. See executor.hpp
  }
 
  avnd::init_controls(*eff);
 
  if constexpr(avnd::can_prepare<Node_T>)
  {
    if constexpr(avnd::function_reflection<&Node_T::prepare>::count == 1)
    {
      using prepare_type = avnd::first_argument<&Node_T::prepare>;
      prepare_type t;
      if_possible(t.instance = parent.instance);
      eff->prepare(t);
    }
    else
    {
      eff->prepare();
    }
  }
}
 
struct port_to_type_enum
{
  template <std::size_t I, avnd::buffer_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Buffer;
  }
 
  template <std::size_t I, avnd::cpu_texture_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    using texture_type = std::remove_cvref_t<decltype(F::texture)>;
    return (avnd::cpu_fixed_format_texture<texture_type> || avnd::cpu_dynamic_format_texture<texture_type>)
               ? score::gfx::Types::Image
               : score::gfx::Types::Buffer;
  }
 
  template <std::size_t I, avnd::gpu_texture_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Image;
  }
 
  template <std::size_t I, avnd::sampler_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Image;
  }
  template <std::size_t I, avnd::image_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Image;
  }
  template <std::size_t I, avnd::attachment_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Image;
  }
  template <std::size_t I, avnd::gpu_render_target_output_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Image;
  }
 
  template <std::size_t I, avnd::geometry_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Geometry;
  }
  // Scene ports reuse Types::Geometry — a scene is a richer form of geometry.
  template <std::size_t I, scene_port F>
    requires(!avnd::geometry_port<F>)
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Geometry;
  }
  template <std::size_t I, avnd::mono_audio_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Audio;
  }
  template <std::size_t I, avnd::poly_audio_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Audio;
  }
  template <std::size_t I, avnd::int_parameter F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Int;
  }
  template <std::size_t I, avnd::enum_parameter F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Int;
  }
  template <std::size_t I, avnd::float_parameter F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Float;
  }
  template <std::size_t I, avnd::parameter_port F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    using value_type = std::remove_cvref_t<decltype(F::value)>;
 
    if constexpr(std::is_array_v<value_type>)
    {
      static constexpr int sz = sizeof(value_type) / sizeof(value_type{}[0]);
      if constexpr(sz == 2)
      {
        return score::gfx::Types::Vec2;
      }
      else if constexpr(sz == 3)
      {
        return score::gfx::Types::Vec3;
      }
      else if constexpr(sz == 4)
      {
        return score::gfx::Types::Vec4;
      }
    }
    else if constexpr(std::is_aggregate_v<value_type>)
    {
      static constexpr int sz = avnd::pfr::tuple_size_v<value_type>;
      if constexpr(sz == 2)
      {
        return score::gfx::Types::Vec2;
      }
      else if constexpr(sz == 3)
      {
        return score::gfx::Types::Vec3;
      }
      else if constexpr(sz == 4)
      {
        return score::gfx::Types::Vec4;
      }
    }
    return score::gfx::Types::Empty;
  }
  template <std::size_t I, typename F>
  constexpr auto operator()(avnd::field_reflection<I, F> p)
  {
    return score::gfx::Types::Empty;
  }
};
 
// Compile-time port flags derived from a field's declarative metadata.
// Inspects:
//   - `texture_target` (texture_kind_of) — non-2D textures bypass the
//     local-RT allocation and grab the upstream texture directly.
//   - `samplable_depth` (samplable_depth_of) — opt-in to having the
//     framework allocate a sampleable depth attachment on the producing
//     edge's RT and expose its handle through `texture.depth_handle`,
//     mirroring the semantics CSF/ISF shaders get via "DEPTH": true.
template <typename Field>
constexpr score::gfx::Flag port_flags_for_field() noexcept
{
  if constexpr(avnd::gpu_texture_port<Field>)
  {
    constexpr auto kind = halp::texture_kind_of<Field>();
    constexpr bool nonD2 = (kind != halp::texture_kind::texture_2d);
    constexpr bool depth = halp::samplable_depth_of<Field>();
    static_assert(
        !(single_cable_port<Field> && (depth || nonD2)),
        "single_cable is only supported on 2D texture inputs without depth");
    if constexpr(single_cable_port<Field>)
      return score::gfx::Flag::SingleCable;
    else if constexpr(nonD2 && depth)
      return score::gfx::Flag::GrabsFromSource | score::gfx::Flag::SamplableDepth;
    else if constexpr(nonD2)
      return score::gfx::Flag::GrabsFromSource;
    else if constexpr(depth)
      return score::gfx::Flag::SamplableDepth;
  }
  return score::gfx::Flag{};
}
 
// Map QRhi's depth-format taxonomy onto halp's depth_format_t.
// The 4-arg subset matches every depth format score's createRenderTarget
// can produce (today always D32F, but the API accepts the others).
inline constexpr halp::gpu_texture::depth_format_t qrhiToHalpDepthFormat(
    QRhiTexture::Format f) noexcept
{
  using D = halp::gpu_texture::depth_format_t;
  switch(f)
  {
    case QRhiTexture::D16:   return D::D16;
    case QRhiTexture::D24:   return D::D24;
    case QRhiTexture::D24S8: return D::D24S8;
    case QRhiTexture::D32F:  return D::D32F;
    default: break;
  }
  return D::D32F;
}
 
template <typename Node_T>
inline void initGfxPorts(auto* self, auto& input, auto& output)
{
  avnd::input_introspection<Node_T>::for_all(
      [self, &input]<typename Field, std::size_t I>(avnd::field_reflection<I, Field> f) {
    static constexpr auto type = port_to_type_enum{}(f);
    static constexpr auto flags = port_flags_for_field<Field>();
    input.push_back(new score::gfx::Port{self, {}, type, flags, {}});
  });
  avnd::output_introspection<Node_T>::for_all(
      [self,
       &output]<typename Field, std::size_t I>(avnd::field_reflection<I, Field> f) {
    static constexpr auto type = port_to_type_enum{}(f);
    // port_flags_for_field encodes INPUT-side sink semantics
    // (GrabsFromSource → "sample the upstream's texture directly";
    // SamplableDepth → "ask the producer for a sampleable depth
    // attachment"). Neither has any meaning on an OUTPUT port — emitting
    // them here would make the graph treat this node's own output as if it
    // grabbed from / sampled some upstream source. Outputs carry no such
    // flags.
    output.push_back(new score::gfx::Port{self, {}, type, score::gfx::Flag{}, {}});
  });
}
 
static score::gfx::BufferView getInputBuffer(
    score::gfx::RenderList& renderer, const score::gfx::Node& parent, int port_index)
{
  const auto& inputs = parent.input;
  // SCORE_ASSERT(port_index == 0);
  {
    score::gfx::Port* p = inputs[port_index];
    for(auto& edge : p->edges)
    {
      auto src_node = edge->source->node;
      score::gfx::NodeRenderer* src_renderer = src_node->renderedNodes.at(&renderer);
      if(src_renderer)
      {
        return src_renderer->bufferForOutput(*edge->source);
      }
      break;
    }
  }
  return {};
}
 
 
static void readbackInputBuffer(
    score::gfx::RenderList& renderer
    , QRhiResourceUpdateBatch& res
    , const score::gfx::Node& parent
    , QRhiBufferReadbackResult& readback
    , int port_index
    )
{
  // FIXME: instead of doing this we could do the readback in the
  // producer node and just read its bytearray once...
  if(auto buf = getInputBuffer(renderer, parent, port_index))
  {
    readback = {};
    res.readBackBuffer(buf.handle, buf.byte_offset, buf.byte_size, &readback);
  }
}
 
static void recreateOutputBuffer(
    score::gfx::RenderList& renderer, avnd::cpu_buffer auto& cpu_buf,
    QRhiResourceUpdateBatch& res, score::gfx::BufferView& buf)
{
  const auto bytesize = avnd::get_bytesize(cpu_buf);
  if(!buf.handle)
  {
    if(bytesize > 0)
    {
      buf.handle = renderer.state.rhi->newBuffer(
          QRhiBuffer::Static,
              score::gfx::compatibleBufferUsage(
                  *renderer.state.rhi,
                  QRhiBuffer::StorageBuffer | QRhiBuffer::VertexBuffer),
          bytesize);
      buf.handle->setName("GpuUtils::recreateOutputBuffer");
      buf.byte_offset = 0;
      buf.byte_size = bytesize;
 
      buf.handle->create();
    }
    else
    {
      cpu_buf.changed = false;
      return;
    }
  }
  else if(buf.handle->size() != bytesize)
  {
    buf.handle->destroy();
    buf.handle->setSize(bytesize);
    buf.handle->create();
    buf.byte_size = bytesize;
  }
}
 
static void uploadOutputBuffer(
    score::gfx::RenderList& renderer, avnd::cpu_buffer auto& cpu_buf,
    QRhiResourceUpdateBatch& res, score::gfx::BufferView& rhi_buf)
{
  if(cpu_buf.changed)
  {
    recreateOutputBuffer(renderer, cpu_buf, res, rhi_buf);
    score::gfx::uploadStaticBufferWithStoredData(
        &res, rhi_buf.handle, 0, cpu_buf.byte_size,
        (const char*)avnd::get_bytes(cpu_buf));
    cpu_buf.changed = false;
  }
}
 
static void uploadOutputBuffer(
    score::gfx::RenderList& renderer, avnd::gpu_buffer auto& gpu_buf,
    QRhiResourceUpdateBatch& res, score::gfx::BufferView& rhi_buf)
{
  rhi_buf.handle = reinterpret_cast<QRhiBuffer*>(gpu_buf.handle);
  rhi_buf.byte_size = gpu_buf.byte_size;
  rhi_buf.byte_offset = gpu_buf.byte_offset;
}
 
template <typename T>
struct geometry_inputs_storage;
 
struct mesh_input_storage
{
  std::vector<QRhiBufferReadbackResult> readbacks;
  std::vector<QRhiBuffer*> buffers;
};
struct geometry_input_storage
{
  ossia::geometry_spec spec;
  std::vector<mesh_input_storage> meshes;
};
 
template <typename T>
  requires(avnd::geometry_input_introspection<T>::size > 0)
struct geometry_inputs_storage<T>
{
  // FIXME in Gfx/Graph/NodeRenderer.hpp
  static_assert(avnd::geometry_input_introspection<T>::size == 1);
 
  geometry_input_storage inputs[avnd::geometry_input_introspection<T>::size];
  ossia::small_vector<QRhiBuffer*, 4> allocated;
 
  struct pending_transform
  {
    ossia::transform3d value;
    bool dirty{};
  };
  pending_transform transforms[avnd::geometry_input_introspection<T>::size];
 
  void setTransform(int32_t port, const ossia::transform3d& v, auto& state)
  {
    avnd::geometry_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(state),
        [&]<typename Field, std::size_t N, std::size_t NField>(
            Field&, avnd::predicate_index<N>, avnd::field_index<NField>) {
      if(int32_t(NField) == port)
        transforms[N] = {v, true};
    });
  }
 
  void readInputGeometries(
      score::gfx::RenderList& renderer, const ossia::geometry_spec& spec, auto& parent,
      auto& state)
  {
    // Copy the readback output inside the structure
    // TODO it would be much better to do this inside the readback's
    // "completed" callback.
    avnd::geometry_input_introspection<T>::for_all_n(
        avnd::get_inputs<T>(state),
        [&]<typename Field, std::size_t N>(Field& t, avnd::predicate_index<N> np) {
      this->inputs[N].spec = spec;      // FIXME multiple geometry input ports
      this->inputs[N].meshes.resize(1); // FIXME
 
      // Here we fetch the readbacks results
      auto& meshes = this->inputs[N].meshes[0];
 
      oscr::meshes_from_ossia(
          spec.meshes, t.mesh,
          [&](auto& write_buf, int buffer_index, void* data, int64_t bytesize) {
        // CPU input geometry, upload was done before
        SCORE_ASSERT(buffer_index >= 0);
        if(buffer_index < meshes.readbacks.size())
        {
          QRhiBuffer* handle = meshes.buffers[buffer_index];
          write_buf.handle = handle;
          write_buf.byte_size = handle->size();
        }
      }, [&](auto& write_buf, int buffer_index, void* handle) {
        // GPU input buffer, CPU output buffer: need to fetch our readback
        SCORE_ASSERT(buffer_index >= 0);
        if(buffer_index < meshes.readbacks.size())
        {
          // FIXME investigate why runInitialPasses is called before inputAboutToFinish
          auto& readback = meshes.readbacks[buffer_index].data;
          write_buf.raw_data = reinterpret_cast<unsigned char*>(readback.data());
          write_buf.byte_size = readback.size();
        }
      });
 
      if constexpr(requires {
                     t.transform[0];
                     t.dirty_transform;
                   })
      {
        auto& pending = transforms[N];
        if(pending.dirty)
        {
          static_assert(std::extent_v<std::remove_cvref_t<decltype(t.transform)>> == 16);
          std::copy_n(pending.value.matrix, 16, t.transform);
          pending.dirty = false;
          t.dirty_transform = true;
        }
        else
        {
          t.dirty_transform = false;
        }
      }
 
      if constexpr(requires { t.mesh.buffers[0].handle; })
      {
        if(spec.meshes && !spec.meshes->meshes.empty())
        {
          const auto& src = spec.meshes->meshes[0].buffers;
          const std::size_t n
              = std::min({src.size(), t.mesh.buffers.size(), meshes.buffers.size()});
          for(std::size_t i = 0; i < n; i++)
          {
            if(!ossia::get_if<ossia::geometry::cpu_buffer>(&src[i].data))
              continue;
            if(QRhiBuffer* handle = meshes.buffers[i])
            {
              t.mesh.buffers[i].handle = handle;
              t.mesh.buffers[i].byte_size = handle->size();
            }
          }
        }
      }
    });
  }
 
  void inputAboutToFinish(
      score::gfx::RenderList& renderer, QRhiResourceUpdateBatch*& res,
      const ossia::geometry_spec& spec, auto& state, auto& parent)
  {
    avnd::geometry_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(state),
        [&]<typename Field, std::size_t N, std::size_t NField>(
            Field& t, avnd::predicate_index<N> np, avnd::field_index<NField> nf) {
      this->inputs[N].spec = spec;      // FIXME multiple geometry input ports
      this->inputs[N].meshes.resize(1); // FIXME
      // Here we request readbacks if necessary
 
      auto& meshes = this->inputs[N].meshes[0];
      auto upload = [&](int buffer_index, const void* data, int64_t bytesize) {
        if(meshes.buffers.size() <= std::size_t(buffer_index))
        {
          meshes.buffers.resize(buffer_index + 1);
          meshes.readbacks.resize(buffer_index + 1);
        }
        QRhiBuffer*& buf = meshes.buffers[buffer_index];
        if(!buf || !ossia::contains(allocated, buf))
        {
          buf = renderer.state.rhi->newBuffer(
              QRhiBuffer::Static,
              score::gfx::compatibleBufferUsage(
                  *renderer.state.rhi,
                  QRhiBuffer::StorageBuffer | QRhiBuffer::VertexBuffer),
              bytesize);
          buf->setName(oscr::getUtf8Name<T>() + "::" + oscr::getUtf8Name(t));
          buf->create();
          allocated.push_back(buf);
        }
        else if(buf->size() < bytesize)
        {
          // Buffer exists but is too small — resize it.
          buf->setSize(bytesize);
          buf->create();
        }
 
        res->uploadStaticBuffer(buf, 0, bytesize, data);
      };
      oscr::meshes_from_ossia(
          spec.meshes, t.mesh,
          [&](auto& write_buf, int buffer_index, void* data, int64_t bytesize) {
        // cpu -> gpu
        upload(buffer_index, data, bytesize);
      }, [&](auto& write_buf, int buffer_index, void* handle) {
        // gpu -> cpu
        if(meshes.readbacks.size() <= buffer_index)
        {
          meshes.buffers.resize(buffer_index + 1);
          meshes.readbacks.resize(buffer_index + 1);
        }
 
        meshes.readbacks[buffer_index] = {};
        if(auto buf = static_cast<QRhiBuffer*>(handle))
        {
          meshes.buffers[buffer_index] = buf;
          res->readBackBuffer(buf, 0, buf->size(), &meshes.readbacks[buffer_index]);
        }
        else
        {
          meshes.buffers[buffer_index] = {};
          meshes.readbacks[buffer_index] = {};
        }
      });
 
      // A CPU buffer is flagged dirty only on the frame it changed: a consumer
      // that first sees it later (inserted into a running graph, or rebuilt)
      // still has to upload it once.
      if constexpr(requires { t.mesh.buffers[0].handle; })
      {
        if(spec.meshes && !spec.meshes->meshes.empty())
        {
          const auto& src = spec.meshes->meshes[0].buffers;
          for(std::size_t i = 0; i < src.size(); i++)
          {
            auto* cpu = ossia::get_if<ossia::geometry::cpu_buffer>(&src[i].data);
            if(!cpu || !cpu->raw_data || cpu->byte_size <= 0)
              continue;
            if(i < meshes.buffers.size() && meshes.buffers[i]
               && ossia::contains(allocated, meshes.buffers[i]))
              continue;
            upload(int(i), cpu->raw_data.get(), cpu->byte_size);
          }
        }
      }
    });
  }
 
  void release(score::gfx::RenderList& renderer)
  {
    for(auto& buf : allocated)
      renderer.releaseBuffer(buf);
    allocated.clear();
    for(auto& in : inputs)
      in.meshes.clear();
  }
};
 
template <typename T>
  requires(avnd::geometry_input_introspection<T>::size == 0)
struct geometry_inputs_storage<T>
{
  static void readInputGeometries(auto&&...) { }
 
  static void inputAboutToFinish(auto&&...) { }
 
  static void release(auto&&...) { }
};
 
template<typename T>
struct buffer_inputs_storage;
 
template<typename T>
  requires (avnd::buffer_input_introspection<T>::size > 0)
struct buffer_inputs_storage<T>
{
  // +1 because of zero-array-size unsupported
  QRhiBufferReadbackResult
      m_readbacks[avnd::cpu_buffer_input_introspection<T>::size + 1];
  score::gfx::BufferView m_gpubufs[avnd::gpu_buffer_input_introspection<T>::size + 1];
 
  void readInputBuffers(
      score::gfx::RenderList& renderer, auto& parent, auto& state)
  {
    if constexpr(avnd::cpu_buffer_input_introspection<T>::size > 0)
    {
      // Copy the readback output inside the structure
      // TODO it would be much better to do this inside the readback's
      // "completed" callback.
      avnd::cpu_buffer_input_introspection<T>::for_all_n(
          avnd::get_inputs<T>(state),
          [&]<typename Field, std::size_t N>
          (Field& t, avnd::predicate_index<N> np)
      {
        auto& readback = m_readbacks[N].data;
        t.buffer.raw_data = reinterpret_cast<unsigned char*>(readback.data());
        t.buffer.byte_size = readback.size();
        t.buffer.byte_offset = 0; // FIXME
        t.buffer.changed = true;
      });
    }
 
    if constexpr(avnd::gpu_buffer_input_introspection<T>::size > 0)
    {
      // Copy the readback output inside the structure
      // TODO it would be much better to do this inside the readback's
      // "completed" callback.
      avnd::gpu_buffer_input_introspection<T>::for_all_n2(
          avnd::get_inputs<T>(state),
          [&]<typename Field, std::size_t N, std::size_t NField>(
              Field& t, avnd::predicate_index<N> np, avnd::field_index<NField> nf) {
        score::gfx::BufferView& buf = m_gpubufs[N];
        if(!buf)
          buf = getInputBuffer(renderer, parent, nf);
        if(!buf)
          return;
        t.buffer.handle = buf.handle;
        t.buffer.byte_size = buf.byte_size;
        t.buffer.byte_offset = buf.byte_offset;
        // t.buffer.changed = true; FIXME
      });
    }
  }
 
  void inputAboutToFinish(
      score::gfx::RenderList& renderer,
      QRhiResourceUpdateBatch*& res,
      auto& state,
      auto& parent)
  {
    avnd::cpu_buffer_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(state),
        [&]<typename Field, std::size_t N, std::size_t NField>
        (Field& port, avnd::predicate_index<N> np, avnd::field_index<NField> nf) {
      readbackInputBuffer(renderer, *res, parent, m_readbacks[N], nf);
    });
    avnd::gpu_buffer_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(state),
        [&]<typename Field, std::size_t N, std::size_t NField>
        (Field& port, avnd::predicate_index<N> np, avnd::field_index<NField> nf) {
      m_gpubufs[N] = getInputBuffer(renderer, parent, nf);
    });
  }
};
 
template<typename T>
  requires (avnd::buffer_input_introspection<T>::size == 0)
struct buffer_inputs_storage<T>
{
  static void readInputBuffers(auto&&...)
  {
 
  }
 
  static void inputAboutToFinish(auto&&...)
  {
 
  }
};
 
struct MaybeOwnedBuffer : score::gfx::BufferView
{
  bool owned{false};
};
 
template<typename T>
struct buffer_outputs_storage;
 
template<typename T>
  requires (avnd::buffer_output_introspection<T>::size > 0)
struct buffer_outputs_storage<T>
{
  std::pair<const score::gfx::Port*, MaybeOwnedBuffer>
      m_buffers[avnd::buffer_output_introspection<T>::size];
 
  QRhiResourceUpdateBatch* currentResourceUpdateBatch{};
 
  score::gfx::RenderList* m_renderer{};
 
  template <typename Field, std::size_t N, std::size_t NField>
    requires avnd::cpu_buffer<std::decay_t<decltype(Field::buffer)>>
  void createOutput(
      score::gfx::RenderList& renderer, auto& parent, Field& port,
      avnd::predicate_index<N> np, avnd::field_index<NField> nf)
  {
    auto& [gfx_port, buf] = m_buffers[N];
    gfx_port = parent.output[nf];
    buf.handle = renderer.state.rhi->newBuffer(
        QRhiBuffer::Static,
              score::gfx::compatibleBufferUsage(
                  *renderer.state.rhi,
                  QRhiBuffer::StorageBuffer | QRhiBuffer::VertexBuffer), 1);
    buf.handle->setName(oscr::getUtf8Name<T>() + "::" + oscr::getUtf8Name(port));
    buf.byte_offset = 0;
    buf.byte_size = 1;
    buf.owned = true;
 
    buf.handle->create();
 
    m_renderer = &renderer;
    bindUpload(port, np);
  }
 
  template <typename Field, std::size_t N>
  void bindUpload(Field& port, avnd::predicate_index<N>)
  {
    port.buffer.upload
        = [this, &port](const char* data, int64_t offset, int64_t bytesize) {
      // FIXME is offset and bytesize relative to the input or the output data ?
      SCORE_ASSERT(currentResourceUpdateBatch);
      SCORE_ASSERT(m_renderer);
      auto& rhi = *m_renderer->state.rhi;
      auto& [gfx_port, buf] = m_buffers[N];
 
      if(!buf.handle)
      {
        if(bytesize > 0)
        {
          buf.handle = rhi.newBuffer(
              QRhiBuffer::Static,
              score::gfx::compatibleBufferUsage(
                  rhi, QRhiBuffer::StorageBuffer | QRhiBuffer::VertexBuffer),
              bytesize);
          buf.handle->setName(oscr::getUtf8Name<T>() + "::" + oscr::getUtf8Name(port));
          buf.byte_offset = 0;
          buf.byte_size = bytesize;
          buf.owned = true;
 
          buf.handle->create();
        }
        else
        {
          buf.handle = rhi.newBuffer(
              QRhiBuffer::Static,
              score::gfx::compatibleBufferUsage(
                  rhi, QRhiBuffer::StorageBuffer | QRhiBuffer::VertexBuffer),
              1);
          buf.handle->setName(oscr::getUtf8Name<T>() + "::" + oscr::getUtf8Name(port));
          buf.byte_offset = 0;
          buf.byte_size = 1;
          buf.owned = true;
 
          buf.handle->create();
          return;
        }
      }
      else if(buf.handle->size() != bytesize)
      {
        buf.handle->destroy();
        buf.handle->setSize(bytesize);
        buf.handle->create();
        buf.byte_size = bytesize;
      }
 
      score::gfx::uploadStaticBufferWithStoredData(
          currentResourceUpdateBatch, buf.handle, offset, bytesize, data);
    };
  }
 
  void bindUploads(auto& state)
  {
    avnd::buffer_output_introspection<T>::for_all_n(
        avnd::get_outputs<T>(state),
        [this]<typename Field, std::size_t N>(Field& port, avnd::predicate_index<N> np) {
      if constexpr(avnd::cpu_buffer<std::decay_t<decltype(Field::buffer)>> && requires {
                     port.buffer.upload(nullptr, 0, 0);
                   })
      {
        bindUpload(port, np);
      }
    });
  }
 
  template <typename Field, std::size_t N, std::size_t NField>
    requires avnd::gpu_buffer<std::decay_t<decltype(Field::buffer)>>
  void createOutput(
      score::gfx::RenderList& renderer, auto& parent, Field& port,
      avnd::predicate_index<N> np, avnd::field_index<NField> nf)
  {
    auto& [gfx_port, buf] = m_buffers[N];
    gfx_port = parent.output[nf];
    buf.handle = reinterpret_cast<QRhiBuffer*>(port.buffer.handle);
    buf.byte_size = port.buffer.byte_size;
    buf.byte_offset = port.buffer.byte_offset;
    buf.owned = false;
  }
 
  void init(score::gfx::RenderList& renderer, auto& state, auto& parent)
  {
    // Init buffers for the outputs
    avnd::buffer_output_introspection<T>::for_all_n2(
        avnd::get_outputs<T>(state), [&]<typename Field, std::size_t N, std::size_t NField>
        (Field& port, avnd::predicate_index<N> np, avnd::field_index<NField> nf) {
      SCORE_ASSERT(parent.output.size() > nf);
      SCORE_ASSERT(parent.output[nf]->type == score::gfx::Types::Buffer);
      using buffer_type = std::decay_t<decltype(port.buffer)>;
 
      if constexpr(avnd::cpu_raw_buffer<buffer_type> && requires {
                     port.buffer.upload(nullptr, 0, 0);
                   })
      {
        createOutput(renderer, parent, port, np, nf);
      }
      else if constexpr(avnd::gpu_buffer<buffer_type>)
      {
        createOutput(renderer, parent, port, np, nf);
      }
      else
      {
        // m_buffers[N] = createOutput(renderer, *parent.output[nf], port.buffer);
        static_assert(std::is_same_v<T, void>, "unsupported");
      }
    });
  }
 
  void prepareUpload(QRhiResourceUpdateBatch& res)
  {
    currentResourceUpdateBatch = &res;
  }
 
  void upload(score::gfx::RenderList& renderer, auto& state, QRhiResourceUpdateBatch& res)
  {
    avnd::buffer_output_introspection<T>::for_all_n(
        avnd::get_outputs<T>(state), [&]<std::size_t N>(auto& t, avnd::predicate_index<N> idx) {
      auto& [port, buf] = m_buffers[N];
      uploadOutputBuffer(renderer, t.buffer, res, buf);
    });
  }
 
  void release(score::gfx::RenderList& renderer)
  {
    // Free outputs
    for(auto& [p, buf] : m_buffers)
    {
      if(buf.owned)
        renderer.releaseBuffer(buf.handle);
      buf.handle = nullptr;
      buf.owned = false;
    }
  }
};
 
template<typename T>
  requires (avnd::buffer_output_introspection<T>::size == 0)
struct buffer_outputs_storage<T>
{
  static void init(auto&&...)
  {
 
  }
 
  static void prepareUpload(auto&&...)
  {
  }
 
  static void bindUploads(auto&&...)
  {
  }
 
  static void upload(auto&&...)
  {
  }
 
  static void release(auto&&...)
  {
  }
};
 
 
template <typename Tex>
static auto
createOutputTexture(score::gfx::RenderList& renderer, const Tex& texture_spec, QSize size)
{
  auto& rhi = *renderer.state.rhi;
  QRhiTexture* texture = &renderer.emptyTexture();
  if(size.width() > 0 && size.height() > 0)
  {
    texture = rhi.newTexture(
        gpp::qrhi::textureFormat(texture_spec), size, 1, QRhiTexture::Flag{});
 
    texture->create();
  }
 
  auto sampler = rhi.newSampler(
      QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
      QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge);
 
  sampler->create();
  return score::gfx::Sampler{sampler, texture};
}
 
 
template<typename T>
struct texture_inputs_storage;
 
template<typename T>
  requires (avnd::texture_input_introspection<T>::size > 0)
struct texture_inputs_storage<T>
{
  ossia::small_flat_map<const score::gfx::Port*, score::gfx::TextureRenderTarget, 2>
      m_rts;
  ossia::small_flat_map<const score::gfx::Port*, QRhiSampler*, 2> m_samplers;
 
  QRhiReadbackResult m_readbacks[avnd::texture_input_introspection<T>::size];
  bool m_readbackPremultiplied[avnd::texture_input_introspection<T>::size]{};
 
  template <typename Tex>
  QRhiTexture* createInput(
      score::gfx::RenderList& renderer, score::gfx::Port* port, Tex& texture_spec,
      const score::gfx::RenderTargetSpecs& spec, bool wantsSamplableDepth = false,
      bool mipmapped = false)
  {
    QRhiTexture::Flags flags
        = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;
    if(mipmapped)
      flags |= QRhiTexture::MipMapped | QRhiTexture::UsedWithGenerateMips;
    QRhiTexture::Format fmt{};
    if constexpr(requires (Tex tex) { tex.format = {}; } && !requires (Tex tex) { tex.request_format; })
    {
      // Format freely assignable: we use what the user sets in the GUI
      fmt = spec.format;
      gpp::qrhi::toTextureFormat(fmt, texture_spec);
    }
    else
    {
      fmt = gpp::qrhi::textureFormat(texture_spec);
    }
 
    QRhiTexture* texture = renderer.state.rhi->newTexture(
        fmt, spec.size, 1, flags);
 
    SCORE_ASSERT(texture->create());
    // wantsSamplableDepth implies wantsDepth: createRenderTarget allocates
    // a sampleable single-sample depth texture (with MSAA-resolve when
    // available) instead of a renderbuffer / non-resolve depth target.
    // Same shape ISF/CSF inputs get when their port has SamplableDepth.
    const bool wantsDepth = renderer.requiresDepth(*port) || wantsSamplableDepth;
    m_rts[port] = score::gfx::createRenderTarget(
        renderer.state, texture, renderer.samples(),
        wantsDepth, wantsSamplableDepth);
    return texture;
  }
 
  void init(auto& self, score::gfx::RenderList& renderer)
  {
    // Init input render targets
    avnd::texture_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(*self.state),
        [&]<typename F, std::size_t K, std::size_t N>(F& t, avnd::predicate_index<K>, avnd::field_index<N>) {
      // Non-2D GPU texture inputs (cube / array / 3D) don't get a local
      // render target — the port carries Flag::GrabsFromSource (set by
      // initGfxPorts via texture_kind_of<F>()), the graph will populate
      // t.texture.handle through updateInputTexture when the edge
      // resolves. Skipping the allocation here avoids wasting a 2D
      // colour attachment that would never be rendered into anyway.
      if constexpr(avnd::gpu_texture_port<F>
                   && halp::texture_kind_of<F>() != halp::texture_kind::texture_2d)
      {
        t.texture.kind = halp::texture_kind_of<F>();
        // Handle + size populated later by updateInputTexture once the
        // upstream is resolved.
        return;
      }
 
      auto& parent = self.node();
      auto spec = renderer.resolveInputRenderTargetSpecs(parent, N);
      if constexpr(requires {
                     t.request_width;
                     t.request_height;
                   })
      {
        spec.size.rwidth() = t.request_width;
        spec.size.rheight() = t.request_height;
      }
 
      constexpr bool wantsSamplableDepth
          = avnd::gpu_texture_port<F> && halp::samplable_depth_of<F>();
      if constexpr(avnd::gpu_texture_port<F>)
      {
        if(!single_cable_port<F> || singleCableNeedsTarget(renderer, *parent.input[N]))
          createInput(
              renderer, parent.input[N], t.texture, spec, wantsSamplableDepth,
              spec.mipmap_mode != QRhiSampler::None);
        auto* sampler = renderer.state.rhi->newSampler(
            spec.mag_filter, spec.min_filter, spec.mipmap_mode, spec.address_u,
            spec.address_v, spec.address_w);
        sampler->setName("texture_inputs_storage::sampler");
        sampler->create();
        m_samplers[parent.input[N]] = sampler;
      }
      else
      {
        createInput(renderer, parent.input[N], t.texture, spec, wantsSamplableDepth);
      }
      if constexpr(avnd::cpu_texture_port<F>)
      {
        t.texture.width = spec.size.width();
        t.texture.height = spec.size.height();
      }
    });
 
    refreshGpuInputs(self, renderer);
  }
 
  static std::pair<bool, QRhiTexture*> upstreamTexture(
      score::gfx::RenderList& renderer, const score::gfx::Node& node, int32_t index,
      const score::gfx::Port& port, bool needsOwnTarget = false)
  {
    int wired = 0;
    QRhiTexture* direct = nullptr;
    for(auto* edge : port.edges)
    {
      if(!edge || !edge->source || !edge->source->node)
        continue;
      auto& rendered = edge->source->node->renderedNodes;
      auto it = rendered.find(&renderer);
      if(it == rendered.end() || !it->second)
        continue;
      if(wired++ == 0)
        direct = it->second->textureForOutput(*edge->source);
    }
    if(wired != 1 || needsOwnTarget || node.hasExplicitRenderTargetSpecs(index))
      direct = nullptr;
    return {wired > 0, direct};
  }
 
  static QRhiTexture*
  singleCableTexture(score::gfx::RenderList& renderer, const score::gfx::Port& port)
  {
    for(auto* edge : port.edges)
    {
      if(!edge || !edge->source || !edge->source->node)
        continue;
      auto& rendered = edge->source->node->renderedNodes;
      auto it = rendered.find(&renderer);
      if(it == rendered.end() || !it->second)
        continue;
      return it->second->textureForOutput(*edge->source);
    }
    return nullptr;
  }
 
  static bool
  singleCableNeedsTarget(score::gfx::RenderList& renderer, const score::gfx::Port& port)
  {
    return !port.edges.empty() && !singleCableTexture(renderer, port);
  }
 
  static bool
  composited(score::gfx::RenderList& renderer, const score::gfx::Port& port)
  {
    for(auto* edge : port.edges)
    {
      if(!edge || !edge->source || !edge->source->node)
        continue;
      auto& rendered = edge->source->node->renderedNodes;
      if(auto it = rendered.find(&renderer);
         it != rendered.end() && it->second && it->second->hasOutputPassForEdge(*edge))
        return true;
    }
    return false;
  }
 
  void releaseTarget(const score::gfx::Port* port)
  {
    if(auto it = m_rts.find(port); it != m_rts.end())
    {
      it->second.release();
      m_rts.erase(it);
    }
  }
 
  QRhiSampler* refreshSampler(
      const score::gfx::Node& node, int32_t index, score::gfx::RenderList& renderer,
      const score::gfx::Port* port)
  {
    auto it = m_samplers.find(port);
    if(it == m_samplers.end() || !it->second)
      return nullptr;
    auto* sampler = it->second;
    const auto spec = node.resolveRenderTargetSpecs(index, renderer);
    if(sampler->magFilter() != spec.mag_filter || sampler->minFilter() != spec.min_filter
       || sampler->mipmapMode() != spec.mipmap_mode
       || sampler->addressU() != spec.address_u || sampler->addressV() != spec.address_v
       || sampler->addressW() != spec.address_w)
    {
      sampler->destroy();
      sampler->setMagFilter(spec.mag_filter);
      sampler->setMinFilter(spec.min_filter);
      sampler->setMipmapMode(spec.mipmap_mode);
      sampler->setAddressU(spec.address_u);
      sampler->setAddressV(spec.address_v);
      sampler->setAddressW(spec.address_w);
      sampler->create();
    }
    return sampler;
  }
 
  static void describeTexture(halp::gpu_texture& dst, QRhiTexture& tex)
  {
    const auto sz = tex.pixelSize();
    dst.handle = &tex;
    dst.width = sz.width();
    dst.height = sz.height();
    gpp::qrhi::toTextureFormat(tex.format(), dst);
    const auto flags = tex.flags();
    if(flags & QRhiTexture::CubeMap)
    {
      dst.kind = halp::texture_kind::cubemap;
      dst.layers_or_depth = 6;
    }
    else if(flags & QRhiTexture::ThreeDimensional)
    {
      dst.kind = halp::texture_kind::texture_3d;
      dst.layers_or_depth = tex.depth();
    }
    else if(flags & QRhiTexture::TextureArray)
    {
      dst.kind = halp::texture_kind::texture_array;
      dst.layers_or_depth = tex.arraySize();
    }
    else
    {
      dst.kind = halp::texture_kind::texture_2d;
      dst.layers_or_depth = 1;
    }
  }
 
  void refreshGpuInputs(auto& self, score::gfx::RenderList& renderer)
  {
    avnd::texture_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(*self.state),
        [&]<typename F, std::size_t K, std::size_t N>(
            F& t, avnd::predicate_index<K>, avnd::field_index<N>) {
      if constexpr(
          avnd::gpu_texture_port<F>
          && halp::texture_kind_of<F>() == halp::texture_kind::texture_2d)
      {
        constexpr bool wantsSamplableDepth = halp::samplable_depth_of<F>();
        auto* port = self.node().input[N];
        auto& tex = t.texture;
        const auto rt_it = m_rts.find(port);
        const bool mipmapped
            = rt_it != m_rts.end() && rt_it->second.texture
              && rt_it->second.texture->flags().testFlag(QRhiTexture::MipMapped);
        tex.sampler_handle = refreshSampler(self.node(), N, renderer, port);
 
        QRhiTexture* src = nullptr;
        if constexpr(single_cable_port<F>)
        {
          src = singleCableTexture(renderer, *port);
          if(src)
          {
            if(rt_it != m_rts.end() && !composited(renderer, *port))
              releaseTarget(port);
          }
          else if(!port->edges.empty() && rt_it != m_rts.end())
          {
            src = rt_it->second.texture;
          }
        }
        else if(auto [wired, direct]
                = upstreamTexture(renderer, self.node(), N, *port, mipmapped);
                wired)
        {
          if constexpr(!wantsSamplableDepth)
            src = direct;
          if(!src && rt_it != m_rts.end())
            src = rt_it->second.texture;
        }
 
        if(!src)
        {
          tex.handle = nullptr;
          tex.width = 0;
          tex.height = 0;
          tex.kind = halp::texture_kind::texture_2d;
          tex.layers_or_depth = 1;
          if constexpr(wantsSamplableDepth)
            tex.depth_handle = nullptr;
          return;
        }
 
        describeTexture(tex, *src);
        if constexpr(wantsSamplableDepth)
        {
          auto* depth = rt_it->second.depthTexture;
          tex.depth_handle = depth;
          if(depth)
            tex.depth_format = qrhiToHalpDepthFormat(depth->format());
        }
      }
    });
  }
 
  bool update(auto& self,
      score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res)
  {
    avnd::texture_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(*self.state),
        [&]<typename F, std::size_t K, std::size_t N>(
            F& t, avnd::predicate_index<K>, avnd::field_index<N>) {
      if constexpr(single_cable_port<F> && avnd::gpu_texture_port<F>)
      {
        auto& parent = self.node();
        auto* port = parent.input[N];
        if(m_rts.find(port) != m_rts.end() || !singleCableNeedsTarget(renderer, *port))
          return;
        auto spec = renderer.resolveInputRenderTargetSpecs(parent, N);
        if constexpr(requires {
                       t.request_width;
                       t.request_height;
                     })
        {
          spec.size.rwidth() = t.request_width;
          spec.size.rheight() = t.request_height;
        }
        createInput(
            renderer, port, t.texture, spec, false,
            spec.mipmap_mode != QRhiSampler::None);
        for(auto* edge : port->edges)
        {
          auto& rendered = edge->source->node->renderedNodes;
          if(auto it = rendered.find(&renderer); it != rendered.end() && it->second)
          {
            it->second->removeOutputPass(renderer, *edge);
            it->second->addOutputPass(renderer, *edge, res);
          }
        }
      }
    });
#if 0
    bool need_update = false;
    avnd::texture_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(*self.state),
        [&]<typename F, std::size_t K, std::size_t N>(F& t, avnd::predicate_index<K>, avnd::field_index<N>) {
      if constexpr(requires {
                     t.request_width;
                     t.request_height;
                   })
      {
        auto& parent = self.node();
        auto port = parent.input[N];
        const score::gfx::TextureRenderTarget& texture = m_rts[port];
        QSizeF sz{};
        if(texture.texture)
          sz = texture.texture->pixelSize();
        if(sz.width() != t.request_width || sz.height() != t.request_height)
        {
          // FIXME right now this doesn't work because
          // the render target spec is stored in the node.
          // Also the RenderList just recomputes everything anyways,
          // so we should just emit a "need to change" signal and abort as
          // long as things aren't more optimized and actually follow the graph
 
          // m_rts[port].release();
 
          // auto spec = parent.resolveRenderTargetSpecs(N, renderer);
          // spec.size.rwidth() = t.request_width;
          // spec.size.rheight() = t.request_height;
 
          // createInput(renderer, port, t.texture, sz);
 
          // t.texture.width = spec.size.width();
          // t.texture.height = spec.size.height();
          // need_update = true;
          //
        }
      }
    });
    return need_update;
#endif
    return false;
  }
 
  template <typename F>
  static constexpr bool reads_upstream_directly() noexcept
  {
    using Tex = std::decay_t<decltype(F::texture)>;
    return avnd::cpu_texture_port<F>
           && requires(Tex tex) { tex.format = {}; }
           && !requires(Tex tex) { tex.request_format; }
           && !requires(F f) { f.request_width; };
  }
 
  void runInitialPasses(auto& self, score::gfx::RenderList& renderer)
  {
    auto& rhi = *renderer.state.rhi;
    refreshGpuInputs(self, renderer);
 
    // Fetch input textures (if any)
    // Copy the readback output inside the structure
    // TODO it would be much better to do this inside the readback's
    // "completed" callback.
    if constexpr(avnd::cpu_texture_input_introspection<T>::size > 0)
    {
      avnd::texture_input_introspection<T>::for_all_n(
          avnd::get_inputs<T>(*self.state), [&]<typename F, std::size_t K>(F& t, avnd::predicate_index<K>) {
        if constexpr(avnd::cpu_texture_port<F>)
          {
            if constexpr(reads_upstream_directly<F>())
            {
              const auto& rb = m_readbacks[K];
              if(!rb.pixelSize.isEmpty())
              {
                t.texture.width = rb.pixelSize.width();
                t.texture.height = rb.pixelSize.height();
                gpp::qrhi::toTextureFormat(rb.format, t.texture);
              }
            }
            if(auto& rb = m_readbacks[K]; m_readbackPremultiplied[K] && !rb.data.isEmpty())
            {
              gpp::qrhi::unpremultiply(
                  rb.format, rb.data, rb.pixelSize.width(), rb.pixelSize.height());
              m_readbackPremultiplied[K] = false;
            }
            oscr::loadInputTexture(rhi, m_readbacks, t.texture, K);
          }
      });
    }
  }
 
  void release()
  {
    // Free inputs
    // TODO investigate why reference does not work here:
    for(auto [port, rt] : m_rts)
      rt.release();
    m_rts.clear();
    for(auto [port, sampler] : m_samplers)
      sampler->deleteLater();
    m_samplers.clear();
  }
 
  void inputAboutToFinish(
      auto& self, score::gfx::RenderList& renderer, const score::gfx::Port& p,
      QRhiResourceUpdateBatch*& res)
  {
    if constexpr(avnd::cpu_texture_input_introspection<T>::size > 0)
    {
      const auto& inputs = self.node().input;
      avnd::texture_input_introspection<T>::for_all_n2(
          avnd::get_inputs<T>(*self.state),
          [&]<typename F, std::size_t K, std::size_t N>(
              F&, avnd::predicate_index<K>, avnd::field_index<N>) {
        if constexpr(avnd::cpu_texture_port<F>)
        {
          if(N >= inputs.size() || inputs[N] != &p)
            return;
          auto rt_it = m_rts.find(&p);
          if(rt_it == m_rts.end())
            return;
          QRhiTexture* tex = rt_it->second.texture;
          if constexpr(reads_upstream_directly<F>())
          {
            auto [wired, direct] = upstreamTexture(renderer, self.node(), N, p);
            if(direct && direct->sampleCount() <= 1
               && (direct->flags() & QRhiTexture::UsedAsTransferSource)
               && !(direct->flags()
                    & (QRhiTexture::CubeMap | QRhiTexture::ThreeDimensional
                       | QRhiTexture::TextureArray)))
              tex = direct;
          }
          if(!tex)
            return;
          auto& readback = m_readbacks[K];
          readback = {};
          m_readbackPremultiplied[K] = tex == rt_it->second.texture;
          res->readBackTexture(QRhiReadbackDescription{tex}, &readback);
        }
      });
    }
  }
 
};
template<typename T>
  requires (avnd::texture_input_introspection<T>::size == 0)
struct texture_inputs_storage<T>
{
  static void init(auto&&...) { }
  static void runInitialPasses(auto&&...) { }
  static void release(auto&&...) { }
  static void inputAboutToFinish(auto&&...) { }
};
 
 
 
template <avnd::cpu_texture Tex>
static QRhiTexture* updateTexture(auto& self, score::gfx::RenderList& renderer, int k, const Tex& cpu_tex)
{
  auto& [sampler, texture, fb_] = self.m_samplers[k];
  if(texture)
  {
    auto sz = texture->pixelSize();
    if(cpu_tex.width == sz.width() && cpu_tex.height == sz.height())
      return texture;
  }
 
  // Check the texture size
  if(cpu_tex.width > 0 && cpu_tex.height > 0)
  {
    QRhiTexture* oldtex = texture;
    QRhiTexture* newtex = renderer.state.rhi->newTexture(
        gpp::qrhi::textureFormat(cpu_tex), QSize{cpu_tex.width, cpu_tex.height}, 1,
        QRhiTexture::Flag{});
    newtex->create();
    for(auto& [edge, pass] : self.m_p)
      if(pass.p.srb)
        score::gfx::replaceTexture(*pass.p.srb, sampler, newtex);
    texture = newtex;
 
    if(oldtex && oldtex != &renderer.emptyTexture())
    {
      oldtex->deleteLater();
    }
 
    return newtex;
  }
  else
  {
    for(auto& [edge, pass] : self.m_p)
      if(pass.p.srb)
        score::gfx::replaceTexture(*pass.p.srb, sampler, &renderer.emptyTexture());
 
    return &renderer.emptyTexture();
  }
}
 
template <avnd::cpu_texture Tex>
static void uploadOutputTexture(auto& self,
                                score::gfx::RenderList& renderer, int k, Tex& cpu_tex,
                                QRhiResourceUpdateBatch* res)
{
  if(cpu_tex.changed)
  {
    if(auto texture = updateTexture(self, renderer, k, cpu_tex))
    {
      if(!cpu_tex.bytes || cpu_tex.bytesize() <= 0)
      {
        cpu_tex.changed = false;
        return;
      }
 
      QByteArray buf
          = QByteArray::fromRawData((const char*)cpu_tex.bytes, cpu_tex.bytesize());
      if constexpr(requires { Tex::RGB; })
      {
        // RGB -> RGBA
        // FIXME other conversions
        const QByteArray rgb = buf;
        QByteArray rgba;
        rgba.resize(cpu_tex.width * cpu_tex.height * 4);
        auto src = (const unsigned char*)rgb.constData();
        auto dst = (unsigned char*)rgba.data();
        for(int rgb_byte = 0, rgba_byte = 0, N = rgb.size(); rgb_byte < N;)
        {
          dst[rgba_byte + 0] = src[rgb_byte + 0];
          dst[rgba_byte + 1] = src[rgb_byte + 1];
          dst[rgba_byte + 2] = src[rgb_byte + 2];
          dst[rgba_byte + 3] = 255;
          rgb_byte += 3;
          rgba_byte += 4;
        }
        buf = rgba;
      }
 
      // Upload it (mirroring is done in shader generic_texgen_fs if necessary)
      {
        QRhiTextureSubresourceUploadDescription sd(buf);
        QRhiTextureUploadDescription desc{QRhiTextureUploadEntry{0, 0, sd}};
 
        res->uploadTexture(texture, desc);
      }
 
      cpu_tex.changed = false;
    }
  }
}
 
static const constexpr auto generic_texgen_vs = R"_(#version 450
layout(location = 0) in vec2 position;
layout(location = 1) in vec2 texcoord;
 
layout(binding=3) uniform sampler2D y_tex;
layout(location = 0) out vec2 v_texcoord;
 
layout(std140, binding = 0) uniform renderer_t {
  mat4 clipSpaceCorrMatrix;
  vec2 renderSize;
} renderer;
 
out gl_PerVertex { vec4 gl_Position; };
 
void main()
{
#if defined(QSHADER_SPIRV) || defined(QSHADER_GLSL)
  v_texcoord = vec2(texcoord.x, 1. - texcoord.y);
#else
  v_texcoord = texcoord;
#endif
  gl_Position = renderer.clipSpaceCorrMatrix * vec4(position.xy, 0.0, 1.);
}
)_";
 
static const constexpr auto generic_texgen_fs = R"_(#version 450
layout(location = 0) in vec2 v_texcoord;
layout(location = 0) out vec4 fragColor;
 
layout(std140, binding = 0) uniform renderer_t {
mat4 clipSpaceCorrMatrix;
vec2 renderSize;
} renderer;
 
layout(binding=3) uniform sampler2D y_tex;
 
void main ()
{
  fragColor = texture(y_tex, v_texcoord);
}
)_";
 
template<typename T>
struct texture_outputs_storage;
 
// If we have texture outs we need the whole rendering infrastructure
template<typename T>
  requires (avnd::texture_output_introspection<T>::size > 0)
struct texture_outputs_storage<T>
{
  static bool drawnOutputPremultiplied(auto& self) noexcept
  {
    bool premultiplied = false;
    const auto first = [&]<typename F, std::size_t N>(F&, avnd::predicate_index<N>) {
      if constexpr(N == 0)
        premultiplied = requires { F::premultiplied; };
    };
    if constexpr(avnd::cpu_texture_output_introspection<T>::size > 0)
      avnd::cpu_texture_output_introspection<T>::for_all_n(
          avnd::get_outputs<T>(*self.state), first);
    else
      avnd::gpu_texture_output_introspection<T>::for_all_n(
          avnd::get_outputs<T>(*self.state), first);
    return premultiplied;
  }
 
  void init(auto& self, score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res)
  {
    const auto& mesh = renderer.defaultTriangle();
    self.defaultMeshInit(renderer, mesh, res);
    self.processUBOInit(renderer);
    // Not needed here as we do not have a GPU pass:
    // this->m_material.init(renderer, this->node.input, this->m_samplers);
 
    std::tie(self.m_vertexS, self.m_fragmentS)
        = score::gfx::makeShaders(renderer.state, generic_texgen_vs, generic_texgen_fs);
 
    avnd::cpu_texture_output_introspection<T>::for_all(
        avnd::get_outputs<T>(*self.state), [&](auto& t) {
      self.m_samplers.push_back(
          createOutputTexture(renderer, t.texture, QSize{t.texture.width, t.texture.height}));
    });
 
    gpu_first = self.m_samplers.size();
    avnd::gpu_texture_output_introspection<T>::for_all(
        avnd::get_outputs<T>(*self.state), [&](auto&) {
      auto sampler = renderer.state.rhi->newSampler(
          QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
          QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge);
      sampler->create();
      self.m_samplers.push_back(score::gfx::Sampler{sampler, nullptr});
    });
 
    self.m_outputPremultiplied = drawnOutputPremultiplied(self);
    self.defaultPassesInit(renderer, mesh);
 
    // defaultPassesInit only covers the edges of output[0]: an edge leaving any
    // other texture outlet (e.g. Image Processor's Mask / Depth) gets its pass
    // here, bound to that outlet's own sampler (see samplersForOutputEdge).
    for(auto* port : self.node().output)
    {
      if(!port || port->type != score::gfx::Types::Image)
        continue;
      for(auto* edge : port->edges)
        if(!self.hasOutputPassForEdge(*edge))
          self.addOutputPass(renderer, *edge, res);
    }
  }
 
  void runInitialPasses(auto& self,
                        score::gfx::RenderList& renderer,
                        QRhiResourceUpdateBatch*& res)
  {
    avnd::cpu_texture_output_introspection<T>::for_all_n(
        avnd::get_outputs<T>(*self.state), [&]<std::size_t N>(auto& t, avnd::predicate_index<N>) {
      uploadOutputTexture(self, renderer, N, t.texture, res);
    });
 
    std::size_t k = gpu_first;
    avnd::gpu_texture_output_introspection<T>::for_all(
        avnd::get_outputs<T>(*self.state), [&](auto& t) {
      auto* tex = static_cast<QRhiTexture*>(t.texture.handle);
      if(tex
         && (tex->flags()
             & (QRhiTexture::CubeMap | QRhiTexture::ThreeDimensional
                | QRhiTexture::TextureArray)))
        tex = nullptr;
      auto& sampler = self.m_samplers[k];
      if(tex != sampler.texture)
      {
        sampler.texture = tex;
        for(auto& [edge, pass] : self.m_p)
        {
          if(!pass.p.srb || !edge)
            continue;
          // A pass bound to its edge's own sampler (samplersForOutputEdge) holds
          // it at binding 3; a pass holding every sampler has this one at 3 + k.
          const auto bound = self.samplersForOutputEdge(*edge);
          if(bound.size() == 1)
          {
            if(bound.data() == &sampler)
              score::gfx::replaceTexture(
                  *pass.p.srb, 3, tex ? tex : &renderer.emptyTexture());
          }
          else
          {
            score::gfx::replaceTexture(
                *pass.p.srb, int(3 + k), tex ? tex : &renderer.emptyTexture());
          }
        }
      }
      k++;
    });
  }
 
  void release(auto& self, score::gfx::RenderList& r)
  {
    for(std::size_t i = 0; i < self.m_samplers.size(); i++)
    {
      auto& texture = self.m_samplers[i].texture;
      if(i < gpu_first && texture != &r.emptyTexture())
        texture->deleteLater();
      texture = nullptr;
    }
  }
 
  std::size_t gpu_first{};
 
};
 
template<typename T>
  requires (avnd::texture_output_introspection<T>::size == 0)
struct texture_outputs_storage<T>
{
  static void init(auto& self, score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res)
  {
  }
 
  static void runInitialPasses(auto& self,
                        score::gfx::RenderList& renderer,
                        QRhiResourceUpdateBatch*& res)
  {
  }
 
  static void release(auto& self, score::gfx::RenderList& r)
  {
  }
};
template<typename T>
struct geometry_outputs_storage;
 
template<typename T>
  requires (avnd::geometry_output_introspection<T>::size > 0)
struct geometry_outputs_storage<T>
{
  ossia::geometry_spec specs[avnd::geometry_output_introspection<T>::size];
 
  struct sent_transform
  {
    std::optional<ossia::transform3d> value;
    std::vector<std::pair<const score::gfx::Edge*, const score::gfx::NodeRenderer*>>
        receivers;
  };
  sent_transform transforms[avnd::geometry_output_introspection<T>::size];
 
  template <avnd::geometry_port Field>
  void reload_mesh(Field& ctrl, ossia::geometry_spec& spc)
  {
    spc.meshes = std::make_shared<ossia::mesh_list>();
    auto& ossia_meshes = *spc.meshes;
    if constexpr(avnd::static_geometry_type<Field> || avnd::dynamic_geometry_type<Field>)
    {
      ossia_meshes.meshes.resize(1);
      load_geometry(ctrl, ossia_meshes.meshes[0]);
    }
    else if constexpr(
        avnd::static_geometry_type<decltype(Field::mesh)>
        || avnd::dynamic_geometry_type<decltype(Field::mesh)>)
    {
      ossia_meshes.meshes.resize(1);
      load_geometry(ctrl.mesh, ossia_meshes.meshes[0]);
    }
    else
    {
      load_geometry(ctrl, ossia_meshes);
    }
  }
 
  template <avnd::geometry_port Field, std::size_t N>
  void upload(
      score::gfx::RenderList& renderer, Field& ctrl, score::gfx::Edge& edge,
      avnd::predicate_index<N>)
  {
    auto edge_sink = edge.sink;
    if(auto pnode = edge_sink->node)
    {
      ossia::geometry_spec& spc = specs[N];
 
      // 1. Reload mesh
      {
        if(ctrl.dirty_mesh)
        {
          reload_mesh(ctrl, spc);
        }
        else
        {
          if(spc.meshes)
          {
            auto& ossia_meshes = *spc.meshes;
 
            bool any_need_reload = false;
            bool any_need_upload = false;
            if constexpr(avnd::static_geometry_type<Field> || avnd::dynamic_geometry_type<Field>)
            {
              SCORE_ASSERT(ossia_meshes.meshes.size() == 1);
              auto [need_reload, need_upload]
                  = update_geometry(ctrl, ossia_meshes.meshes[0]);
              any_need_reload = need_reload;
              any_need_upload = need_upload;
            }
            else if constexpr(
                avnd::static_geometry_type<decltype(Field::mesh)>
                || avnd::dynamic_geometry_type<decltype(Field::mesh)>)
            {
              SCORE_ASSERT(ossia_meshes.meshes.size() == 1);
              auto [need_reload, need_upload]
                  = update_geometry(ctrl.mesh, ossia_meshes.meshes[0]);
              any_need_reload = need_reload;
              any_need_upload = need_upload;
            }
            else
            {
              auto [need_reload, need_upload] = update_geometry(ctrl, ossia_meshes);
              any_need_reload = need_reload;
              any_need_upload = need_upload;
            }
 
            if(any_need_reload)
            {
              reload_mesh(ctrl, spc);
            }
          }
        }
        ctrl.dirty_mesh = false;
      }
 
      // 2. Push to next node
      // FIXME this should be for the renderer of edge, not the node, since
      // geometries can have gpu buffers
      auto rendered_node = pnode->renderedNodes.find(&renderer);
      SCORE_ASSERT(rendered_node != pnode->renderedNodes.end());
 
      auto it = std::find(
          edge_sink->node->input.begin(), edge_sink->node->input.end(), edge_sink);
      SCORE_ASSERT(it != edge_sink->node->input.end());
      int n = it - edge_sink->node->input.begin();
 
      rendered_node->second->process(n, spc, edge.source);
 
      // 3. Same for transform3d
 
      if constexpr(requires { ctrl.transform; })
      {
        auto& sent = transforms[N];
        if(ctrl.dirty_transform)
        {
          sent.value.emplace();
          std::copy_n(ctrl.transform, std::ssize(ctrl.transform), sent.value->matrix);
          sent.receivers.clear();
          ctrl.dirty_transform = false;
        }
 
        const std::pair<const score::gfx::Edge*, const score::gfx::NodeRenderer*>
            receiver{&edge, rendered_node->second};
        if(sent.value && !ossia::contains(sent.receivers, receiver))
        {
          sent.receivers.push_back(receiver);
          rendered_node->second->process(n, *sent.value);
          if(auto pnode = dynamic_cast<score::gfx::ProcessNode*>(edge_sink->node))
            pnode->process(n, *sent.value);
        }
      }
    }
  }
 
  void upload(score::gfx::RenderList& renderer, auto& state, score::gfx::Edge& edge)
  {
    // FIXME we need something such as port_run_{pre,post}process for GPU nodes
    avnd::geometry_output_introspection<T>::for_all_n(
        avnd::get_outputs(state),
        [&](auto& field, auto pred) { this->upload(renderer, field, edge, pred); });
  }
 
  // Lifecycle parity with the other *_outs storages. The geometry_spec
  // wrapper carries non-owning pointers + transform values, so release has
  // nothing to do; it exists so RHI handles added later have a hook.
  void release(score::gfx::RenderList&) noexcept { }
};
 
 
template<typename T>
  requires (avnd::geometry_output_introspection<T>::size == 0)
struct geometry_outputs_storage<T>
{
  static void upload(auto&&...)
  {
 
  }
  static void release(auto&&...) noexcept { }
};
 
// Scene output support (Crousti-side pending promotion to avendish).
// The `scene_port` concept and `scene_dirt_flags` live in SceneConcepts.hpp
// so the port-creation visitor in ProcessModelPortInit.hpp can reuse them.
 
template <typename Field>
using is_scene_port_t = boost::mp11::mp_bool<scene_port<Field>>;
 
template <typename T>
using scene_output_introspection =
    avnd::predicate_introspection<typename avnd::outputs_type<T>::type, is_scene_port_t>;
 
template <typename T>
using scene_input_introspection =
    avnd::predicate_introspection<typename avnd::inputs_type<T>::type, is_scene_port_t>;
 
// Scene input transport: NodeRenderer::process(port, scene_spec, source)
// keeps one scene per (port, source) and merges them all into `this->scene`.
// A node with a single scene input gets that merged scene. With several, each
// field receives only the scenes that arrived on its own port, merged across
// sources; the merge is memoized per port on the (state, version) set so an
// unchanged input keeps its scene_state identity.
template <typename T>
struct scene_inputs_storage;
 
template <typename T>
  requires(scene_input_introspection<T>::size > 0)
struct scene_inputs_storage<T>
{
  struct port_cache
  {
    ossia::small_vector<std::pair<const ossia::scene_state*, int64_t>, 4> inputs;
    ossia::scene_spec merged;
  };
  port_cache m_cache[scene_input_introspection<T>::size];
 
  static ossia::scene_spec
  sceneOnPort(const score::gfx::NodeRenderer& renderer, int port, port_cache& cache)
  {
    ossia::small_vector<std::pair<const ossia::scene_state*, int64_t>, 4> sig;
    ossia::small_vector<ossia::scene_spec, 4> scenes;
    renderer.forEachSceneOnPort(port, [&](const ossia::scene_spec& s) {
      sig.push_back({s.state.get(), s.state->version});
      scenes.push_back(s);
    });
 
    if(scenes.empty())
    {
      cache = {};
      return {};
    }
    if(scenes.size() == 1)
    {
      cache = {};
      return scenes[0];
    }
    if(sig == cache.inputs && cache.merged.state)
      return cache.merged;
 
    cache.inputs.assign(sig.begin(), sig.end());
    cache.merged = ossia::merge_scenes(
        std::span<const ossia::scene_spec>{scenes.data(), scenes.size()});
    return cache.merged;
  }
 
  void readInputScenes(const score::gfx::NodeRenderer& renderer, auto& state)
  {
    if constexpr(scene_input_introspection<T>::size == 1)
    {
      scene_input_introspection<T>::for_all(
          avnd::get_inputs<T>(state), [&](auto& field) { field.scene = renderer.scene; });
      return;
    }
    scene_input_introspection<T>::for_all_n2(
        avnd::get_inputs<T>(state),
        [&]<typename F, std::size_t K, std::size_t N>(
            F& field, avnd::predicate_index<K>, avnd::field_index<N>) {
      field.scene = sceneOnPort(renderer, int(N), m_cache[K]);
    });
  }
 
  void release(score::gfx::RenderList&)
  {
    for(auto& c : m_cache)
      c = {};
  }
};
 
template <typename T>
  requires(scene_input_introspection<T>::size == 0)
struct scene_inputs_storage<T>
{
  static void readInputScenes(auto&&...) { }
  static void release(auto&&...) { }
};
 
template <typename T>
struct scene_outputs_storage;
 
template <typename T>
  requires(scene_output_introspection<T>::size > 0)
struct scene_outputs_storage<T>
{
  template <scene_port Field, std::size_t N>
  void upload(
      score::gfx::RenderList& renderer, Field& ctrl, score::gfx::Edge& edge,
      avnd::predicate_index<N>)
  {
    // Publish the scene every frame rather than only when `ctrl.dirty` is
    // set: a once-only push gets overwritten by any other producer on the
    // same downstream inlet. Consumers short-circuit on shared_ptr
    // identity + version, so publishing every frame costs only refcount
    // bumps.
    if(!ctrl.scene.state)
      return;
 
    auto* edge_sink = edge.sink;
    if(!edge_sink || !edge_sink->node)
      return;
 
    auto rendered_node = edge_sink->node->renderedNodes.find(&renderer);
    if(rendered_node == edge_sink->node->renderedNodes.end())
      return;
 
    auto it = std::find(
        edge_sink->node->input.begin(), edge_sink->node->input.end(), edge_sink);
    if(it == edge_sink->node->input.end())
      return;
    int n = it - edge_sink->node->input.begin();
 
    // NodeRenderer::process(port, scene_spec, source_key) handles additive
    // merging across multiple producers converging on the same sink port
    // (keyed on the source edge's producer Port pointer), extracts a legacy
    // geometry_spec for downstream consumers that only understand geometry,
    // and sets sceneChanged=true.
    rendered_node->second->process(n, ctrl.scene, edge.source);
 
    if constexpr(requires { ctrl.dirty; })
      ctrl.dirty = 0;
  }
 
  void upload(score::gfx::RenderList& renderer, auto& state, score::gfx::Edge& edge)
  {
    scene_output_introspection<T>::for_all_n(
        avnd::get_outputs(state),
        [&](auto& field, auto pred) { this->upload(renderer, field, edge, pred); });
  }
 
  // Lifecycle parity with texture_outputs_storage / buffer_outputs_storage:
  // the storage owns no QRhi resources (the scene_spec is a value-semantics
  // struct plus a shared_ptr to scene_state, both managed by their own
  // destructors), so release has nothing to do. It keeps CpuFilterNode /
  // CpuAnalysisNode releaseState symmetric across all storages, and gives
  // RHI handles added later a hook.
  void release(score::gfx::RenderList&) noexcept { }
};
 
template <typename T>
  requires(scene_output_introspection<T>::size == 0)
struct scene_outputs_storage<T>
{
  static void upload(auto&&...) { }
  static void release(auto&&...) noexcept { }
};
 
}
 
#endif