ISFProcess.hpp

#pragma once
 
#include <Process/Dataflow/WidgetInlets.hpp>
#include <Process/ProcessFactory.hpp>
 
#include <Explorer/DocumentPlugin/DeviceDocumentPlugin.hpp>
 
#include <Gfx/Graph/Utils.hpp>
#include <Gfx/LongInputControl.hpp>
#include <Gfx/TexturePort.hpp>
#include <Gfx/WindowDevice.hpp>
 
#include <score/tools/File.hpp>
 
#include <ossia/detail/flat_map.hpp>
 
#include <QFile>
 
#include <isf.hpp>
 
#include <algorithm>
 
namespace Gfx
{
struct ISFHelpers
{
  template <typename T>
  static QString firstWindowDeviceName(T& self)
  {
    auto& ctx = score::IDocument::documentContext(self);
    auto& device_plug = ctx.template plugin<Explorer::DeviceDocumentPlugin>();
    for(auto dev : device_plug.list().devices())
      if(auto win = qobject_cast<WindowDevice*>(dev))
        return win->name();
    return {};
  }
 
  template <typename T>
  static Process::Descriptor descriptorFromISFFile(QString path)
  {
    auto base = Metadata<Process::Descriptor_k, T>::get();
    if(path.isEmpty())
      return base;
 
    // The static author is the one of the process, not of the shader file:
    // a file that credits nobody has no known author.
    base.author.clear();
 
    QFile f{path};
    if(!f.open(QIODevice::ReadOnly))
      return base;
 
    try
    {
      auto [_, desc] = isf::parser::parse_isf_header(score::readFileAsString(f));
      if(desc.credits.starts_with("Automatically converted from "))
        desc.credits = desc.credits.substr(strlen("Automatically converted from "));
      else if(desc.credits.starts_with("by "))
        desc.credits = desc.credits.substr(strlen("by "));
      if(!desc.credits.empty())
        base.author = QString::fromStdString(desc.credits);
      if(!desc.description.empty())
        base.description = QString::fromStdString(desc.description);
      for(auto& cat : desc.categories)
        base.tags.push_back(QString::fromStdString(cat));
    }
    catch(...)
    {
    }
 
    return base;
  }
 
