ISFVisitors.hpp

#pragma once
#include <isf.hpp>
 
#include <ossia/detail/variant.hpp>
 
#include <span>
#include <string_view>
#include <vector>
 
namespace score::gfx
{
// ---------------------------------------------------------------------------
// Descriptor port walker
// ---------------------------------------------------------------------------
//
// The single source of truth for "how many input ports / output ports /
// samplers does each desc.inputs entry produce?", shared by CSF port_indices,
// RawRaster port_idx, RawRaster bindAuxTexturesInit and IsfBindingsBuilder.
// Mirrors `isf_input_port_vis` in ISFNode.cpp, which is the actual
// port-creation code.
//
// When a new isf::*_input variant is added, update isf_input_port_vis and the
// matching `operator()` here -- keep them in lockstep.
struct port_counts
{
  int inlets{};   
  int outlets{};  
  int samplers{}; 
 
  port_counts& operator+=(const port_counts& o) noexcept
  {
    inlets += o.inlets;
    outlets += o.outlets;
    samplers += o.samplers;
    return *this;
  }
};
 
// Returns the port_counts contributed by a single input variant. Mirrors
// isf_input_port_vis (ISFNode.cpp) one-to-one.
struct isf_input_port_count_vis
{
  bool raw_raster{};
 
  port_counts operator()(const isf::float_input&) const noexcept   { return {1, 0, 0}; }
  port_counts operator()(const isf::long_input&) const noexcept    { return {1, 0, 0}; }
  port_counts operator()(const isf::event_input&) const noexcept   { return {1, 0, 0}; }
  port_counts operator()(const isf::bool_input&) const noexcept    { return {1, 0, 0}; }
  port_counts operator()(const isf::point2d_input&) const noexcept { return {1, 0, 0}; }
  port_counts operator()(const isf::point3d_input&) const noexcept { return {1, 0, 0}; }
  port_counts operator()(const isf::color_input&) const noexcept   { return {1, 0, 0}; }
  port_counts operator()(const isf::audio_input&) const noexcept    { return {1, 0, 0}; }
  port_counts operator()(const isf::audioHist_input&) const noexcept{ return {1, 0, 0}; }
  port_counts operator()(const isf::audioFFT_input&) const noexcept { return {1, 0, 0}; }
 
  port_counts operator()(const isf::image_input& in) const noexcept
  {
    // GrabsFromSource means no own render target, so the matching depth
    // sampler (image_input.depth==true) is not created in initInputSamplers
    // either.
    const bool grabs = (in.dimensions == 3 || in.is_array || in.is_static);
    const int extra_depth_sampler = (in.depth && !grabs) ? 1 : 0;
    return {1, 0, 1 + extra_depth_sampler};
  }
  port_counts operator()(const isf::cubemap_input&) const noexcept { return {1, 0, 1}; }
  port_counts operator()(const isf::texture_input&) const noexcept { return {1, 0, 1}; }
 
  port_counts operator()(const isf::storage_input& in) const noexcept
  {
    // read_only: 1 input port (no output, no sampler).
    // write/read_write: 1 output port; +1 input port if the layout's last
    //   field is a flexible array (synthesized long_input for sizing).
    if(in.access == "read_only")
      return {1, 0, 0};
    port_counts c{0, 1, 0};
    if(!in.layout.empty()
       && in.layout.back().type.find("[]") != std::string::npos)
      c.inlets = 1;
    return c;
  }
 
  port_counts operator()(const isf::uniform_input&) const noexcept
  {
    return {1, 0, 0};
  }
 
  port_counts operator()(const isf::csf_image_input& in) const noexcept
  {
    // read_only: 1 input port; write/read_write: 1 output port (no input).
    if(in.access == "read_only")
      return {1, 0, 0};
    return {0, 1, 0};
  }
 
  port_counts operator()(const isf::geometry_input& in) const noexcept
  {
    port_counts c{};
    if(!raw_raster)
    {
      if(in.passes_through())
      {
        // Pass-through: 1 inlet + 1 outlet
        c.inlets = 1;
        c.outlets = 1;
      }
      else
      {
        if(in.reads_upstream())
          c.inlets = 1;
        for(const auto& attr : in.attributes)
          if(attr.access == "write_only" || attr.access == "read_write")
          { c.outlets = 1; break; }
      }
    }
    // $USER ports → synthesized long_input each (1 inlet)
    if(in.vertex_count.find("$USER") != std::string::npos)   c.inlets++;
    if(in.instance_count.find("$USER") != std::string::npos) c.inlets++;
    for(const auto& aux : in.auxiliary)
      if(aux.size.find("$USER") != std::string::npos)
        c.inlets++;
    return c;
  }
};
 
// Walk desc.inputs once. For each input, the visitor receives:
//   - the isf::input entry
//   - the cumulative port_counts BEFORE this input (so cur.inlets is the
//     index of the first input port this entry creates, if any)
//   - the per-input port_counts delta (how many ports this entry creates)
// Cumulative state is then advanced before moving on.
//
// Callers needing a non-zero starting offset (e.g. RawRaster's port 0 is
// the implicit Geometry input) can pass it in `start` — its inlets/outlets
// are accumulated upfront.
template <typename F>
inline void walk_descriptor_inputs(
    const isf::descriptor& desc, port_counts start, F&& fn)
{
  port_counts cur = start;
  for(const auto& inp : desc.inputs)
  {
    port_counts delta = ossia::visit(
        isf_input_port_count_vis{desc.mode == isf::descriptor::RawRaster}, inp.data);
    fn(inp, cur, delta);
    cur += delta;
  }
}
 
// Convenience overload: zero starting offset.
template <typename F>
inline void walk_descriptor_inputs(const isf::descriptor& desc, F&& fn)
{
  walk_descriptor_inputs(desc, port_counts{}, std::forward<F>(fn));
}
 
// Input port holding the element count of storage resource `name`'s trailing
// flexible array: the long_input isf_input_port_vis synthesizes for a written
// buffer. -1 when there is none, notably for a read_only buffer, whose one
// inlet is the buffer itself.
inline int storage_array_size_port(const isf::descriptor& desc, std::string_view name)
{
  int port = -1;
  walk_descriptor_inputs(
      desc, [&](const isf::input& inp, port_counts cur, port_counts delta) {
    if(port >= 0 || inp.name != name)
      return;
    if(auto* s = ossia::get_if<isf::storage_input>(&inp.data);
       s && s->access != "read_only" && delta.inlets == 1)
      port = cur.inlets;
  });
  return port;
}
 
struct isf_input_size_vis
{
  int sz{};
  void operator()(const isf::float_input&) noexcept { sz += 4; }
 
