PatternModel.hpp

#pragma once
#include <Process/Process.hpp>
 
#include <Patternist/PatternMetadata.hpp>
 
#include <score_plugin_midi_export.h>
 
#include <verdigris>
 
namespace Process
{
class ControlInlet;
class ValueOutlet;
}
namespace Patternist
{
 
enum class Note : uint8_t
{
  Rest,
  Note,
  Legato
};
}
 
Q_DECLARE_METATYPE(Patternist::Note)
W_REGISTER_ARGTYPE(Patternist::Note)
 
namespace Patternist
{
 
enum class Condition : uint8_t
{
  Always,
  Fill,
  NotFill,
  First,
  NotFirst,
  Cycle
};
 
struct StepParams
{
  float velocity{1.f};
  float velocityRandom{0.f};
  float chance{1.f};
  float offset{0.f};
  float offsetRandom{0.f};
  float gate{1.f};
  float gateRandom{0.f};
  uint8_t ratchet{1};
  float pace{0.f};
  int8_t pitch{0};
  uint8_t pitchRandom{0};
  Condition condition{Condition::Always};
  uint8_t cycleA{1};
  uint8_t cycleB{2};
 
  bool operator==(const StepParams&) const noexcept = default;
  bool isDefault() const noexcept { return *this == StepParams{}; }
};
 
inline bool euclidHit(int i, int steps, int pulses, int rotation) noexcept
{
  if(steps <= 0 || pulses <= 0)
    return false;
  if(pulses >= steps)
    return true;
  const int j = (((i - rotation) % steps) + steps) % steps;
  return (j * pulses) % steps < pulses;
}
 
struct Lane
{
  std::vector<Patternist::Note> pattern;
  uint8_t note{};
  bool mute{};
  bool solo{};
  int length{};
  int division{};
  float velocity{100.f / 127.f};
  std::vector<StepParams> params;
  enum RandomPerHit : uint8_t
  {
    VelocityPerHit = 1,
    PitchPerHit = 2,
    TimingPerHit = 4,
    GatePerHit = 8
  };
  uint8_t randomPerHit{};
 
  bool operator==(const Lane& other) const noexcept = default;
};
 
inline constexpr uint8_t accentLane = 255;
inline constexpr uint8_t slideLane = 254;
inline bool isControlLane(const Lane& l) noexcept
{
  return l.note == accentLane || l.note == slideLane;
}
 
struct Pattern
{
  static const constexpr int maxLength = 128;
  static const constexpr int maxLanes = 128;
  static const constexpr int maxDivision = 64;
 
  int length{16};
  int division{16};
  std::vector<Lane> lanes;
 
  bool operator==(const Pattern& other) const noexcept
  {
    return length == other.length && division == other.division && lanes == other.lanes;
  }
};
 
SCORE_PLUGIN_MIDI_TEST_EXPORT void normalize(Pattern& p) noexcept;
 
inline bool anySolo(const Pattern& p) noexcept
{
  for(const Lane& l : p.lanes)
    if(l.solo)
      return true;
  return false;
}
 
inline int laneLength(const Pattern& p, const Lane& l) noexcept
{
  return l.length > 0 ? l.length : p.length;
}
 
inline int laneDivision(const Pattern& p, const Lane& l) noexcept
{
  return l.division > 0 ? l.division : p.division;
}
 
inline Note writtenNote(const Pattern& p, const Lane& l, int step) noexcept
{
  return (step >= 0 && step < int(l.pattern.size())) ? l.pattern[step] : Note::Rest;
}
 
inline const StepParams& stepParams(const Lane& l, int step) noexcept
{
  static const StepParams defaults;
  return (step >= 0 && step < int(l.params.size())) ? l.params[step] : defaults;
}
 
inline bool tieStrikes(const Pattern& p, const Lane& l, int step) noexcept
{
  const int len = laneLength(p, l);
  if(len <= 0)
    return true;
  const int prev = ((step - 1) % len + len) % len;
  if(writtenNote(p, l, prev) == Note::Rest)
    return true;
  const StepParams& sp = stepParams(l, step);
  const StepParams& pp = stepParams(l, prev);
  const bool spread
      = !(l.randomPerHit & Lane::PitchPerHit) && (sp.pitchRandom > 0 || pp.pitchRandom > 0);
  return sp.ratchet > 1 || sp.pitch != pp.pitch || spread;
}
 
inline int struckStep(const Pattern& p, const Lane& l, int step) noexcept
{
  const int len = laneLength(p, l);
  for(int k = 0; k < len; k++)
  {
    if(writtenNote(p, l, step) != Note::Legato || tieStrikes(p, l, step))
      return step;
    step = ((step - 1) % len + len) % len;
  }
  return step;
}
 
inline Note audibleNote(const Pattern& p, const Lane& l, int step, bool anySolo) noexcept
{
  if(l.mute || (anySolo && !l.solo))
    return Note::Rest;
  return writtenNote(p, l, step);
}
 
enum class LaneLabels : uint8_t
{
  NameAndNumber,
  Name,
  Number,
  DrumName
};
}
 
