feat(rivet): storyboard composition with flexible lengths and meters
Check and Windows preview / check (patina) (push) Successful in 3m59s
Check and Windows preview / check (rivet) (push) Successful in 2m2s
Check and Windows preview / previews (push) Successful in 1m8s
Independent plugin release / plan (push) Successful in 7s
Check and Windows preview / windows (push) Successful in 2m41s
Independent plugin release / build (push) Successful in 3m0s
Independent plugin release / publish (push) Successful in 9s
Check and Windows preview / check (patina) (push) Successful in 3m59s
Check and Windows preview / check (rivet) (push) Successful in 2m2s
Check and Windows preview / previews (push) Successful in 1m8s
Independent plugin release / plan (push) Successful in 7s
Check and Windows preview / windows (push) Successful in 2m41s
Independent plugin release / build (push) Successful in 3m0s
Independent plugin release / publish (push) Successful in 9s
Rivet 0.4.0 tells a motif as a story. A timeline of blocks with roles (statement, answer, departure, return, rest) replaces tasks, pins and branches. Rivet writes each block from a motif and joins the seams with a cut, breath, pickup or approach. - Motifs of 1-8 bars in a bin of 16; storyboards up to 32 bars. - Meters 2/4, 3/4, 4/4, 5/4, 6/8, 7/8 and 12/8 for import, writing, audition and export. Phrygian, harmonic minor and Mixolydian scales. - Per-block options, Another take and Keep; templates for new boards. - Editor rebuilt: motif bin, timeline, large piano roll, inspector, tabs for generation, harmony and sound roles, 32-step undo/redo. - Sessions from 0.1-0.3 open as a storyboard from their source motif.
This commit is contained in:
1 parent
abd37fd4fe
commit
f1366280ff
37 files changed
+3763
-2549
No files matched your search
@@ -1,138 +0,0 @@
|
||||
use rivet_core::*;
|
||||
|
||||
fn session() -> Session {
|
||||
let mut s = Session {
|
||||
source: Some(demo_motif()),
|
||||
..Default::default()
|
||||
};
|
||||
s.regenerate().unwrap();
|
||||
s
|
||||
}
|
||||
#[test]
|
||||
fn moves_fork_and_restore_context_without_losing_siblings() {
|
||||
let mut s = session();
|
||||
s.pin_selected(0).unwrap();
|
||||
let root = s.save_branch("Original").unwrap();
|
||||
let original = s.composed_phrase().unwrap();
|
||||
s.apply_move(CreativeMove::Thin, Some(1)).unwrap();
|
||||
let thin = s.active_branch.unwrap();
|
||||
let thinned = s.composed_phrase().unwrap();
|
||||
assert_ne!(thinned, original);
|
||||
assert_eq!(
|
||||
&thinned.notes[..demo_motif().notes.len()],
|
||||
demo_motif().notes.as_slice()
|
||||
);
|
||||
s.restore_branch(root).unwrap();
|
||||
assert_eq!(s.composed_phrase().unwrap(), original);
|
||||
assert_eq!(s.pins.len(), 1);
|
||||
s.apply_move(CreativeMove::Lengthen, Some(2)).unwrap();
|
||||
let long = s.active_branch.unwrap();
|
||||
assert_ne!(thin, long);
|
||||
assert_eq!(s.branches.len(), 3);
|
||||
assert_eq!(
|
||||
s.branches.iter().find(|b| b.id == thin).unwrap().parent,
|
||||
Some(root)
|
||||
);
|
||||
assert_eq!(
|
||||
s.branches.iter().find(|b| b.id == long).unwrap().parent,
|
||||
Some(root)
|
||||
);
|
||||
s.restore_branch(thin).unwrap();
|
||||
assert_eq!(s.composed_phrase().unwrap(), thinned);
|
||||
assert!(s.remove_branch(root).is_err());
|
||||
assert_eq!(Session::from_json(&s.to_json().unwrap()).unwrap(), s);
|
||||
}
|
||||
#[test]
|
||||
fn gesture_recall_and_cross_project_library_preserve_performance() {
|
||||
let mut s = session();
|
||||
s.performance.mode = RoleMode::CallResponse;
|
||||
s.performance.voices[1].controller.enabled = true;
|
||||
s.performance.voices[1].controller.cc = 20;
|
||||
s.performance.voices[1].controller.shape(2);
|
||||
let id = s.save_gesture("Floating answer", Some(1)).unwrap();
|
||||
let saved = s.gestures[0].clone();
|
||||
let bytes = s.export_gesture_library().unwrap();
|
||||
let mut other = Session {
|
||||
source: Some(demo_motif()),
|
||||
harmony: Harmony::progression(2, Scale::Major),
|
||||
..Default::default()
|
||||
};
|
||||
other.save_gesture("Existing", None).unwrap();
|
||||
let context = other.harmony.clone();
|
||||
other
|
||||
.import_gesture_library(read_gesture_library(&bytes).unwrap())
|
||||
.unwrap();
|
||||
assert_eq!(other.gestures.len(), 2);
|
||||
assert_ne!(other.gestures[0].id, other.gestures[1].id);
|
||||
let imported = other.gestures[1].id;
|
||||
other.recall_gesture(imported).unwrap();
|
||||
assert_eq!(other.source, Some(saved.phrase));
|
||||
assert_eq!(other.performance, saved.performance);
|
||||
assert_eq!(other.harmony, context);
|
||||
assert!(other.candidates.is_empty());
|
||||
assert!(other.pins.is_empty());
|
||||
assert!(s.gestures.iter().any(|g| g.id == id));
|
||||
}
|
||||
#[test]
|
||||
fn blocked_moves_and_full_histories_are_atomic() {
|
||||
let mut s = session();
|
||||
s.settings.preserve_rhythm = true;
|
||||
let before = s.clone();
|
||||
assert!(s.apply_move(CreativeMove::Thin, None).is_err());
|
||||
assert_eq!(s, before);
|
||||
s.settings.preserve_rhythm = false;
|
||||
for i in 0..MAX_BRANCHES {
|
||||
s.save_branch(&format!("Idea {i}")).unwrap();
|
||||
}
|
||||
let before = s.clone();
|
||||
assert!(s.apply_move(CreativeMove::Thin, Some(1)).is_err());
|
||||
assert_eq!(s, before);
|
||||
let leaf = s.active_branch.unwrap();
|
||||
s.remove_branch(leaf).unwrap();
|
||||
assert_eq!(s.branches.len(), MAX_BRANCHES - 1);
|
||||
}
|
||||
#[test]
|
||||
fn malformed_ancestry_libraries_and_version_two_state_are_handled() {
|
||||
let mut s = session();
|
||||
let id = s.save_branch("Root").unwrap();
|
||||
s.branches[0].parent = Some(id);
|
||||
assert!(s.validate().is_err());
|
||||
assert!(read_gesture_library(br#"{"version":99,"gestures":[]}"#).is_err());
|
||||
let old = session();
|
||||
let mut value = serde_json::to_value(&old).unwrap();
|
||||
value["version"] = 2.into();
|
||||
for key in [
|
||||
"performance",
|
||||
"gestures",
|
||||
"branches",
|
||||
"active_branch",
|
||||
"next_id",
|
||||
] {
|
||||
value.as_object_mut().unwrap().remove(key);
|
||||
}
|
||||
let restored = Session::from_json(&serde_json::to_vec(&value).unwrap()).unwrap();
|
||||
assert_eq!(restored.version, 3);
|
||||
assert_eq!(restored.source, old.source);
|
||||
assert_eq!(restored.performance, PerformanceSettings::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delay_moves_adjacent_notes_together_and_rejects_protected_collisions() {
|
||||
let mut s = session();
|
||||
let make_note = |start| Note {
|
||||
start,
|
||||
duration: PPQ,
|
||||
pitch: 60,
|
||||
velocity: 90,
|
||||
..Default::default()
|
||||
};
|
||||
s.candidates[s.selected].phrase.notes = vec![make_note(SECTION), make_note(SECTION + PPQ)];
|
||||
s.apply_move(CreativeMove::Delay, Some(1)).unwrap();
|
||||
let moved = s.composed_phrase().unwrap();
|
||||
assert_eq!(moved.notes[0].start, SECTION + PPQ / 4);
|
||||
assert_eq!(moved.notes[1].start, SECTION + PPQ + PPQ / 4);
|
||||
s.candidates[0].phrase.notes[1].rhythm_locked = true;
|
||||
let before = s.clone();
|
||||
assert!(s.apply_move(CreativeMove::Delay, Some(1)).is_err());
|
||||
assert_eq!(s, before);
|
||||
}
|
||||
+135
-160
@@ -3,85 +3,110 @@ use rivet_core::*;
|
||||
fn rhythm(p: &Phrase) -> Vec<(u32, u32)> {
|
||||
p.notes.iter().map(|n| (n.start, n.duration)).collect()
|
||||
}
|
||||
fn options(motif: &Phrase, role: Role, s: &Settings) -> Vec<Candidate> {
|
||||
realize(motif, role, 2, 2 * BAR, false, 0, s, &Harmony::default()).unwrap()
|
||||
}
|
||||
#[test]
|
||||
fn alternatives_change_density_and_rhythm_instead_of_only_pitch() {
|
||||
let source = demo_motif();
|
||||
fn each_role_offers_distinct_reproducible_options_led_by_its_best_fit() {
|
||||
let motif = demo_motif();
|
||||
let s = Settings::default();
|
||||
let candidates = generate(&source, &s).unwrap();
|
||||
assert_eq!(candidates.len(), 3);
|
||||
assert!(candidates
|
||||
.iter()
|
||||
.any(|c| c.phrase.notes.len() != source.notes.len() * 4));
|
||||
assert!(candidates
|
||||
.windows(2)
|
||||
.any(|pair| rhythm(&pair[0].phrase) != rhythm(&pair[1].phrase)));
|
||||
for c in &candidates {
|
||||
assert_eq!(
|
||||
&c.phrase.notes[..source.notes.len()],
|
||||
source.notes.as_slice()
|
||||
);
|
||||
for (role, first) in [
|
||||
(Role::Statement, Strategy::Quote),
|
||||
(Role::Answer, Strategy::CallResponse),
|
||||
(Role::Departure, Strategy::LaterPeak),
|
||||
(Role::Return, Strategy::HarmonicReturn),
|
||||
] {
|
||||
let a = options(&motif, role, &s);
|
||||
assert_eq!(a, options(&motif, role, &s), "{role:?} is deterministic");
|
||||
assert_eq!(a.len(), 3, "{role:?}");
|
||||
assert_eq!(a[0].strategy, first, "{role:?}");
|
||||
for pair in a.windows(2) {
|
||||
assert_ne!(pair[0].phrase, pair[1].phrase);
|
||||
}
|
||||
for c in &a {
|
||||
c.phrase.validate(MAX_PLAYBACK_NOTES).unwrap();
|
||||
assert_eq!(c.phrase.length, 2 * BAR);
|
||||
}
|
||||
}
|
||||
assert_eq!(candidates, generate(&source, &s).unwrap());
|
||||
let quote = &options(&motif, Role::Statement, &s)[0];
|
||||
assert_eq!(
|
||||
quote.phrase.notes, motif.notes,
|
||||
"a statement quotes the motif"
|
||||
);
|
||||
let rest = realize(&motif, Role::Rest, 1, 0, false, 0, &s, &Harmony::default()).unwrap();
|
||||
assert_eq!(rest.len(), 1);
|
||||
assert!(rest[0].phrase.notes.is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn options_change_rhythm_and_density_not_only_pitch() {
|
||||
let motif = demo_motif();
|
||||
let s = Settings::default();
|
||||
let mut signatures = std::collections::BTreeSet::new();
|
||||
for seed in 0..12 {
|
||||
for c in generate(&source, &Settings { seed, ..s.clone() }).unwrap() {
|
||||
signatures.insert(rhythm(&c.phrase));
|
||||
for role in [Role::Answer, Role::Departure] {
|
||||
for c in options(&motif, role, &Settings { seed, ..s.clone() }) {
|
||||
signatures.insert(rhythm(&c.phrase));
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
signatures.len() > 3,
|
||||
"seeds should explore multiple rhythmic decisions"
|
||||
"seeds should explore rhythmic decisions"
|
||||
);
|
||||
assert!(options(&motif, Role::Answer, &s)
|
||||
.iter()
|
||||
.any(|c| c.phrase.notes.len() != motif.notes.len()));
|
||||
}
|
||||
#[test]
|
||||
fn fixed_groove_and_separate_note_locks_take_priority() {
|
||||
let mut source = demo_motif();
|
||||
source.notes[1].pitch_locked = true;
|
||||
source.notes[1].pitch = 99;
|
||||
source.notes[3].rhythm_locked = true;
|
||||
for c in generate(&source, &Settings::default()).unwrap() {
|
||||
let pitch: Vec<_> = c.phrase.notes.iter().filter(|n| n.pitch_locked).collect();
|
||||
assert_eq!(pitch.len(), 4);
|
||||
assert!(pitch.iter().all(|n| n.pitch == 99));
|
||||
for rep in 0..4 {
|
||||
assert!(c.phrase.notes.iter().any(|n| n.rhythm_locked
|
||||
&& n.start == source.notes[3].start + rep * source.length
|
||||
&& n.duration == source.notes[3].duration));
|
||||
let mut motif = demo_motif();
|
||||
motif.notes[1].pitch_locked = true;
|
||||
motif.notes[1].pitch = 99;
|
||||
motif.notes[3].rhythm_locked = true;
|
||||
for role in [Role::Answer, Role::Departure, Role::Return] {
|
||||
for c in realize(
|
||||
&motif,
|
||||
role,
|
||||
4,
|
||||
0,
|
||||
false,
|
||||
0,
|
||||
&Settings::default(),
|
||||
&Harmony::default(),
|
||||
)
|
||||
.unwrap()
|
||||
{
|
||||
let locked: Vec<_> = c.phrase.notes.iter().filter(|n| n.pitch_locked).collect();
|
||||
assert_eq!(locked.len(), 2, "{role:?} {:?}", c.strategy);
|
||||
assert!(locked.iter().all(|n| n.pitch == 99));
|
||||
for rep in 0..2 {
|
||||
assert!(c.phrase.notes.iter().any(|n| n.rhythm_locked
|
||||
&& n.start == motif.notes[3].start + rep * motif.length
|
||||
&& n.duration == motif.notes[3].duration));
|
||||
}
|
||||
}
|
||||
}
|
||||
let source = demo_motif();
|
||||
let repeated: Vec<_> = (0..4)
|
||||
.flat_map(|rep| {
|
||||
source
|
||||
.notes
|
||||
.iter()
|
||||
.map(move |n| (n.start + rep * SECTION, n.duration))
|
||||
})
|
||||
.collect();
|
||||
for c in generate(
|
||||
&source,
|
||||
&Settings {
|
||||
preserve_rhythm: true,
|
||||
..Settings::default()
|
||||
},
|
||||
)
|
||||
.unwrap()
|
||||
{
|
||||
assert_eq!(rhythm(&c.phrase), repeated);
|
||||
let motif = demo_motif();
|
||||
let s = Settings {
|
||||
preserve_rhythm: true,
|
||||
..Settings::default()
|
||||
};
|
||||
for c in options(&motif, Role::Departure, &s) {
|
||||
assert_eq!(rhythm(&c.phrase), rhythm(&motif));
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn impossible_diversity_returns_one_honest_proposal() {
|
||||
let mut source = demo_motif();
|
||||
for n in &mut source.notes {
|
||||
fn fully_locked_motif_returns_one_honest_option() {
|
||||
let mut motif = demo_motif();
|
||||
for n in &mut motif.notes {
|
||||
n.locked = true;
|
||||
}
|
||||
let candidates = generate(&source, &Settings::default()).unwrap();
|
||||
assert_eq!(candidates.len(), 1);
|
||||
assert_eq!(candidates[0].phrase.notes.len(), source.notes.len() * 4);
|
||||
let all = options(&motif, Role::Answer, &Settings::default());
|
||||
assert_eq!(all.len(), 1);
|
||||
assert_eq!(all[0].phrase.notes, motif.notes);
|
||||
}
|
||||
#[test]
|
||||
fn harmony_drives_strong_notes_and_distinct_open_or_closed_arrivals() {
|
||||
fn harmony_drives_strong_notes_and_the_final_ending() {
|
||||
let harmony = Harmony {
|
||||
length: BAR,
|
||||
spans: vec![HarmonySpan {
|
||||
@@ -97,13 +122,30 @@ fn harmony_drives_strong_notes_and_distinct_open_or_closed_arrivals() {
|
||||
ending,
|
||||
..Settings::default()
|
||||
};
|
||||
for c in generate_with_harmony(&demo_motif(), &s, &harmony).unwrap() {
|
||||
for c in realize(
|
||||
&demo_motif(),
|
||||
Role::Return,
|
||||
2,
|
||||
6 * BAR,
|
||||
true,
|
||||
0,
|
||||
&s,
|
||||
&harmony,
|
||||
)
|
||||
.unwrap()
|
||||
{
|
||||
if c.strategy == Strategy::Quote {
|
||||
continue;
|
||||
}
|
||||
let last = c.phrase.notes.last().unwrap();
|
||||
let chord = ChordQuality::Major.mask(0) & (1 << (last.pitch % 12)) != 0;
|
||||
assert_eq!(chord, ending == Ending::Resolve);
|
||||
for n in c.phrase.notes.iter().filter(|n| {
|
||||
n.start >= SECTION && n.start.is_multiple_of(PPQ) && n.start != last.start
|
||||
}) {
|
||||
assert_eq!(chord, ending == Ending::Resolve, "{:?}", c.strategy);
|
||||
for n in c
|
||||
.phrase
|
||||
.notes
|
||||
.iter()
|
||||
.filter(|n| n.start.is_multiple_of(PPQ) && n.start != last.start)
|
||||
{
|
||||
assert_ne!(
|
||||
harmony.at(n.start).unwrap().tones & (1 << (n.pitch % 12)),
|
||||
0
|
||||
@@ -114,29 +156,16 @@ fn harmony_drives_strong_notes_and_distinct_open_or_closed_arrivals() {
|
||||
}
|
||||
#[test]
|
||||
fn imported_harmony_preserves_voicings_and_gaps_without_guessing_roots() {
|
||||
let notes = vec![
|
||||
Note {
|
||||
let notes: Vec<_> = [64, 67, 72]
|
||||
.into_iter()
|
||||
.map(|pitch| Note {
|
||||
start: 0,
|
||||
duration: BAR,
|
||||
pitch: 64,
|
||||
pitch,
|
||||
velocity: 90,
|
||||
..Default::default()
|
||||
},
|
||||
Note {
|
||||
start: 0,
|
||||
duration: BAR,
|
||||
pitch: 67,
|
||||
velocity: 90,
|
||||
..Default::default()
|
||||
},
|
||||
Note {
|
||||
start: 0,
|
||||
duration: BAR,
|
||||
pitch: 72,
|
||||
velocity: 90,
|
||||
..Default::default()
|
||||
},
|
||||
];
|
||||
})
|
||||
.collect();
|
||||
let h = Harmony::from_midi(¬es, 2 * BAR).unwrap();
|
||||
assert_eq!(h.spans.len(), 1);
|
||||
assert_eq!(h.spans[0].bass, 64);
|
||||
@@ -145,84 +174,30 @@ fn imported_harmony_preserves_voicings_and_gaps_without_guessing_roots() {
|
||||
assert_eq!(h.at(2 * BAR).unwrap().bass, 64);
|
||||
}
|
||||
#[test]
|
||||
fn pins_combine_candidates_and_survive_regeneration_exactly() {
|
||||
let mut s = Session {
|
||||
source: Some(demo_motif()),
|
||||
..Default::default()
|
||||
};
|
||||
s.regenerate().unwrap();
|
||||
s.pin_selected(1).unwrap();
|
||||
let saved = s.pins[0].clone();
|
||||
s.selected = 1;
|
||||
let expected: Vec<_> = saved
|
||||
.phrase
|
||||
.notes
|
||||
.iter()
|
||||
.map(|n| Note {
|
||||
start: n.start + SECTION,
|
||||
..*n
|
||||
})
|
||||
.collect();
|
||||
let combined = s.composed_phrase().unwrap();
|
||||
assert_eq!(
|
||||
combined
|
||||
.notes
|
||||
.iter()
|
||||
.filter(|n| n.start >= SECTION && n.start < 2 * SECTION)
|
||||
.copied()
|
||||
.collect::<Vec<_>>(),
|
||||
expected
|
||||
);
|
||||
s.settings.seed += 7;
|
||||
s.regenerate().unwrap();
|
||||
assert_eq!(s.pins[0], saved);
|
||||
s.accept_composed().unwrap();
|
||||
assert_eq!(s.accepted, Some(s.composed_phrase().unwrap()));
|
||||
assert_eq!(Session::from_json(&s.to_json().unwrap()).unwrap(), s);
|
||||
}
|
||||
#[test]
|
||||
fn version_one_sessions_migrate_without_losing_existing_notes() {
|
||||
let s = Session {
|
||||
source: Some(demo_motif()),
|
||||
..Default::default()
|
||||
};
|
||||
let mut value = serde_json::to_value(&s).unwrap();
|
||||
value["version"] = 1.into();
|
||||
let object = value.as_object_mut().unwrap();
|
||||
for key in ["harmony", "pins", "audition", "looping"] {
|
||||
object.remove(key);
|
||||
fn every_meter_key_and_block_length_realizes_valid_options() {
|
||||
let motif = demo_motif();
|
||||
for meter in Meter::ALL {
|
||||
for root in [0, 5, 11] {
|
||||
for scale in Scale::ALL {
|
||||
let s = Settings {
|
||||
root,
|
||||
scale,
|
||||
meter,
|
||||
low: 60,
|
||||
high: 72,
|
||||
..Settings::default()
|
||||
};
|
||||
for bars in [1, 3, 8] {
|
||||
for role in Role::ALL {
|
||||
for c in realize(&motif, role, bars, 0, true, 0, &s, &Harmony::default())
|
||||
.unwrap()
|
||||
{
|
||||
c.phrase.check(MAX_PLAYBACK_NOTES, true).unwrap();
|
||||
assert_eq!(c.phrase.length, bars as u32 * meter.bar());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let settings = object.get_mut("settings").unwrap().as_object_mut().unwrap();
|
||||
for key in ["preserve_contour", "task", "ending"] {
|
||||
settings.remove(key);
|
||||
}
|
||||
for n in object.get_mut("source").unwrap()["notes"]
|
||||
.as_array_mut()
|
||||
.unwrap()
|
||||
{
|
||||
n.as_object_mut().unwrap().remove("pitch_locked");
|
||||
n.as_object_mut().unwrap().remove("rhythm_locked");
|
||||
}
|
||||
let migrated = Session::from_json(&serde_json::to_vec(&value).unwrap()).unwrap();
|
||||
assert_eq!(migrated.version, STATE_VERSION);
|
||||
assert_eq!(migrated.source, s.source);
|
||||
assert!(!migrated.looping);
|
||||
assert!(migrated.harmony.spans.is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn invalid_pins_and_unsafe_legacy_seams_are_rejected() {
|
||||
let mut s = Session {
|
||||
source: Some(demo_motif()),
|
||||
..Default::default()
|
||||
};
|
||||
s.regenerate().unwrap();
|
||||
s.candidates[0].phrase.notes = vec![Note {
|
||||
start: SECTION - 100,
|
||||
duration: 200,
|
||||
pitch: 60,
|
||||
velocity: 80,
|
||||
..Default::default()
|
||||
}];
|
||||
assert!(s.pin_selected(1).is_err());
|
||||
assert!(s.pin_selected(9).is_err());
|
||||
}
|
||||
@@ -34,7 +34,7 @@ fn role_handoffs_preserve_event_identity_and_respect_locks() {
|
||||
s.voices[1].transpose = 12;
|
||||
s.voices[0].velocity = 50;
|
||||
s.voices[1].velocity = 50;
|
||||
let p = Performance::compile(&source, &s, 140., false).unwrap();
|
||||
let p = Performance::compile(&source, &s, 140., false, Meter::default()).unwrap();
|
||||
let on: Vec<_> = p
|
||||
.events
|
||||
.iter()
|
||||
@@ -42,7 +42,7 @@ fn role_handoffs_preserve_event_identity_and_respect_locks() {
|
||||
.collect();
|
||||
assert_eq!(on.len(), source.notes.len());
|
||||
for (i, n) in source.notes.iter().enumerate() {
|
||||
let role = mode.role(i, n);
|
||||
let role = mode.role(i, n, Meter::default());
|
||||
let actual = on.iter().find(|e| e.tick == n.start as i32).unwrap();
|
||||
assert_eq!(actual.message.channel, s.voices[role].channel);
|
||||
assert_eq!(
|
||||
@@ -69,7 +69,7 @@ fn controller_interpolation_and_validation_are_explicit() {
|
||||
let mut s = PerformanceSettings::default();
|
||||
s.voices[0].controller.enabled = true;
|
||||
s.voices[0].controller.cc = 20;
|
||||
let p = Performance::compile(&held(), &s, 120., false).unwrap();
|
||||
let p = Performance::compile(&held(), &s, 120., false, Meter::default()).unwrap();
|
||||
assert!(p
|
||||
.events
|
||||
.iter()
|
||||
@@ -83,7 +83,7 @@ fn controller_interpolation_and_validation_are_explicit() {
|
||||
fn attack_compensation_warms_up_once_and_wraps_without_cutting_the_next_note() {
|
||||
let mut s = PerformanceSettings::default();
|
||||
s.voices[0].attack_ms = 100;
|
||||
let performance = Performance::compile(&held(), &s, 120., true).unwrap();
|
||||
let performance = Performance::compile(&held(), &s, 120., true, Meter::default()).unwrap();
|
||||
assert_eq!(performance.lead_in, 192);
|
||||
assert!(performance
|
||||
.events
|
||||
@@ -127,8 +127,14 @@ fn attack_compensation_warms_up_once_and_wraps_without_cutting_the_next_note() {
|
||||
}
|
||||
#[test]
|
||||
fn public_clip_validation_rejects_bad_roles_and_dense_events() {
|
||||
let mut p =
|
||||
Performance::compile(&held(), &PerformanceSettings::default(), 120., false).unwrap();
|
||||
let mut p = Performance::compile(
|
||||
&held(),
|
||||
&PerformanceSettings::default(),
|
||||
120.,
|
||||
false,
|
||||
Meter::default(),
|
||||
)
|
||||
.unwrap();
|
||||
p.events[0].role = 9;
|
||||
assert!(p.clip().is_err());
|
||||
let event = TimedMessage {
|
||||
|
||||
@@ -0,0 +1,182 @@
|
||||
use rivet_core::*;
|
||||
|
||||
fn demo() -> Session {
|
||||
Session::demo()
|
||||
}
|
||||
#[test]
|
||||
fn templates_build_the_story_from_one_motif() {
|
||||
let s = demo();
|
||||
let roles: Vec<_> = s.blocks.iter().map(|b| b.role).collect();
|
||||
assert_eq!(
|
||||
roles,
|
||||
[Role::Statement, Role::Answer, Role::Departure, Role::Return]
|
||||
);
|
||||
assert_eq!(s.total_bars(), 8);
|
||||
assert!(s.blocks.iter().all(|b| b.options.len() == 3));
|
||||
let phrase = s.compose().unwrap();
|
||||
assert_eq!(phrase.length, 8 * BAR);
|
||||
assert_eq!(
|
||||
&phrase.notes[..demo_motif().notes.len()],
|
||||
demo_motif().notes.as_slice(),
|
||||
"the story opens with the motif"
|
||||
);
|
||||
let mut s = demo();
|
||||
let id = s.motifs[0].id;
|
||||
s.apply_template(Template::Breathe, id).unwrap();
|
||||
assert_eq!(s.blocks[1].role, Role::Rest);
|
||||
assert_eq!(s.blocks[1].bars, 1);
|
||||
assert_eq!(s.total_bars(), 8);
|
||||
}
|
||||
#[test]
|
||||
fn blocks_have_free_lengths_up_to_the_storyboard_limit() {
|
||||
let mut s = demo();
|
||||
let motif = s.motifs[0].id;
|
||||
s.insert_block(4, motif, Role::Departure, 5).unwrap();
|
||||
s.insert_block(5, motif, Role::Rest, 1).unwrap();
|
||||
assert_eq!(s.total_bars(), 14);
|
||||
assert_eq!(s.compose().unwrap().length, 14 * BAR);
|
||||
assert!(s.insert_block(0, motif, Role::Answer, 9).is_err());
|
||||
while s.total_bars() + 8 <= MAX_BARS {
|
||||
s.insert_block(0, motif, Role::Answer, 8).unwrap();
|
||||
}
|
||||
assert!(s.insert_block(0, motif, Role::Answer, 8).is_err());
|
||||
s.validate().unwrap();
|
||||
}
|
||||
#[test]
|
||||
fn joins_shape_the_seam_without_crossing_it() {
|
||||
let mut s = demo();
|
||||
let first = s.blocks[1].phrase().unwrap().notes[0];
|
||||
let bar = s.settings.meter.bar();
|
||||
for join in Join::ALL {
|
||||
s.blocks[0].join = join;
|
||||
let phrase = s.compose().unwrap();
|
||||
let tail: Vec<_> = phrase
|
||||
.notes
|
||||
.iter()
|
||||
.filter(|n| n.start < 2 * bar)
|
||||
.copied()
|
||||
.collect();
|
||||
assert!(tail.iter().all(|n| n.end() <= 2 * bar), "{join:?}");
|
||||
let last = tail.last().unwrap();
|
||||
match join {
|
||||
Join::Cut => assert_eq!(tail, s.blocks[0].phrase().unwrap().notes),
|
||||
Join::Breath => assert!(last.end() <= 2 * bar - s.settings.meter.beat() / 2),
|
||||
Join::Approach => {
|
||||
assert_ne!(last.pitch, first.pitch);
|
||||
assert!(last.pitch.abs_diff(first.pitch) <= 2);
|
||||
}
|
||||
Join::Pickup => {
|
||||
let pickup: Vec<_> = tail
|
||||
.iter()
|
||||
.filter(|n| n.start >= 2 * bar - s.settings.meter.beat())
|
||||
.collect();
|
||||
assert_eq!(pickup.len(), 2);
|
||||
let direction = (pickup[1].pitch as i16 - pickup[0].pitch as i16).signum();
|
||||
let into = (first.pitch as i16 - pickup[1].pitch as i16).signum();
|
||||
assert_eq!(direction, into, "the pickup moves toward the next block");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn kept_blocks_survive_new_settings_and_other_blocks_follow_them() {
|
||||
let mut s = demo();
|
||||
s.blocks[1].choice = 2;
|
||||
s.blocks[1].kept = true;
|
||||
let kept = s.blocks[1].phrase().unwrap().clone();
|
||||
let free = s.blocks[2].options.clone();
|
||||
s.settings.seed += 7;
|
||||
s.realize_all();
|
||||
assert_eq!(s.blocks[1].phrase().unwrap(), &kept);
|
||||
assert_ne!(s.blocks[2].options, free);
|
||||
s.another_take(1);
|
||||
assert!(!s.blocks[1].kept);
|
||||
assert_eq!(Session::from_json(&s.to_json().unwrap()).unwrap(), s);
|
||||
}
|
||||
#[test]
|
||||
fn compound_and_odd_meters_compose_whole_bars() {
|
||||
for meter in [
|
||||
Meter { beats: 3, unit: 4 },
|
||||
Meter { beats: 6, unit: 8 },
|
||||
Meter { beats: 7, unit: 8 },
|
||||
] {
|
||||
let mut s = Session::default();
|
||||
s.settings.meter = meter;
|
||||
let motif = Phrase {
|
||||
length: meter.bar(),
|
||||
notes: (0..3)
|
||||
.map(|i| Note {
|
||||
start: i * meter.beat() / 2,
|
||||
duration: meter.beat() / 2,
|
||||
pitch: 60 + 2 * i as u8,
|
||||
velocity: 90,
|
||||
..Default::default()
|
||||
})
|
||||
.collect(),
|
||||
};
|
||||
let id = s.add_motif("Waltz", motif).unwrap();
|
||||
s.apply_template(Template::Build, id).unwrap();
|
||||
let phrase = s.compose().unwrap();
|
||||
assert_eq!(phrase.length, s.total_bars() * meter.bar());
|
||||
s.validate().unwrap();
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn removing_a_motif_removes_its_blocks_and_limits_hold() {
|
||||
let mut s = demo();
|
||||
let id = s.motifs[0].id;
|
||||
let other = s.add_motif("Second", demo_motif()).unwrap();
|
||||
s.insert_block(4, other, Role::Answer, 2).unwrap();
|
||||
s.remove_motif(id);
|
||||
assert_eq!(s.blocks.len(), 1);
|
||||
assert_eq!(s.blocks[0].motif, other);
|
||||
let long = Phrase {
|
||||
length: 9 * BAR,
|
||||
..demo_motif()
|
||||
};
|
||||
assert!(s.add_motif("Too long", long).is_err());
|
||||
for i in s.motifs.len()..MAX_MOTIFS {
|
||||
s.add_motif(&format!("M{i}"), demo_motif()).unwrap();
|
||||
}
|
||||
assert!(s.add_motif("One more", demo_motif()).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn version_three_sessions_become_a_storyboard_without_losing_notes() {
|
||||
let mut source = demo_motif();
|
||||
source.notes[2].locked = true;
|
||||
for (bars, blocks) in [(8, 4), (4, 2)] {
|
||||
let old = serde_json::json!({
|
||||
"version": 3,
|
||||
"source": source,
|
||||
"settings": {"bars": bars, "root": 2, "scale": "Dorian", "variation": 40,
|
||||
"preserve_rhythm": false, "preserve_contour": true, "task": "Answer",
|
||||
"ending": "Open", "low": 50, "high": 80, "seed": 9},
|
||||
"candidates": [], "selected": 0, "accepted": null, "previous_accepted": null,
|
||||
"tempo": 128.0, "follow_host": true, "pins": [], "looping": true,
|
||||
"gestures": [{"id": 1, "name": "Hook", "phrase": demo_motif(),
|
||||
"performance": PerformanceSettings::default()}],
|
||||
"branches": [], "active_branch": null, "next_id": 2
|
||||
});
|
||||
let s = Session::from_json(&serde_json::to_vec(&old).unwrap()).unwrap();
|
||||
assert_eq!(s.version, STATE_VERSION);
|
||||
assert_eq!(s.motifs[0].phrase, source);
|
||||
assert_eq!(s.motifs[1].name, "Hook");
|
||||
assert_eq!(s.blocks.len(), blocks);
|
||||
assert_eq!(s.blocks.last().unwrap().role, Role::Return);
|
||||
assert_eq!(s.settings.root, 2);
|
||||
assert_eq!(s.settings.scale, Scale::Dorian);
|
||||
assert_eq!(s.settings.ending, Ending::Open);
|
||||
assert_eq!(s.tempo, 128.);
|
||||
assert!(s.follow_host);
|
||||
assert!(s.compose().is_ok());
|
||||
}
|
||||
let v1 = serde_json::json!({"version": 1, "source": demo_motif(),
|
||||
"settings": {"bars": 8}, "candidates": [], "selected": 0, "accepted": null,
|
||||
"previous_accepted": null, "tempo": 140.0, "follow_host": false});
|
||||
let s = Session::from_json(&serde_json::to_vec(&v1).unwrap()).unwrap();
|
||||
assert!(!s.looping, "version-1 sessions kept one-shot audition");
|
||||
assert!(s.harmony.spans.is_empty());
|
||||
let mut future = serde_json::to_value(Session::default()).unwrap();
|
||||
future["version"] = 99.into();
|
||||
assert!(Session::from_json(&serde_json::to_vec(&future).unwrap()).is_err());
|
||||
}
|
||||
Reference in new issue
Block a user