MathMapping_generic.hpp

#pragma once
#include <Fx/MathHelpers.hpp>
#include <Fx/Types.hpp>
 
#include <ossia/dataflow/value_port.hpp>
 
#include <halp/callback.hpp>
namespace Nodes
{
template <typename State>
struct GenericMathMapping
{
  static void store_output_vec(auto& self, const auto& vec)
  {
    const auto n = std::min(vec.size(), self.pov.size());
    for(std::size_t i = 0; i < n; i++)
      self.pov[i] = vec[i];
  }
 
  static void store_output(auto& self, const ossia::value& v)
  {
    switch(v.get_type())
    {
      case ossia::val_type::NONE:
        break;
      case ossia::val_type::FLOAT:
        self.po = *v.target<float>();
        break;
      case ossia::val_type::VEC2F: {
        if constexpr(requires { self.pov; })
          store_output_vec(self, *v.target<ossia::vec2f>());
        break;
      }
      case ossia::val_type::VEC3F: {
        if constexpr(requires { self.pov; })
          store_output_vec(self, *v.target<ossia::vec3f>());
        break;
      }
      case ossia::val_type::VEC4F: {
        if constexpr(requires { self.pov; })
          store_output_vec(self, *v.target<ossia::vec4f>());
        break;
      }
      case ossia::val_type::LIST: {
        if constexpr(requires { self.pov; })
        {
          auto& arr = *v.target<std::vector<ossia::value>>();
          // pov is an exprtk vector *view* onto this buffer: it must keep both
          // its size and its data pointer, so write in place and drop anything
          // that does not fit rather than growing (and reallocating) it.
          const auto n = std::min(arr.size(), self.pov.size());
          for(std::size_t i = 0; i < n; i++)
            self.pov[i] = ossia::convert<float>(arr[i]);
        }
        break;
      }
      // Only these types are used now as per ossia::math_expression::result()
      default:
        break;
    }
  }
 
  static void exec_scalar(State& self, value_output_callback& output)
  {
    auto res = self.expr.result();
 
    self.px = self.x;
    if(!res.valid())
      return;
 
    store_output(self, res);
    output(res);
  }
 
  static bool exec_polyphonic(State& self, std::vector<ossia::value>& res)
  {
    const auto N = self.expressions.size();
    res.resize(N);
 
    for(std::size_t i = 0; i < N; i++)
    {
      auto& e = self.expressions[i];
      auto r = e.expr.result();
      if(!r.valid())
        return false;
 
      if constexpr(requires { e.x; })
        e.px = e.x;
 
      // Feeds `po` for the next cycle...
      store_output(e, r);
      // ... but the output is the expression's actual result, which may well be
      // a point rather than a scalar (`return [x, y]`).
      res[i] = std::move(r);
    }
    return true;
  }
 
  static void
  exec_array(State& self, value_output_callback& output, bool vector_size_did_change)
  {
    if(self.xv.empty())
      return;
 
    if(vector_size_did_change)
    {
      // xv and pxv are exprtk views: re-point both, then recompile so that the
      // new sizes are baked in. This can legitimately fail - `xv[2]` cannot
      // compile against a one-element input - in which case we simply produce
      // nothing until an input of a workable size arrives.
      self.pxv.resize(self.xv.size());
      self.expr.rebase_vector("xv", self.xv);
      self.expr.rebase_vector("pxv", self.pxv);
      self.expr.recompile();
    }
 
    if(!self.expr.valid())
      return;
 
    auto res = self.expr.result();
    store_output(self, res);
 
    // Save the previous input
    self.pxv.assign(self.xv.begin(), self.xv.end());
 
    if(res.valid())
      output(std::move(res));
  }
 
  static void run_scalar(
      const ossia::value& v, value_output_callback& output, const halp::tick_flicks& tk,
      State& self)
  {
    setMathExpressionTiming(
        self, tk.start_in_flicks, self.last_value_time, tk.relative_position);
    self.last_value_time = tk.start_in_flicks;
 
    switch(v.get_type())
    {
      case ossia::val_type::NONE:
        break;
      case ossia::val_type::IMPULSE:
        break;
      case ossia::val_type::INT:
        self.x = *v.target<int>();
        break;
      case ossia::val_type::FLOAT:
        self.x = *v.target<float>();
        break;
      case ossia::val_type::BOOL:
        self.x = *v.target<bool>() ? 1.f : 0.f;
        break;
      case ossia::val_type::STRING:
        self.x = ossia::convert<float>(v);
        break;
      case ossia::val_type::VEC2F:
        self.x = (*v.target<ossia::vec2f>())[0];
        break;
      case ossia::val_type::VEC3F:
        self.x = (*v.target<ossia::vec3f>())[0];
        break;
      case ossia::val_type::VEC4F:
        self.x = (*v.target<ossia::vec4f>())[0];
        break;
      case ossia::val_type::LIST: {
        auto& arr = *v.target<std::vector<ossia::value>>();
        if(!arr.empty())
          self.x = ossia::convert<float>(arr[0]);
        break;
      }
      case ossia::val_type::MAP: {
        auto& arr = *v.target<ossia::value_map_type>();
        if(!arr.empty())
          self.x = ossia::convert<float>(arr.begin()->second);
        break;
      }
    }
 
    GenericMathMapping::exec_scalar(self, output);
  }
 
