score-plugin-gfx/Gfx/Graph/Node.hpp

#pragma once
#include <memory>
#include <Gfx/Graph/CommonUBOs.hpp>
#include <Gfx/Graph/Mesh.hpp>
#include <Gfx/Graph/RenderState.hpp>
#include <Gfx/Graph/Uniforms.hpp>
#include <Gfx/Graph/Utils.hpp>
 
#include <ossia/dataflow/geometry_port.hpp>
#include <ossia/dataflow/nodes/media.hpp>
#include <ossia/dataflow/texture_port.hpp>
#include <ossia/dataflow/token_request.hpp>
#include <ossia/detail/flat_map.hpp>
#include <ossia/detail/variant.hpp>
#include <ossia/network/value/value.hpp>
 
#include <score_plugin_gfx_export.h>
 
#include <boost/version.hpp>
 
#include <algorithm>
#include <vector>
 
namespace score::gfx
{
struct PreviewTap;
}
 
namespace score::gfx
{
class RenderList;
struct Graph;
class GenericNodeRenderer;
class NodeRenderer;
using FunctionMessage = std::function<void(score::gfx::Node&)>;
#if BOOST_VERSION < 107900
#define a <::BOOST_VERSION>
#include a
#error Boost version not supported anymore
#endif
using gfx_input = ossia::variant<
    ossia::monostate, ossia::value, ossia::audio_vector, ossia::render_target_spec,
    ossia::transform3d, FunctionMessage, ossia::buffer_spec>;
 
struct Timings
{
  ossia::time_value date{};
  ossia::time_value parent_duration{};
  double sample_rate{};
};
 
struct Message
{
  int32_t node_id{};
  Timings token{};
  std::vector<gfx_input> input;
  uint64_t tick{};
};
 
struct RenderTargetSpecs
{
  QSize size;
 
  QRhiTexture::Format format = QRhiTexture::Format ::RGBA8;
 
  QRhiSampler::Filter mag_filter = QRhiSampler::Linear;
  QRhiSampler::Filter min_filter = QRhiSampler::Linear;
  QRhiSampler::Filter mipmap_mode = QRhiSampler::None;
 
  QRhiSampler::AddressMode address_u = QRhiSampler::Repeat;
  QRhiSampler::AddressMode address_v = QRhiSampler::Repeat;
  QRhiSampler::AddressMode address_w = QRhiSampler::Repeat;
 
  // Whether the inlet set the filters, the address modes, the mipmap mode.
  // A field it did not set is the shader's, when its JSON declares one
  // (resolveSamplerFields, shader board U34).
  bool filter_set{};
  bool address_set{};
  bool mipmap_set{};
};
 
inline constexpr int unsetSamplerField = 3;
inline bool isUnsetSamplerField(auto v) noexcept
{
  return (unsigned(v) & 3u) == unsigned(unsetSamplerField);
}
 
SCORE_PLUGIN_GFX_EXPORT
RenderTargetSpecs toRenderTargetSpecs(const ossia::render_target_spec& in) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
void resolveSamplerFields(RenderTargetSpecs& spec, const isf::sampler_config& cfg) noexcept;
 
class SCORE_PLUGIN_GFX_EXPORT Node : public QObject
{
public:
  explicit Node();
  virtual ~Node();
 
  Node(const Node&) = delete;
  Node(Node&&) = delete;
  Node& operator=(const Node&) = delete;
  Node& operator=(Node&&) = delete;
 
  virtual NodeRenderer* createRenderer(RenderList& r) const noexcept = 0;
 
  virtual void renderedNodesChanged();
 
  virtual void process(Message&& msg);
  virtual void update();
 
  std::vector<Port*> input;
  ossia::small_pod_vector<Port*, 1> output;
 
  ossia::flat_map<RenderList*, score::gfx::NodeRenderer*> renderedNodes;
 
  std::vector<std::shared_ptr<PreviewTap>> previewTaps;
 
  ossia::flat_map<int32_t, ossia::render_target_spec> renderTargetSpecs;
 