  template <typename T>
  static void setupISFModelPorts(
      T& self, const isf::descriptor& desc,
      const ossia::flat_map<QString, ossia::value>& previous_values)
  {
    /*
  {
    auto& [shader, error] = score::gfx::ShaderCache::get(
        m_processedProgram.vertex.toLatin1(), QShader::Stage::VertexStage);
    SCORE_ASSERT(error.isEmpty());
  }
  {
    auto& [shader, error] = score::gfx::ShaderCache::get(
        m_processedProgram.fragment.toLatin1(), QShader::Stage::FragmentStage);
    SCORE_ASSERT(error.isEmpty());
  }
  */
 
    int i = 0;
    using namespace isf;
 
    struct input_vis
    {
      const ossia::flat_map<QString, ossia::value>& previous_values;
      const isf::input& input;
      const int i;
      T& self;
      // Outlet id allocator for write-access storage / image inputs. Starts at
      // a high base so it never collides with inlet ids (input index `i`), the
      // default "Texture Out" outlet (id 1), or the MRT outlet base (10000).
      int& outlet_id;
      bool vsa;
 
      Process::Inlet* operator()(const float_input& v)
      {
        auto nm = QString::fromStdString(input.name);
        auto port = new Process::FloatSlider(
            v.min, v.max, v.def, nm, Id<Process::Port>(i), &self);
 
        self.m_inlets.push_back(port);
        if(auto it = previous_values.find(nm);
           it != previous_values.end()
           && it->second.get_type() == ossia::val_type::FLOAT)
          port->setValue(it->second);
 
        self.controlAdded(port->id());
        return port;
      }
 
      Process::Inlet* operator()(const long_input& v)
      {
        auto nm = QString::fromStdString(input.name);
 
        auto port = makeLongInputControl(v, nm, Id<Process::Port>(i), &self);
 
        if(auto it = previous_values.find(nm);
           it != previous_values.end()
           && it->second.get_type() == port->value().get_type())
          port->setValue(it->second);
 
        self.m_inlets.push_back(port);
        self.controlAdded(port->id());
        return port;
      }
 
      Process::Inlet* operator()(const event_input& v)
      {
        auto nm = QString::fromStdString(input.name);
        auto port = new Process::Button(nm, Id<Process::Port>(i), &self);
 
        self.m_inlets.push_back(port);
        self.controlAdded(port->id());
        return port;
      }
 
      Process::Inlet* operator()(const bool_input& v)
      {
        auto nm = QString::fromStdString(input.name);
        auto port = new Process::Toggle(v.def, nm, Id<Process::Port>(i), &self);
 
        if(auto it = previous_values.find(nm);
           it != previous_values.end()
           && it->second.get_type() == port->value().get_type())
          port->setValue(it->second);
 
        self.m_inlets.push_back(port);
        self.controlAdded(port->id());
        return port;
      }
 
      Process::Inlet* operator()(const point2d_input& v)
      {
        auto nm = QString::fromStdString(input.name);
        ossia::vec2f min{-100., -100.};
        ossia::vec2f max{100., 100.};
        ossia::vec2f init{0.0, 0.0};
        if(v.def)
          std::copy_n(v.def->begin(), 2, init.begin());
        if(v.min)
          std::copy_n(v.min->begin(), 2, min.begin());
        if(v.max)
          std::copy_n(v.max->begin(), 2, max.begin());
        auto port = new Process::XYSpinboxes{
            min, max, init, false, nm, Id<Process::Port>(i), &self};
 
        // The pointer addresses of the first window device (PointerAddresses.hpp),
        // set as any other address: shown on the inlet, changeable there.
        // vertexshaderart's `mouse` is clip space, -1..1, y up (src/js/main.js
        // recordMouseMove; src/index.html "mouse position normalized (-1 to
        // 1)"); in an ISF a `mouse` is 0..1, y up, an `iMouse` (Shadertoy) in
        // pixels.
        if(const QString win = ISFHelpers::firstWindowDeviceName(self); !win.isEmpty())
        {
          if(nm.contains("iMouse"))
            port->setAddress(
                State::AddressAccessor{State::Address{win, {"cursor", "absolute"}}});
          else if(vsa && nm == QStringLiteral("mouse"))
            port->setAddress(
                State::AddressAccessor{State::Address{win, {"cursor", "clip"}}});
          else if(nm.contains("mouse", Qt::CaseInsensitive))
            port->setAddress(
                State::AddressAccessor{State::Address{win, {"cursor", "gl"}}});
        }
 
        if(auto it = previous_values.find(nm);
           it != previous_values.end()
           && it->second.get_type() == port->value().get_type())
          port->setValue(it->second);
 
        self.m_inlets.push_back(port);
        self.controlAdded(port->id());
        return port;
      }
 
      Process::Inlet* operator()(const point3d_input& v)
      {
        auto nm = QString::fromStdString(input.name);
        ossia::vec3f min{-100., -100., -100.};
        ossia::vec3f max{100., 100., 100.};
        ossia::vec3f init{0., 0., 0.};
        if(v.def)
          std::copy_n(v.def->begin(), 3, init.begin());
        if(v.min)
          std::copy_n(v.min->begin(), 3, min.begin());
        if(v.max)
          std::copy_n(v.max->begin(), 3, max.begin());
        auto port = new Process::XYZSpinboxes{
            min, max, init, false, nm, Id<Process::Port>(i), &self};
 
        if(auto it = previous_values.find(nm);
           it != previous_values.end()
           && it->second.get_type() == port->value().get_type())
          port->setValue(it->second);
 
        self.m_inlets.push_back(port);
        self.controlAdded(port->id());
        return port;
      }
 
      Process::Inlet* operator()(const color_input& v)
      {
        auto nm = QString::fromStdString(input.name);
        ossia::vec4f init{0.5, 0.5, 0.5, 1.};
        if(v.def)
        {
          std::copy_n(v.def->begin(), 4, init.begin());
        }
        auto port = new Process::HSVSlider(
            init, QString::fromStdString(input.name), Id<Process::Port>(i), &self);
 
        if(auto it = previous_values.find(nm);
           it != previous_values.end()
           && it->second.get_type() == port->value().get_type())
          port->setValue(it->second);
 
        self.m_inlets.push_back(port);
        self.controlAdded(port->id());
        return port;
      }
      Process::Inlet* operator()(const image_input& v)
      {
        auto port = new Gfx::TextureInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
 
        // vertexshaderart's `touch`, in any shader format: the window's touch
        // history (PointerAddresses.hpp, TouchHistoryNode), read through a
        // target of its own size and format, NEAREST, clamped
        // (src/js/main.js: 32 x 240, FLOAT, NEAREST, CLAMP_TO_EDGE). All of it
        // is set on the inlet, where it shows and can be changed.
        if(input.name == "touch" && v.dimensions == 2 && !v.is_array && !v.is_static
           && !v.depth)
        {
          if(const QString win = ISFHelpers::firstWindowDeviceName(self); !win.isEmpty())
          {
            port->setAddress(
                State::AddressAccessor{State::Address{win, {"touch", "history"}}});
            port->setRenderSize(QSize{32, 240});
            port->setTextureFormat(ossia::texture_format::RGBA32F);
            port->setTextureFilter(ossia::texture_filter::NEAREST);
            port->setTextureAddressMode(ossia::texture_address_mode::CLAMP_TO_EDGE);
          }
        }
 
        self.m_inlets.push_back(port);
        return port;
      }
      Process::Inlet* operator()(const cubemap_input& v)
      {
        auto port = new Gfx::TextureInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
 
        self.m_inlets.push_back(port);
        return port;
      }
      Process::Inlet* operator()(const audio_input& v)
      {
        auto port = new Process::AudioInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
        self.m_inlets.push_back(port);
        return port;
      }
      Process::Inlet* operator()(const audioFFT_input& v)
      {
        auto port = new Process::AudioInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
        self.m_inlets.push_back(port);
        return port;
      }
      Process::Inlet* operator()(const audioHist_input& v)
      {
        auto port = new Process::AudioInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
        self.m_inlets.push_back(port);
        return port;
      }
      
      // CSF-specific input handlers
      Process::Inlet* operator()(const storage_input& v)
      {
        // Mirror the renderer (isf_input_port_vis in ISFNode.cpp): the access
        // qualifier decides inlet vs outlet. Treating every storage_input as a
        // read inlet would give write buffers a phantom TextureInlet, shifting
        // every later port by one (positional routing) and never exposing the
        // TextureOutlet the renderer produces.
        if(v.access == "read_only")
        {
          // read inlet: an upstream Buffer-producing node (ScenePreprocessor's
          // scene_* auxes, ExtractBuffer2 outputs, ...) has a target to land on.
          // For aux-named storage_inputs the RawRaster renderer also auto-binds
          // by name, so this inlet is optional but allows explicit wiring.
          auto port = new Gfx::TextureInlet(
              QString::fromStdString(input.name), Id<Process::Port>(i), &self);
          self.m_inlets.push_back(port);
          return port;
        }
 
        // write_only / read_write: the renderer pushes a Buffer output port for
        // the produced SSBO so downstream nodes can connect to it.
        auto outport = new Gfx::TextureOutlet(
            QString::fromStdString(input.name), Id<Process::Port>(outlet_id++),
            &self);
        self.m_outlets.push_back(outport);
 
        // Conditional sizing inlet: only buffers whose layout ends in a
        // flexible-array member synthesize a "size" control -- the same
        // condition as CSF/Process.cpp setupCSF, the renderer and the
        // generated GLSL.
        if(!v.layout.empty()
           && v.layout.back().type.find("[]") != std::string::npos)
        {
          auto size_inl = new Process::IntSpinBox{
              1, 536870911, 1024,
              QString::fromStdString(input.name) + " size",
              Id<Process::Port>(i), &self};
          self.m_inlets.push_back(size_inl);
          self.controlAdded(size_inl->id());
          return size_inl;
        }
        return nullptr;
      }
      Process::Inlet* operator()(const uniform_input& v)
      {
        // uniform_input expects an upstream Buffer port (ScenePreprocessor's
        // camera/env aux buffers, ExtractBuffer2 outputs, etc.). TextureInlet
        // is score's Process-layer inlet for SSBO / texture / UBO data flow.
        // Without this, the Process model has no inlet for the cable to land
        // on and Score.inlet(proc, i) returns null.
        auto port = new Gfx::TextureInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
        self.m_inlets.push_back(port);
        return port;
      }
      Process::Inlet* operator()(const texture_input& v)
      {
        // The renderer (isf_input_port_vis) creates an Image input port for
        // every texture_input, so the model must create the matching inlet:
        // returning nullptr here would shift every subsequent port.
        auto port = new Gfx::TextureInlet(
            QString::fromStdString(input.name), Id<Process::Port>(i), &self);
        self.m_inlets.push_back(port);
        return port;
      }
      Process::Inlet* operator()(const csf_image_input& v)
      {
        // Mirror the renderer: read_only → input port (an upstream texture
        // cable lands on it); write_only / read_write → output port for the
        // produced storage image. Always creating an inlet would give write
        // images a phantom inlet (port shift) and no outlet for downstream
        // connection.
        if(v.access == "read_only")
        {
          auto port = new Gfx::TextureInlet(
              QString::fromStdString(input.name), Id<Process::Port>(i), &self);
          self.m_inlets.push_back(port);
          return port;
        }
        auto outport = new Gfx::TextureOutlet(
            QString::fromStdString(input.name), Id<Process::Port>(outlet_id++),
            &self);
        self.m_outlets.push_back(outport);
        return nullptr;
      }
      Process::Inlet* operator()(const geometry_input& v) { return nullptr; }
    };
 
    // Outlet ids for write-access storage / image inputs. Base 20000 keeps
    // them clear of inlet ids (input index), the default outlet (id 1) and the
    // MRT base (10000), and lets the MRT block below tell them apart.
    static constexpr int storage_outlet_base = 20000;
    int outlet_id = storage_outlet_base;
 
    for(const isf::input& input : desc.inputs)
    {
      ossia::visit(
          input_vis{
              previous_values, input, i, self, outlet_id,
              desc.mode == isf::descriptor::VSA},
          input.data);
      i++;
    }
 
    // The renderer (isf_input_port_vis) pushes write-storage / write-image
    // output ports first (in input order), then the color / MRT outputs. The
    // model's outlets must follow the same order for positional routing. The
    // default "Texture Out" outlet was created by the constructor *before* this
    // loop, so it currently sits ahead of any storage outlets — pull the
    // storage outlets (ids >= storage_outlet_base) to the front to match.
    {
      std::stable_partition(
          self.m_outlets.begin(), self.m_outlets.end(),
          [](Process::Outlet* o) { return o->id().val() >= storage_outlet_base; });
    }
 
    // MRT: recreate the color outlets from OUTPUTS declarations. Preserve the
    // storage / image write outlets (ids >= storage_outlet_base); only the
    // color / default outlets are replaced.
    if(!desc.outputs.empty())
    {
      for(auto it = self.m_outlets.begin(); it != self.m_outlets.end();)
      {
        if((*it)->id().val() < storage_outlet_base)
        {
          delete *it;
          it = self.m_outlets.erase(it);
        }
        else
        {
          ++it;
        }
      }
 
      int outId = 10000; // High base to avoid ID collisions with inlets
      for(const auto& out : desc.outputs)
      {
        self.m_outlets.push_back(new Gfx::TextureOutlet{
            QString::fromStdString(out.name),
            Id<Process::Port>(outId++), &self});
      }
    }
  }
};
}