  static bool resize(const std::string& expr, State& self, int sz)
  {
    if(std::ssize(self.expressions) == sz && expr == self.last_expression)
      return self.last_expression_ok;
 
    self.expressions.resize(sz);
    self.count = sz;
 
    bool ok = true;
    int i = 0;
    for(auto& e : self.expressions)
    {
      // init() adds the symbols and registers the symbol table; doing it again
      // on an expression that already has them would stack up duplicate symbol
      // tables every time the text changes.
      if(!std::exchange(e.initialized, true))
        e.init(self.cur_time, self.cur_deltatime, self.cur_pos, self.count);
 
      e.instance = i;
      if(!e.expr.set_expression(expr))
        ok = false;
      e.expr.seed_random(
          UINT64_C(0xda3e39cb94b95bdb), UINT64_C(0x853c49e6748fea9b) * (1 + i));
      i++;
    }
 
    // Remember the outcome, successful or not: an expression that does not
    // compile must not be re-parsed for all 1024 elements on every tick.
    self.last_expression = expr;
    self.last_expression_ok = ok;
    return ok;
  }
 
  static void run_polyphonic(
      int size, value_output_callback& output, const std::string& expr,
      const halp::tick_flicks& tk, State& self)
  {
    // `po` is the element's own previous output: an expression that reads it
    // needs one instance - with its own state - per element. Everything else
    // can go through a single expression re-evaluated for each index, which
    // also lets each element return a vector (`return [x, y]`).
    if(size <= 1 || uses_identifier(expr, "po"))
    {
      size = std::clamp(size, 0, 1024);
      if(!resize(expr, self, size))
        return;
 
      setMathExpressionTiming(
          self, tk.start_in_flicks, self.last_value_time, tk.relative_position);
      self.last_value_time = tk.start_in_flicks;
 
      std::vector<ossia::value> res;
      if(GenericMathMapping::exec_polyphonic(self, res))
        output(std::move(res));
    }
    else
    {
      if(!resize(expr, self, 1))
        return;
 
      setMathExpressionTiming(
          self, tk.start_in_flicks, self.last_value_time, tk.relative_position);
      self.last_value_time = tk.start_in_flicks;
 
      std::vector<ossia::value> res;
      res.resize(size);
      self.count = size;
      for(int i = 0; i < size; i++)
      {
        auto& e = self.expressions[0];
        e.instance = i;
        res[i] = e.expr.result();
        if(!res[i].valid())
          return;
 
        // po isn't used either store_output(e, res);
      }
      output(std::move(res));
    }
  }
 
  static void run_polyphonic(
      const ossia::value& value, value_output_callback& output, const std::string& expr,
      const halp::tick_flicks& tk, State& self)
  {
    setMathExpressionTiming(
        self, tk.start_in_flicks, self.last_value_time, tk.relative_position);
    self.last_value_time = tk.start_in_flicks;
    //auto ratio = st.modelToSamples();
    //auto parent_dur = tk.parent_duration.impl * ratio;
    //for(const ossia::timed_value& v : input.get_data())
    //{
    //  auto val = value.target<std::vector<ossia::value>>();
    //  if(!val)
    //    return;
 
    //  int64_t new_time = tk.prev_date.impl * ratio + timestamp;
    //  setMathExpressionTiming(self, new_time, self.last_value_time, parent_dur);
    //  self.last_value_time = new_time;
 
    switch(value.get_type())
    {
      case ossia::val_type::NONE:
        break;
      case ossia::val_type::IMPULSE:
        break;
      case ossia::val_type::INT:
        if(!resize(expr, self, 1))
          return;
        self.expressions[0].x = *value.target<int>();
        break;
      case ossia::val_type::FLOAT:
        if(!resize(expr, self, 1))
          return;
        self.expressions[0].x = *value.target<float>();
        break;
      case ossia::val_type::BOOL:
        if(!resize(expr, self, 1))
          return;
        self.expressions[0].x = *value.target<bool>() ? 1.f : 0.f;
        break;
      case ossia::val_type::STRING:
        if(!resize(expr, self, 1))
          return;
        self.expressions[0].x = ossia::convert<float>(value);
        break;
      case ossia::val_type::VEC2F:
        if(!resize(expr, self, 2))
          return;
        self.expressions[0].x = (*value.target<ossia::vec2f>())[0];
        self.expressions[1].x = (*value.target<ossia::vec2f>())[1];
        break;
      case ossia::val_type::VEC3F:
        if(!resize(expr, self, 3))
          return;
        self.expressions[0].x = (*value.target<ossia::vec3f>())[0];
        self.expressions[1].x = (*value.target<ossia::vec3f>())[1];
        self.expressions[2].x = (*value.target<ossia::vec3f>())[2];
        break;
      case ossia::val_type::VEC4F:
        if(!resize(expr, self, 4))
          return;
        self.expressions[0].x = (*value.target<ossia::vec4f>())[0];
        self.expressions[1].x = (*value.target<ossia::vec4f>())[1];
        self.expressions[2].x = (*value.target<ossia::vec4f>())[2];
        self.expressions[3].x = (*value.target<ossia::vec4f>())[3];
        break;
      case ossia::val_type::LIST: {
        auto& arr = *value.target<std::vector<ossia::value>>();
        const auto N = std::clamp((int)std::ssize(arr), 0, 1024);
        if(!resize(expr, self, N))
          return;
        for(int i = 0; i < N; i++)
          self.expressions[i].x = ossia::convert<float>(arr[i]);
        break;
      }
      case ossia::val_type::MAP: {
        auto& arr = *value.target<ossia::value_map_type>();
        const auto N = std::clamp((int)std::ssize(arr), 0, 1024);
        if(!resize(expr, self, N))
          return;
        int i = 0;
        for(auto& [k, v] : arr)
          self.expressions[i++].x = ossia::convert<float>(v);
        break;
      }
    }
 
    std::vector<ossia::value> res;
    if(GenericMathMapping::exec_polyphonic(self, res))
      output(std::move(res));
  }
 
