LFO_v2.hpp

#pragma once
#include <Fx/LFO.hpp>
#include <Fx/Types.hpp>
 
#include <ossia/detail/flicks.hpp>
#include <ossia/detail/math.hpp>
 
#include <halp/controls.hpp>
#include <halp/layout.hpp>
#include <halp/meta.hpp>
#include <halp/midi.hpp>
#include <rnd/random.hpp>
#include <tuplet/tuple.hpp>
 
#include <numbers>
#include <random>
 
namespace Nodes::LFO::v2
{
struct Node
{
  halp_meta(name, "LFO")
  halp_meta(c_name, "LFO")
  halp_meta(category, "Control/Generators")
  halp_meta(author, "ossia score")
  halp_meta(manual_url, "https://ossia.io/score-docs/processes/lfo.html#lfo")
  halp_meta(description, "Low-frequency oscillator")
  halp_meta(recommended_height, 130.)
  halp_meta(uuid, "1e17e479-3513-44c8-a8a7-017be9f6ac8a");
 
  struct ins
  {
    halp::log_hslider_f32<"Freq.", halp::range{0.01f, 100.f, 1.f}> freq;
    halp::knob_f32<"Ampl.", halp::range{0., 2., 0.5}> ampl;
    halp::knob_f32<"Offset", halp::range{-1., 1., 0.5}> offset;
    halp::knob_f32<"Jitter", halp::range{0., 1., 0}> jitter;
    halp::knob_f32<"Phase", halp::range{-1., 1., 0.}> phase;
    struct : halp::enum_t<Control::Widgets::Waveform, "Waveform">
    {
      static constexpr auto pixmaps()
      {
        return std::array<const char*, 16>{
            ":/icons/wave_sin_off.png",
            ":/icons/wave_sin_on.png",
            ":/icons/wave_triangle_off.png",
            ":/icons/wave_triangle_on.png",
            ":/icons/wave_saw_off.png",
            ":/icons/wave_saw_on.png",
            ":/icons/wave_square_off.png",
            ":/icons/wave_square_on.png",
            ":/icons/wave_sample_and_hold_off.png",
            ":/icons/wave_sample_and_hold_on.png",
            ":/icons/wave_noise1_off.png",
            ":/icons/wave_noise1_on.png",
            ":/icons/wave_noise2_off.png",
            ":/icons/wave_noise2_on.png",
            ":/icons/wave_noise3_off.png",
            ":/icons/wave_noise3_on.png"};
      }
    } waveform;
    quant_selector<"Quantification"> quant;
 
  } inputs;
  struct
  {
    // FIXME output range ???
    struct : halp::val_port<"Out", std::optional<float>>
    {
      struct range
      {
        float min = 0.;
        float max = 1.;
      };
    } out;
  } outputs;
 
  double phase{};
  rnd::pcg rd{random_source()};
 
  using tick = halp::tick_flicks;
  void operator()(const halp::tick_flicks& tk)
  {
    const auto quantif = inputs.quant.value;
    const auto ampl = inputs.ampl.value;
    const auto offset = inputs.offset.value;
    const auto jitter = inputs.jitter.value;
    const auto custom_phase = inputs.phase.value;
    const auto type = inputs.waveform.value;
 
    double ph_delta{};
 
    if(quantif)
    {
      if(tk.unexpected_bar_change())
        this->phase = 0;
 
      const double bar_length = 4.0 * tk.signature.num / tk.signature.denom;
      const double quarters_elapsed
          = tk.end_position_in_quarters - tk.start_position_in_quarters;
      const double quarters_per_cycle = bar_length * quantif * 2.;
 
      ph_delta = (quarters_elapsed / quarters_per_cycle) * 2.0 * std::numbers::pi;
    }
    else
    {
      constexpr double sine_ratio = ossia::two_pi / ossia::flicks_per_second<double>;
      ph_delta = tk.model_read_duration() * inputs.freq.value * sine_ratio;
    }
 
    double ph = this->phase;
    if(jitter > 0)
      ph += std::normal_distribution<float>(0., 0.25)(this->rd) * jitter;
 
    ph += custom_phase;
 
    using namespace Control::Widgets;
    const auto add_val
        = [&](auto new_val) { outputs.out.value = ampl * new_val + offset; };
 
    switch(type)
    {
      case Sin:
        add_val(std::sin(ph));
        break;
      case Triangle:
        add_val(std::asin(std::sin(ph)) / ossia::half_pi);
        break;
      case Saw:
        add_val(std::atan(std::tan(ph)) / ossia::half_pi);
        break;
      case Square:
        add_val((std::sin(ph) > 0.f) ? 1.f : -1.f);
        break;
      case SampleAndHold: {
        const auto start_s = std::sin(ph);
        const auto end_s = std::sin(ph + ph_delta);
        if((start_s > 0 && end_s <= 0) || (start_s <= 0 && end_s > 0))
          add_val(std::uniform_real_distribution<float>(-1.f, 1.f)(this->rd));
        break;
      }
      case Noise1:
        add_val(std::uniform_real_distribution<float>(-1.f, 1.f)(this->rd));
        break;
      case Noise2:
        add_val(std::normal_distribution<float>(0.f, 1.f)(this->rd));
        break;
      case Noise3:
        add_val(
            std::clamp(std::cauchy_distribution<float>(0.f, 1.f)(this->rd), 0.f, 1.f));
        break;
    }
 
    this->phase += ph_delta;
    if(this->phase > 1e6)
      this->phase = std::fmod(this->phase, 2.0 * std::numbers::pi);
  }
 
  struct ui
  {
    halp_meta(layout, halp::layouts::hbox)
    struct
    {
      halp_meta(layout, halp::layouts::vbox)
      halp_meta(background, halp::colors::background_mid)
      struct
      {
        halp_meta(layout, halp::layouts::hbox)
 
        halp::control<&ins::freq> f;
        halp::control<&ins::quant> q;
      } timing;
      halp::control<&ins::waveform> w;
    } gen;
 
    struct
    {
      halp_meta(layout, halp::layouts::vbox)
      halp_meta(background, halp::colors::background_mid)
      halp::control<&ins::ampl> a;
      halp::control<&ins::offset> o;
    } ampl;
    struct
    {
      halp_meta(layout, halp::layouts::vbox)
      halp_meta(background, halp::colors::background_mid)
      halp::control<&ins::jitter> j;
      halp::control<&ins::phase> p;
    } modulation;
  };
};
}