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 <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/small_flat_map.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>
 
namespace oscr
{
struct GpuWorker
{
  template <typename T>
  void initWorker(this auto& self, std::shared_ptr<T>& state) noexcept
  {
    if constexpr(avnd::has_worker<T>)
    {
      auto ptr = QPointer{&self};
      auto& tq = score::TaskPool::instance();
      using worker_type = decltype(state->worker);
 
      auto wk_state = std::weak_ptr{state};
      state->worker.request = [ptr, &tq, wk_state]<typename... Args>(Args&&... f) {
        using type_of_result = decltype(worker_type::work(std::forward<Args>(f)...));
        tq.post([... ff = std::forward<Args>(f), wk_state, ptr]() mutable {
          if constexpr(std::is_void_v<type_of_result>)
          {
            worker_type::work(std::forward<decltype(ff)>(ff)...);
          }
          else
          {
            // If the worker returns a std::function, it
            // is to be invoked back in the processor DSP thread
            auto res = worker_type::work(std::forward<decltype(ff)>(ff)...);
            if(!res || !ptr)
              return;
 
            ossia::qt::run_async(
                QCoreApplication::instance(),
                [res = std::move(res), wk_state, ptr]() mutable {
              if(ptr)
                if(auto state = wk_state.lock())
                  res(*state);
                });
          }
        });
      };
    }
  }
};
 
#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
 
template <typename GpuNodeRenderer, typename Node>
struct GpuProcessIns
{
  GpuNodeRenderer& gpu;
  Node& state;
  const score::gfx::Message& prev_mess;
  const score::gfx::Message& mess;
  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 same message is handed to the renderer more than once (init, update, every frame between
  // two execution ticks).
  bool is_new_message() const noexcept
  {
    return prev_mess.node_id != mess.node_id || prev_mess.token.date != mess.token.date
           || prev_mess.input.size() != mess.input.size();
  }
 
  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)>)
    {
      // Impulses and other one-shot values are events, not states: a value equal to the previous
      // one is a new event, but the same message must not fire it twice. Mirrors the CPU path
      // (which sees each port's data stream once per tick).
      if(mess.input.size() <= NField || !is_new_message())
        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;
    node.process(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;
    node.process(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, score::gfx::Message& renderer_mess,
      const score::gfx::Message& 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;
  score::gfx::Message 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();
 
  score::gfx::Message 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;
  score::gfx::Message 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;
  score::gfx::Message 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>();
    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;
 
  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();
        }
      });
    });
  }
 
  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];
      oscr::meshes_from_ossia(
          spec.meshes, t.mesh,
          [&](auto& write_buf, int buffer_index, void* data, int64_t bytesize) {
        // cpu -> gpu
        if(meshes.buffers.size() <= buffer_index)
        {
          meshes.buffers.resize(buffer_index + 1);
          meshes.readbacks.resize(buffer_index + 1);
 
          auto 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);
          meshes.buffers[buffer_index] = buf;
        }
        else if(auto* existing = meshes.buffers[buffer_index];
                existing && existing->size() < bytesize)
        {
          // Buffer exists but is too small — resize it.
          existing->setSize(bytesize);
          existing->create();
        }
 
        res->uploadStaticBuffer(meshes.buffers[buffer_index], 0, bytesize, data);
      }, [&](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] = {};
        }
      });
    });
  }
 
  void release(score::gfx::RenderList& renderer)
  {
    for(auto& buf : allocated)
      renderer.releaseBuffer(buf);
    allocated.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;
 
  QRhiReadbackResult m_readbacks[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)
  {
    static constexpr auto flags
        = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;
    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 = parent.resolveRenderTargetSpecs(N, renderer);
      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>();
      auto tex = 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();
      }
      else if constexpr(avnd::gpu_texture_port<F>)
      {
        t.texture.handle = tex;
        t.texture.width = spec.size.width();
        t.texture.height = spec.size.height();
        if constexpr(wantsSamplableDepth)
        {
          // The local RT just allocated owns a sampleable depth texture
          // that the upstream renders into when the edge runs — same
          // pointer, stable for the RT's lifetime, no per-frame refresh.
          const auto& rt = m_rts[parent.input[N]];
          t.texture.depth_handle = rt.depthTexture;
          if(rt.depthTexture)
            t.texture.depth_format = qrhiToHalpDepthFormat(rt.depthTexture->format());
        }
      }
    });
  }
 
  bool update(auto& self,
      score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& 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;
  }
 
  void runInitialPasses(auto& self, QRhi& rhi)
  {
    // 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>)
          {
            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();
  }
 
  void inputAboutToFinish(auto& parent, const score::gfx::Port& p,  QRhiResourceUpdateBatch*& res)
  {
    if constexpr(avnd::cpu_texture_input_introspection<T>::size > 0)
    {
      const auto& inputs = parent.input;
      auto index_of_port = ossia::find(inputs, &p) - inputs.begin();
      {
        auto tex = m_rts[&p].texture;
        auto& readback = m_readbacks[index_of_port];
        readback = {};
        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>
{
  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}));
    });
 
    self.defaultPassesInit(renderer, mesh);
  }
 
  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);
    });
  }
 
  void release(auto& self, score::gfx::RenderList& r)
  {
    // Free outputs
    for(auto& [sampl, texture, fb_] : self.m_samplers)
    {
      if(texture != &r.emptyTexture())
        texture->deleteLater();
      texture = nullptr;
    }
  }
 
};
 
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];
 
  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; })
      {
        if(ctrl.dirty_transform)
        {
          ossia::transform3d transform;
          std::copy_n(ctrl.transform, std::ssize(ctrl.transform), transform.matrix);
          ctrl.dirty_transform = false;
 
          rendered_node->second->process(n, transform);
          if(auto pnode = dynamic_cast<score::gfx::ProcessNode*>(edge_sink->node))
            pnode->process(n, transform);
        }
      }
    }
  }
 
  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)
// already merges multi-producer scenes into `this->scene`, so scene_inputs_storage
// only needs to copy that merged scene_spec into each halp scene input field
// before operator()() runs. Cheap (shared_ptr assignment), no decode.
template <typename T>
struct scene_inputs_storage;
 
template <typename T>
  requires(scene_input_introspection<T>::size > 0)
struct scene_inputs_storage<T>
{
  void readInputScenes(const ossia::scene_spec& scene, auto& state)
  {
    scene_input_introspection<T>::for_all(
        avnd::get_inputs<T>(state), [&](auto& field) { field.scene = scene; });
  }
 
  static void release(score::gfx::RenderList&) { }
};
 
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