wip/pico next 2

ci/common.deps.sh

@@ -46,6 +46,8 @@ then
   clone_addon https://github.com/ossia/score-addon-deuterium
 fi
 
+cd score-addon-led
+git checkout feature/gfx_led
 )
 
 

src/plugins/score-lib-device/CMakeLists.txt

@@ -26,6 +26,8 @@ set(HEADERS
 "${CMAKE_CURRENT_SOURCE_DIR}/Device/Widgets/DeviceCompleter.hpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Device/Widgets/DeviceModelProvider.hpp"
 
+"${CMAKE_CURRENT_SOURCE_DIR}/Device/CodeWriter.hpp"
+
 "${CMAKE_CURRENT_SOURCE_DIR}/score_lib_device.hpp"
 )
 
@@ -54,6 +56,7 @@ set(SRCS
 
 "${CMAKE_CURRENT_SOURCE_DIR}/Device/Widgets/DeviceCompleter.cpp"
 
+"${CMAKE_CURRENT_SOURCE_DIR}/Device/CodeWriter.cpp"
 )
 
 add_library(score_lib_device ${SRCS} ${HEADERS})

src/plugins/score-lib-device/Device/CodeWriter.cpp

@@ -0,0 +1,11 @@
+#include "CodeWriter.hpp"
+
+namespace Device
+{
+CodeWriter::CodeWriter(const DeviceInterface& p) noexcept
+    : self{p}
+{
+}
+
+CodeWriter::~CodeWriter() = default;
+}

src/plugins/score-lib-device/Device/CodeWriter.hpp

@@ -0,0 +1,29 @@
+#pragma once
+#include <score_lib_device_export.h>
+
+#include <string>
+namespace Device
+{
+class DeviceInterface;
+class SCORE_LIB_DEVICE_EXPORT CodeWriter
+{
+public:
+  explicit CodeWriter(const DeviceInterface& p) noexcept;
+  virtual ~CodeWriter();
+
+  CodeWriter() = delete;
+  CodeWriter(const CodeWriter&) = delete;
+  CodeWriter(CodeWriter&&) = delete;
+  CodeWriter& operator=(const CodeWriter&) = delete;
+  CodeWriter& operator=(CodeWriter&&) = delete;
+
+  virtual std::string init() = 0;
+  virtual std::string readPins() = 0;
+  virtual std::string readOSC() = 0;
+  virtual std::string writePins() = 0;
+  virtual std::string writeOSC() = 0;
+
+protected:
+  const Device::DeviceInterface& self;
+};
+}

src/plugins/score-lib-process/CMakeLists.txt