Q_DECLARE_METATYPE(Patternist::LaneLabels)
W_REGISTER_ARGTYPE(Patternist::LaneLabels)
 
namespace Patternist
{
 
class SCORE_PLUGIN_MIDI_EXPORT ProcessModel final : public Process::ProcessModel
{
  SCORE_SERIALIZE_FRIENDS
  W_OBJECT(ProcessModel)
 
public:
  static const constexpr int maxPatterns = 128;
 
  PROCESS_METADATA_IMPL(Patternist::ProcessModel)
  explicit ProcessModel(
      const TimeVal& duration, const Id<Process::ProcessModel>& id, QObject* parent);
  explicit ProcessModel(
      const TimeVal& duration, const QString& custom,
      const Id<Process::ProcessModel>& id, QObject* parent);
 
  template <typename Impl>
  explicit ProcessModel(Impl& vis, QObject* parent)
      : Process::ProcessModel{vis, parent}
  {
    vis.writeTo(*this);
    init();
  }
 
  void init();
  void sanitize();
 
  ~ProcessModel() override;
 
  void setChannel(int n);
  int channel() const noexcept;
 
  void setCurrentPattern(int n);
  int currentPattern() const noexcept;
 
  void setLaneLabels(LaneLabels l);
  LaneLabels laneLabels() const noexcept;
 
  const std::vector<int64_t>& execSteps() const noexcept { return m_execSteps; }
  void setExecSteps(std::vector<int64_t> s) { m_execSteps = std::move(s); }
 
  void setPattern(int n, Pattern p);
  void setPatterns(const std::vector<Pattern>& n);
  const std::vector<Pattern>& patterns() const noexcept;
 
  void loadPreset(const Process::Preset& preset) override;
  Process::Preset savePreset() const noexcept override;
 
  std::unique_ptr<Process::ControlInlet> patternSelect;
  std::unique_ptr<Process::ControlInlet> switchQuantification;
  std::unique_ptr<Process::ControlInlet> fill;
  std::unique_ptr<Process::ControlInlet> density;
  std::unique_ptr<Process::ControlInlet> velocity;
  std::unique_ptr<Process::ControlInlet> swing;
  std::unique_ptr<Process::ControlInlet> ratchet;
  std::unique_ptr<Process::ControlInlet> pace;
  std::unique_ptr<Process::ControlInlet> repeatTime;
  std::unique_ptr<Process::MidiOutlet> outlet;
  std::unique_ptr<Process::Outlet> accent;
  std::unique_ptr<Process::Outlet> slide;
 
public:
  void channelChanged(int arg_1) W_SIGNAL(channelChanged, arg_1);
  void currentPatternChanged(int arg_1) W_SIGNAL(currentPatternChanged, arg_1);
  void execStepsChanged() W_SIGNAL(execStepsChanged);
  void execPattern(int current, int pending) W_SIGNAL(execPattern, current, pending);
  void patternsChanged() W_SIGNAL(patternsChanged);
  void laneLabelsChanged(LaneLabels arg_1) W_SIGNAL(laneLabelsChanged, arg_1);
  void timeGridChanged() W_SIGNAL(timeGridChanged);
 
  PROPERTY(int, channel READ channel WRITE setChannel NOTIFY channelChanged, W_Final)
  PROPERTY(
      int,
      currentPattern READ currentPattern WRITE setCurrentPattern NOTIFY
          currentPatternChanged,
      W_Final)
  PROPERTY(
      LaneLabels,
      laneLabels READ laneLabels WRITE setLaneLabels NOTIFY laneLabelsChanged, W_Final)
private:
  void ancestorStartDateChanged() override;
  void ancestorTempoChanged() override;
  void setDurationAndScale(const TimeVal& newDuration) noexcept override;
  void setDurationAndGrow(const TimeVal& newDuration) noexcept override;
  void setDurationAndShrink(const TimeVal& newDuration) noexcept override;
 
  int m_channel{1};
  int m_currentPattern{};
  LaneLabels m_laneLabels{LaneLabels::NameAndNumber};
  std::vector<int64_t> m_execSteps;
  std::vector<bool> m_grown;
  std::vector<Pattern> m_patterns;
};
}