  void operator()(const isf::long_input&) noexcept { sz += 4; }
 
  void operator()(const isf::event_input&) noexcept
  {
    sz += 4; // bool
  }
 
  void operator()(const isf::bool_input&) noexcept
  {
    sz += 4; // bool
  }
 
  void operator()(const isf::point2d_input&) noexcept
  {
    if(sz % 8 != 0)
      sz += 4;
    sz += 2 * 4;
  }
 
  void operator()(const isf::point3d_input&) noexcept
  {
    while(sz % 16 != 0)
    {
      sz += 4;
    }
    sz += 3 * 4;
  }
 
  void operator()(const isf::color_input&) noexcept
  {
    while(sz % 16 != 0)
    {
      sz += 4;
    }
    sz += 4 * 4;
  }
 
  void operator()(const isf::image_input&) noexcept { }
  void operator()(const isf::cubemap_input&) noexcept { }
 
  void operator()(const isf::audio_input&) noexcept { }
  void operator()(const isf::audioFFT_input&) noexcept { }
  void operator()(const isf::audioHist_input&) noexcept { }
 
  // CSF-specific input handlers
  void operator()(const isf::storage_input& in) noexcept
  {
    // Must match what isf_input_port_vis (ISFNode.cpp) writes into the blob,
    // and the synthesized "size" int it creates: only a writable buffer whose
    // layout ends in a flexible-array member. Reserving for every write buffer
    // would desync this from the port visitor and the generated GLSL
    // Params/material_t block.
    if(in.access.contains("write") && !in.layout.empty()
       && in.layout.back().type.find("[]") != std::string::npos)
    {
      (*this)(isf::long_input{});
    }
  }
 
  void operator()(const isf::uniform_input&) noexcept
  {
    // UBO inputs are bound from an upstream Buffer port; they do not
    // contribute to the material UBO size.
  }
 
  void operator()(const isf::texture_input in) noexcept { }
 
  void operator()(const isf::csf_image_input& in) noexcept
  {
    // isf_input_port_vis writes nothing into the material blob for write
    // csf_image inputs (its point2d/long synthesis is commented out), so
    // reserve nothing here: the size visitor, the port visitor and the
    // generated uniform block must agree.
  }
 
  void operator()(const isf::geometry_input& in) noexcept
  {
    // Geometry inputs don't contribute to the material UBO size.
    // Their buffers are bound separately as SSBOs.
    // But $USER ports create long_input (int) entries in the material UBO.
    if(in.vertex_count.find("$USER") != std::string::npos)
      (*this)(isf::long_input{});
    if(in.instance_count.find("$USER") != std::string::npos)
      (*this)(isf::long_input{});
    for(const auto& aux : in.auxiliary)
      if(aux.size.find("$USER") != std::string::npos)
        (*this)(isf::long_input{});
  }
};
 
// The image-like and audio samplers of `desc` in the order libisf declares
// them: INPUTS order, an image-like input's port_counts::samplers and an
// audio / audioFFT / audioHist input's one in turn (isf.cpp, the material
// sampler loop). `image` holds the image-like inputs' samplers in port order,
// storage images left out; `audio` the audio inputs' in INPUTS order. Any the
// walk does not account for are appended, so none is lost.
//
// Binding the image ones first and the audio ones after, as the renderers
// did, swapped textures whenever an audio input came before an image input.
template <typename S>
std::vector<S> samplersInInputOrder(
    const isf::descriptor& desc, std::span<const S> image, std::span<const S> audio)
{
  std::vector<S> out;
  out.reserve(image.size() + audio.size());
  std::size_t i = 0, a = 0;
  walk_descriptor_inputs(desc, [&](const isf::input& inp, port_counts, port_counts delta) {
    if(ossia::get_if<isf::audio_input>(&inp.data)
       || ossia::get_if<isf::audioFFT_input>(&inp.data)
       || ossia::get_if<isf::audioHist_input>(&inp.data))
    {
      if(a < audio.size())
        out.push_back(audio[a++]);
      return;
    }
    for(int k = 0; k < delta.samplers && i < image.size(); k++)
      out.push_back(image[i++]);
  });
  out.insert(out.end(), image.begin() + i, image.end());
  out.insert(out.end(), audio.begin() + a, audio.end());
  return out;
}
}