@@ -12,6 +12,7 @@ set(PROCESS_HDRS
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/Commands/SetControlValue.hpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/Commands/Properties.hpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/ApplicationPlugin.hpp"
+"${CMAKE_CURRENT_SOURCE_DIR}/Process/CodeWriter.hpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/ControlMessage.hpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/Instantiations.hpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/ExecutionFunctions.hpp"
@@ -116,6 +117,7 @@ set(PROCESS_SRCS
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/State/MessageNodeSerialization.cpp"
 
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/ApplicationPlugin.cpp"
+"${CMAKE_CURRENT_SOURCE_DIR}/Process/CodeWriter.cpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/ControlMessage.cpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/HeaderDelegate.cpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/Process/ProcessFactory.cpp"

src/plugins/score-lib-process/Process/CodeFormat.hpp

@@ -0,0 +1,8 @@
+#pragma once
+namespace Process
+{
+enum class CodeFormat
+{
+  Cpp
+};
+}

src/plugins/score-lib-process/Process/CodeWriter.cpp

@@ -0,0 +1,176 @@
+#include "CodeWriter.hpp"
+
+#include <Process/Dataflow/Port.hpp>
+#include <Process/Process.hpp>
+
+#include <ossia/detail/algorithms.hpp>
+#include <ossia/network/value/value_conversion.hpp>
+#include <ossia/network/domain/domain.hpp>
+
+#include <fmt/format.h>
+namespace Process
+{
+
+CodeWriter::CodeWriter(const ProcessModel& p) noexcept
+    : self{p}
+{
+}
+
+CodeWriter::~CodeWriter() { }
+
+std::string DummyCodeWriter::initializer() const noexcept
+{
+  return "";
+}
+
+std::string DummyCodeWriter::typeName() const noexcept
+{
+  return "Dummy";
+}
+
+std::string DummyCodeWriter::accessInlet(const Id<Port>& id) const noexcept
+{
+  return "Dummy::variable";
+}
+
+std::string DummyCodeWriter::accessOutlet(const Id<Port>& id) const noexcept
+{
+  return "Dummy::variable";
+}
+
+std::string DummyCodeWriter::execute() const noexcept
+{
+  qDebug() << "!! Generating Dummy code writing for: " << typeid(self).name();
+  return {};
+}
+
+struct PortValueToInitString
+{
+  std::string res;
+  void operator()(const auto& domain, const ossia::impulse& value)
+  {
+    res = "halp::impulse{}";
+  }
+  void operator()(const auto& domain, const float& value)
+  {
+    res = std::to_string(value);
+  }
+  void operator()(const auto& domain, const ossia::vec2f& value)
+  {
+    res = fmt::format("std::array<float, 2>{{ {}, {} }}", value[0], value[1]);
+  }
+  void operator()(const auto& domain, const ossia::vec3f& value)
+  {
+    res = fmt::format(
+        "std::array<float, 3>{{ {}, {} , {} }}", value[0], value[1], value[2]);
+  }
+  void operator()(const auto& domain, const ossia::vec4f& value)
+  {
+    res = fmt::format(
+        "std::array<float, 4>{{ {}, {} , {}, {} }}", value[0], value[1], value[2],
+        value[3]);
+  }
+  void operator()(const auto& domain, const int& value) { res = std::to_string(value); }
+  void operator()(const auto& domain, const bool& value)
+  {
+    res = value ? "true" : "false";
+  }
+  void operator()(const auto& domain, const std::string& value)
+  {
+    res.reserve(value.size() + 2);
+    res += "\"";
+    res += value;
+    res += "\"";
+  }
+  void operator()(const auto& domain, const std::vector<ossia::value>& value)
+  {
+    res += "{";
+    for(auto& v : value)
+    {
+      //FIXME
+      res += ossia::convert<float>(v);
+      res += ", ";
+    }
+    res += "}";
+  }
+  void operator()(const auto& domain, const ossia::value_map_type& value)
+  {
+    res += "{";
+    for(auto& [k, v] : value)
+    {
+      //FIXME
+      res += "{";
+      res += "\"" + k + "\"";
+      res += ", ";
+      res += ossia::convert<float>(v);
+      res += "}";
+      res += ", ";
+    }
+    res += "}";
+  }
+
+  void
+  operator()(const ossia::domain_base<std::string>& domain, const std::string& value)
+  {
+    auto i = ossia::index_in_container(domain.values, value);
+    if(i != -1)
+      res = std::to_string(i);
+    else
+    {
+      res.reserve(value.size() + 2);
+      res += "\"";
+      res += value;
+      res += "\"";
+    }
+  }
+  void operator()(const auto& domain, const auto& value) = delete;
+};
+
+std::string AvndCodeWriter::initializer() const noexcept
+{
+  std::string init_list;
+  for(const Process::Inlet* in : this->self.inlets())
+  {
+    if(auto c = qobject_cast<const Process::ControlInlet*>(in))
+    {
+      PortValueToInitString str;
+      if(auto dom = c->domain().get())
+        ossia::apply(str, dom.v, c->value().v);
+      else
+        str.res = "";
+      // qDebug() << ossia::value_to_pretty_string(c->value()) << " => " << str.res;
+      auto name = c->exposed();
+
+      if(auto it = name.indexOf('('); it != -1)
+        name = name.mid(0, it);
+      name.replace(" ", "_");
+      name.replace(".", "_");
+      init_list += fmt::format(".{} = {{ {} }}, ", name.toStdString(), str.res);
+    }
+  }
+  return fmt::format(".inputs = {{ {} }}", init_list);
+}
+
+std::string AvndCodeWriter::accessInlet(const Id<Port>& id) const noexcept
+{
+  int index = ossia::index_in_container(this->self.inlets(), id);
+  return fmt::format(
+      "(avnd::input_introspection<{}>::field<{}>({}.inputs))", typeName(), index,
+      variable);
+}
+
+std::string AvndCodeWriter::accessOutlet(const Id<Port>& id) const noexcept
+{
+  int index = ossia::index_in_container(this->self.outlets(), id);
+  return fmt::format(
+      "(avnd::output_introspection<{}>::field<{}>({}.outputs))", typeName(), index,
+      variable);
+}
+
+std::string AvndCodeWriter::execute() const noexcept
+{
+  return fmt::format(
+      "avnd_clean_outputs({0}); avnd_call({0}); avnd_clean_inputs({0}); ", variable);
+}
+
+}

src/plugins/score-lib-process/Process/CodeWriter.hpp

@@ -0,0 +1,61 @@
+#pragma once
+#include <score/model/Identifier.hpp>
+
+#include <score_lib_process_export.h>
+
+#include <string>
+namespace Process
+{
+class ProcessModel;
+class Port;
+class Inlet;
+class ControlInlet;
+class Outlet;
+
+class SCORE_LIB_PROCESS_EXPORT CodeWriter
+{
+public:
+  const ProcessModel& self;
+  explicit CodeWriter(const ProcessModel& p) noexcept;
+  virtual ~CodeWriter();
+
+  CodeWriter() = delete;
+  CodeWriter(const CodeWriter&) = delete;
+  CodeWriter(CodeWriter&&) = delete;
+  CodeWriter& operator=(const CodeWriter&) = delete;
+  CodeWriter& operator=(CodeWriter&&) = delete;
+
+  std::string variable;
+
+  virtual std::string typeName() const noexcept = 0;
+  virtual std::string initializer() const noexcept = 0;
+  virtual std::string accessInlet(const Id<Process::Port>& id) const noexcept = 0;
+  virtual std::string accessOutlet(const Id<Process::Port>& id) const noexcept = 0;
+  virtual std::string execute() const noexcept = 0;
+};
+
+class SCORE_LIB_PROCESS_EXPORT DummyCodeWriter : public Process::CodeWriter
+{
+public:
+  using Process::CodeWriter::CodeWriter;
+
+  std::string typeName() const noexcept override;
+  std::string initializer() const noexcept override;
+  std::string accessInlet(const Id<Process::Port>& id) const noexcept override;
+  std::string accessOutlet(const Id<Process::Port>& id) const noexcept override;
+  std::string execute() const noexcept override;
+};
+
+struct SCORE_LIB_PROCESS_EXPORT AvndCodeWriter : Process::CodeWriter
+{
+  using Process::CodeWriter::CodeWriter;
+
+  std::string initializer() const noexcept override;
+
+  std::string accessInlet(const Id<Process::Port>& id) const noexcept override;
+
+  std::string accessOutlet(const Id<Process::Port>& id) const noexcept override;
+
+  std::string execute() const noexcept override;
+};
+}

src/plugins/score-lib-process/Process/Process.cpp

@@ -2,6 +2,7 @@
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 #include "Process.hpp"
 
+#include <Process/CodeWriter.hpp>
 #include <Process/Dataflow/Port.hpp>
 #include <Process/ExpandMode.hpp>
 #include <Process/PresetHelpers.hpp>
@@ -129,6 +130,11 @@ QString ProcessModel::prettyName() const noexcept
   return metadata().getName();
 }
 
+std::unique_ptr<CodeWriter> ProcessModel::codeWriter(CodeFormat) const noexcept
+{
+  return std::make_unique<DummyCodeWriter>(*this);
+}
+
 void ProcessModel::setParentDuration(ExpandMode mode, const TimeVal& t) noexcept
 {
   switch(mode)

src/plugins/score-lib-process/Process/Process.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <Process/Dataflow/PortForward.hpp>
+#include <Process/CodeFormat.hpp>
 #include <Process/ExpandMode.hpp>
 #include <Process/Preset.hpp>
 #include <Process/ProcessFlags.hpp>
@@ -49,6 +50,7 @@ class ProcessModel;
 class LayerFactory;
 struct Inlets;
 struct Outlets;
+class CodeWriter;
 
 /**
  * @brief The Process class
@@ -83,6 +85,7 @@ class SCORE_LIB_PROCESS_EXPORT ProcessModel
   virtual QString category() const noexcept = 0;
   virtual QStringList tags() const noexcept = 0;
   virtual ProcessFlags flags() const noexcept = 0;
+  virtual std::unique_ptr<CodeWriter> codeWriter(CodeFormat) const noexcept;
 
   //// Features of a process
   /// Duration