  void materialChange() noexcept
  {
    materialChanged.fetch_add(1, std::memory_order_release);
  }
  bool hasMaterialChanged(int64_t& renderer) const noexcept
  {
    int64_t res = materialChanged.load(std::memory_order_acquire);
    if(renderer != res)
    {
      renderer = res;
      return true;
    }
    return false;
  }
  std::atomic_int64_t materialChanged{0};
 
  void renderTargetChange() noexcept
  {
    renderTargetSpecChanged.fetch_add(1, std::memory_order_release);
  }
  bool hasRenderTargetChanged(int64_t& renderer) const noexcept
  {
    int64_t res = renderTargetSpecChanged.load(std::memory_order_acquire);
    if(renderer != res)
    {
      renderer = res;
      return true;
    }
    return false;
  }
  std::atomic_int64_t renderTargetSpecChanged{-1};
 
  int32_t nodeId = score::gfx::invalid_node_index;
  bool requiresDepth{};
 
  bool hasExplicitRenderTargetSize(int32_t port) const noexcept
  {
    auto it = renderTargetSpecs.find(port);
    return it != renderTargetSpecs.end() && it->second.size.has_value();
  }
 
  bool hasExplicitRenderTargetSpecs(int32_t port) const noexcept
  {
    auto it = renderTargetSpecs.find(port);
    return it != renderTargetSpecs.end()
           && (it->second.size.has_value() || it->second.format_set
               || it->second.format != ossia::texture_format::RGBA8);
  }
 
  QSize resolveRenderTargetSize(int32_t port, RenderList& renderer) const noexcept;
  RenderTargetSpecs
  resolveRenderTargetSpecs(int32_t port, RenderList& renderer) const noexcept;
 
  virtual void adjustRenderTargetSpecs(int32_t port, RenderTargetSpecs& spec) const noexcept;
 
  std::optional<RenderTargetSpecs> firstInputRenderTargetSpecs() const noexcept;
 
  void process(int32_t port, const ossia::render_target_spec& v);
};
 
class SCORE_PLUGIN_GFX_EXPORT ProcessNode : public Node
{
public:
  using Node::Node;
 
  ProcessUBO standardUBO{};
 
  void process(Message&& msg) override;
  virtual void process(Timings tk);
  virtual void process(int32_t port, const ossia::value& v);
  virtual void process(int32_t port, const ossia::audio_vector& v);
  // virtual void process(int32_t port, const ossia::geometry_spec& v);
  virtual void process(int32_t port, const ossia::transform3d& v);
  void process(int32_t port, ossia::monostate) const noexcept { }
  virtual void process(int32_t port, const FunctionMessage&);
  virtual void process(int32_t port, const ossia::buffer_spec&);
  using Node::process;
 
  std::vector<int*> m_event_ports;
 
  [[nodiscard]] bool resetEventPortsAfterFrame() noexcept
  {
    bool fired = false;
    for(int* p : m_event_ports)
    {
      if(p && *p != 0)
      {
        *p = 0;
        fired = true;
      }
    }
    return fired;
  }
 
protected:
  bool fireEventPort(int32_t port, const ossia::value& v) noexcept
  {
    if(!v.target<ossia::impulse>() || port < 0 || port >= int(this->input.size()))
      return false;
    auto* data = static_cast<int*>(this->input[port]->value);
    if(std::find(m_event_ports.begin(), m_event_ports.end(), data)
       == m_event_ports.end())
      return false;
    *data = 1;
    this->materialChange();
    return true;
  }
};
 
class SCORE_PLUGIN_GFX_EXPORT NodeModel : public score::gfx::ProcessNode
{
public:
  explicit NodeModel();
  virtual ~NodeModel();
 
  virtual score::gfx::NodeRenderer*
  createRenderer(RenderList& r) const noexcept override;
 
protected:
  std::unique_ptr<char[]> m_materialData;
 
  friend class GenericNodeRenderer;
};
}
 
// QDebug operator<<(QDebug, const score::gfx::gfx_input&);
QDebug operator<<(QDebug, const std::vector<score::gfx::gfx_input>&);