  static void run_array(
      const ossia::value& value, value_output_callback& output,
      const halp::tick_flicks& tk, State& self)
  {
    //auto ratio = st.modelToSamples();
    //auto parent_dur = tk.parent_duration.impl * ratio;
    //for(const ossia::timed_value& v : input.get_data())
    //{
    //  int64_t new_time = tk.prev_date.impl * ratio + timestamp;
    //  setMathExpressionTiming(self, new_time, self.last_value_time, parent_dur);
    //  self.last_value_time = new_time;
 
    auto array_run_scalar = [&](float in) {
      auto old_size = self.xv.size();
      self.xv.assign(1, in);
      auto new_size = 1U;
      GenericMathMapping::exec_array(self, output, old_size != new_size);
    };
 
    switch(value.get_type())
    {
      case ossia::val_type::NONE:
        break;
      case ossia::val_type::IMPULSE:
        GenericMathMapping::exec_array(self, output, false);
        break;
      case ossia::val_type::INT:
        array_run_scalar(*value.target<int>());
        break;
      case ossia::val_type::FLOAT:
        array_run_scalar(*value.target<float>());
        break;
      case ossia::val_type::BOOL:
        array_run_scalar(*value.target<bool>() ? 1.f : 0.f);
        break;
      case ossia::val_type::STRING:
        array_run_scalar(ossia::convert<float>(value));
        break;
      case ossia::val_type::VEC2F: {
        auto& arr = *value.target<ossia::vec2f>();
        auto old_size = self.xv.size();
        self.xv.assign(arr.begin(), arr.end());
        auto new_size = 2U;
        GenericMathMapping::exec_array(self, output, old_size != new_size);
        break;
      }
      case ossia::val_type::VEC3F: {
        auto& arr = *value.target<ossia::vec3f>();
        auto old_size = self.xv.size();
        self.xv.assign(arr.begin(), arr.end());
        auto new_size = 3U;
        GenericMathMapping::exec_array(self, output, old_size != new_size);
        break;
      }
      case ossia::val_type::VEC4F: {
        auto& arr = *value.target<ossia::vec4f>();
        auto old_size = self.xv.size();
        self.xv.assign(arr.begin(), arr.end());
        auto new_size = 4U;
        GenericMathMapping::exec_array(self, output, old_size != new_size);
        break;
      }
      case ossia::val_type::LIST: {
        auto& arr = *value.target<std::vector<ossia::value>>();
        auto old_size = self.xv.size();
        self.xv.resize(arr.size());
        auto new_size = arr.size();
        for(std::size_t i = 0; i < arr.size(); i++)
        {
          self.xv[i] = ossia::convert<float>(arr[i]);
        }
        GenericMathMapping::exec_array(self, output, old_size != new_size);
        break;
      }
      case ossia::val_type::MAP: {
        auto& arr = *value.target<ossia::value_map_type>();
        auto old_size = self.xv.size();
        self.xv.resize(arr.size());
        auto new_size = arr.size();
        int i = 0;
        for(const auto& [k, v] : arr)
        {
          self.xv[i++] = ossia::convert<float>(v);
        }
        GenericMathMapping::exec_array(self, output, old_size != new_size);
        break;
      }
    }
    //}
  }
};
}