PatternEdit.hpp

#pragma once
#include <Patternist/PatternModel.hpp>
 
#include <score_plugin_midi_export.h>
 
#include <algorithm>
#include <optional>
#include <random>
 
class QMimeData;
namespace Patternist
{
 
SCORE_PLUGIN_MIDI_EXPORT Note toggledNote(Note current) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT bool setStep(Pattern& p, int lane, int step, Note n) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT void clear(Pattern& p) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT void rotate(Pattern& p, int steps) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT void
randomize(Pattern& p, std::mt19937& rng, int lane = -1) noexcept;
 
enum class Combine : uint8_t
{
  Replace,
  Add,
  Mask
};
 
SCORE_PLUGIN_MIDI_EXPORT void euclidean(
    const Pattern& p, Lane& l, int hits, int rotation, Combine c = Combine::Replace) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT bool transpose(Pattern& p, int semitones) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT void addLane(Pattern& p);
SCORE_PLUGIN_MIDI_EXPORT bool addControlLane(Pattern& p, uint8_t note) noexcept;
SCORE_PLUGIN_MIDI_EXPORT bool hasLane(const Pattern& p, uint8_t note) noexcept;
SCORE_PLUGIN_MIDI_EXPORT void removeLane(Pattern& p, int lane);
SCORE_PLUGIN_MIDI_EXPORT void setLength(Pattern& p, int length);
 
SCORE_PLUGIN_MIDI_EXPORT
QMimeData* patternToMime(const Pattern& p);
SCORE_PLUGIN_MIDI_EXPORT
std::optional<Pattern> patternFromMime(const QMimeData& mime);
 
struct StepSelection
{
  int lane0{-1};
  std::vector<std::vector<int>> steps;
 
  bool valid() const noexcept { return lane0 >= 0 && !steps.empty(); }
  bool contains(int lane, int step) const noexcept
  {
    if(lane < lane0 || lane >= lane0 + int(steps.size()))
      return false;
    const auto& s = steps[lane - lane0];
    return std::find(s.begin(), s.end(), step) != s.end();
  }
  bool operator==(const StepSelection&) const noexcept = default;
};
 
SCORE_PLUGIN_MIDI_EXPORT Pattern copySteps(const Pattern& p, const StepSelection& s);
SCORE_PLUGIN_MIDI_EXPORT void
pasteSteps(Pattern& p, const Pattern& steps, int lane, const std::vector<int>& starts);
SCORE_PLUGIN_MIDI_EXPORT void clearSteps(Pattern& p, const StepSelection& s) noexcept;
SCORE_PLUGIN_MIDI_EXPORT QMimeData* stepsToMime(const Pattern& steps);
SCORE_PLUGIN_MIDI_EXPORT std::optional<Pattern> stepsFromMime(const QMimeData& mime);
 
SCORE_PLUGIN_MIDI_EXPORT Pattern copyLanes(const Pattern& p, const std::vector<int>& lanes);
SCORE_PLUGIN_MIDI_EXPORT bool
pasteLanes(Pattern& p, const Pattern& lanes, const std::vector<int>& targets);
SCORE_PLUGIN_MIDI_EXPORT void clearLanes(Pattern& p, const std::vector<int>& lanes);
SCORE_PLUGIN_MIDI_EXPORT QMimeData* lanesToMime(const Pattern& lanes);
SCORE_PLUGIN_MIDI_EXPORT std::optional<Pattern> lanesFromMime(const QMimeData& mime);
 
enum class StepField : uint8_t
{
  Velocity,
  VelocityRandom,
  Chance,
  Offset,
  OffsetRandom,
  Gate,
  Ratchet,
  Pace,
  Pitch,
  PitchRandom,
  GateRandom
};
 
struct FieldRange
{
  float min, max;
  float origin;
};
SCORE_PLUGIN_MIDI_EXPORT FieldRange fieldRange(StepField f) noexcept;
SCORE_PLUGIN_MIDI_EXPORT QString fieldName(StepField f);
SCORE_PLUGIN_MIDI_EXPORT float stepField(const StepParams& p, StepField f) noexcept;
SCORE_PLUGIN_MIDI_EXPORT void setStepField(StepParams& p, StepField f, float v) noexcept;
SCORE_PLUGIN_MIDI_EXPORT QString fieldText(StepField f, float v);
 
SCORE_PLUGIN_MIDI_EXPORT void
randomizeField(Pattern& p, std::mt19937& rng, StepField f, int lane = -1) noexcept;
SCORE_PLUGIN_MIDI_EXPORT float randomFieldValue(StepField f, std::mt19937& rng) noexcept;
SCORE_PLUGIN_MIDI_EXPORT float anyFieldValue(StepField f, std::mt19937& rng) noexcept;
SCORE_PLUGIN_MIDI_EXPORT void resetField(Pattern& p, StepField f, int lane = -1) noexcept;
 
SCORE_PLUGIN_MIDI_EXPORT QString laneLabel(int note, LaneLabels mode);
}