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

#pragma once
#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/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 <algorithm>
#include <optional>
#include <vector>
 
namespace score::gfx
{
class RenderList;
struct Graph;
class GenericNodeRenderer;
class NodeRenderer;
using FunctionMessage = std::function<void(score::gfx::Node&)>;
#if BOOST_VERSION < 107900
// Old boost: small_vector was not nothrow-move-constructible so we remove the check there.
using gfx_input = ossia::slow_variant<
    ossia::monostate, ossia::value, ossia::audio_vector, ossia::mesh_list_ptr,
    ossia::transform3d, FunctionMessage>;
#else
using gfx_input = ossia::variant<
    ossia::monostate, ossia::value, ossia::audio_vector, ossia::mesh_list_ptr,
    ossia::transform3d, FunctionMessage>;
#endif
 
struct Timings
{
  ossia::time_value date{};
  ossia::time_value parent_duration{};
};
 
struct Message
{
  int32_t node_id{};
  Timings token{};
  std::vector<gfx_input> input;
};
class SCORE_PLUGIN_GFX_EXPORT Node
{
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;
 
  bool addedToGraph{};
};
 
class SCORE_PLUGIN_GFX_EXPORT ProcessNode : public Node
{
public:
  using Node::Node;
 
  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 geometryChange() noexcept
  {
    geometryChanged.fetch_add(1, std::memory_order_release);
  }
  bool hasGeometryChanged(int64_t& renderer) const noexcept
  {
    int64_t res = geometryChanged.load(std::memory_order_acquire);
    if(renderer != res)
    {
      renderer = res;
      return true;
    }
    return false;
  }
  std::atomic_int64_t geometryChanged{-1};
 
  ProcessUBO standardUBO{};
 
  std::shared_ptr<ossia::mesh_list> geometry;
 
  void process(Message&& msg) override;
  void process(Timings tk);
  void process(int32_t port, const ossia::value& v);
  void process(int32_t port, const ossia::audio_vector& v);
  void process(int32_t port, const ossia::mesh_list_ptr& v);
  void process(int32_t port, const ossia::transform3d& v);
  void process(int32_t port, ossia::monostate) const noexcept { }
  void process(int32_t port, const FunctionMessage&);
};
 
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>&);