unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 03:36:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

no more mode-specific constructors

Browse source
This commit is contained in:
🪞👃🪞 2025-04-13 19:20:28 +03:00
parent 5e21792a26
commit 7aa5627371
8 changed files with 96 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

0
app/edn/view_transport.edn
View file

125
app/src/model.rs
View file

@ -44,7 +44,7 @@ mod model_select; pub use self::model_select::*;
pub keys_scene: SourceIter<'static>,
pub keys_mix: SourceIter<'static>,
pub(crate) fmtd: Arc<RwLock<ViewCache>>,
pub fmtd: Arc<RwLock<ViewCache>>,
}
has_size!(<TuiOut>|self: Tek|&self.size);
has_clock!(|self: Tek|self.clock);
@ -148,129 +148,6 @@ impl Tek {
Ok(())
}
}
impl Tek {
pub fn new_clock (
jack: &Jack,
bpm: Option<f64>,
sync_lead: bool,
sync_follow: bool,
midi_froms: &[PortConnect],
midi_tos: &[PortConnect],
) -> Usually<Self> {
let tek = Self {
view: SourceIter(include_str!("../edn/view_transport.edn")),
jack: jack.clone(),
color: ItemPalette::random(),
clock: Clock::new(jack, bpm)?,
midi_ins: {
let mut midi_ins = vec![];
for (index, connect) in midi_froms.iter().enumerate() {
let port = JackMidiIn::new(jack, &format!("M/{index}"), &[connect.clone()])?;
midi_ins.push(port);
}
midi_ins
},
midi_outs: {
let mut midi_outs = vec![];
for (index, connect) in midi_tos.iter().enumerate() {
let port = JackMidiOut::new(jack, &format!("{index}/M"), &[connect.clone()])?;
midi_outs.push(port);
}
midi_outs
},
keys: SourceIter(KEYS_APP),
keys_clip: SourceIter(KEYS_CLIP),
keys_track: SourceIter(KEYS_TRACK),
keys_scene: SourceIter(KEYS_SCENE),
keys_mix: SourceIter(KEYS_MIX),
tracks: vec![],
scenes: vec![],
..Default::default()
};
jack.sync_lead(sync_lead, |mut state|{
let clock = tek.clock();
clock.playhead.update_from_sample(state.position.frame() as f64);
state.position.bbt = Some(clock.bbt());
state.position
});
jack.sync_follow(sync_follow);
Ok(tek)
}
pub fn new_sequencer (
jack: &Jack,
bpm: Option<f64>,
sync_lead: bool,
sync_follow: bool,
midi_froms: &[PortConnect],
midi_tos: &[PortConnect],
) -> Usually<Self> {
let clip = MidiClip::new("Clip", true, 384usize, None, Some(ItemColor::random().into()));
let clip = Arc::new(RwLock::new(clip));
let this = Self::new_clock(jack, bpm, sync_lead, sync_follow, midi_froms, midi_tos)?;
Ok(Self {
view: SourceIter(include_str!("../edn/view_sequencer.edn")),
pool: Some((&clip).into()),
editor: Some((&clip).into()),
editing: false.into(),
midi_buf: vec![vec![];65536],
tracks: vec![Track::default()],
//player: Some(MidiPlayer::new("sequencer", &jack, Some(&this.clock), Some(&clip), &midi_froms, &midi_tos)?),
..this
})
}
pub fn new_groovebox (
jack: &Jack,
bpm: Option<f64>,
sync_lead: bool,
sync_follow: bool,
midi_froms: &[PortConnect],
midi_tos: &[PortConnect],
audio_froms: &[&[PortConnect];2],
audio_tos: &[&[PortConnect];2],
) -> Usually<Self> {
let tek = Self {
view: SourceIter(include_str!("../edn/view_groovebox.edn")),
tracks: vec![Track {
devices: vec![Sampler::new(jack, &"sampler", midi_froms, audio_froms, audio_tos)?.boxed()],
..Track::default()
}],
..Self::new_sequencer(jack, bpm, sync_lead, sync_follow, midi_froms, midi_tos)?
};
//if let Some(sampler) = tek.sampler.as_ref().unwrap().midi_in.as_ref() {
//tek.player.as_ref().unwrap().midi_outs[0].connect_to(sampler.port())?;
//}
Ok(tek)
}
pub fn new_arranger (
jack: &Jack,
bpm: Option<f64>,
sync_lead: bool,
sync_follow: bool,
midi_froms: &[PortConnect],
midi_tos: &[PortConnect],
audio_froms: &[&[PortConnect];2],
audio_tos: &[&[PortConnect];2],
scenes: usize,
tracks: usize,
track_width: usize,
) -> Usually<Self> {
let mut tek = Self {
view: SourceIter(include_str!("../edn/view_arranger.edn")),
pool: Some(Default::default()),
editor: Some(Default::default()),
editing: false.into(),
midi_buf: vec![vec![];65536],
tracks: vec![],
scenes: vec![],
..Self::new_clock(jack, bpm, sync_lead, sync_follow, midi_froms, midi_tos)?
};
tek.arranger = Default::default();
tek.selected = Selection::Clip(1, 1);
tek.scenes_add(scenes);
tek.tracks_add(tracks, Some(track_width), &[], &[]);
Ok(tek)
}
}
#[cfg(test)] #[test] fn test_model () {
let mut tek = Tek::default();
let _ = tek.clip();

1
cli/Cargo.toml
View file

@ -5,7 +5,6 @@ version = "0.2.0"
[dependencies]
tek = { workspace = true }
clap = { workspace = true }
[[bin]]

118
cli/tek.rs
View file

@ -1,4 +1,5 @@
pub use tek::*;
pub(crate) use tek::*;
pub(crate) use std::sync::{Arc, RwLock};
pub(crate) use clap::{self, Parser, Subcommand};
/// Application entrypoint.
pub fn main () -> Usually<()> {
@ -64,9 +65,7 @@ pub struct Cli {
impl Cli {
pub fn run (&self) -> Usually<()> {
let name = self.name.as_ref().map_or("tek", |x|x.as_str());
//let color = ItemPalette::random();
let jack = Jack::new(name)?;
let engine = Tui::new()?;
let mode = &self.mode;
let empty = &[] as &[&str];
let midi_froms = PortConnect::collect(&self.midi_from, empty, &self.midi_from_re);
let midi_tos = PortConnect::collect(&self.midi_to, empty, &self.midi_to_re);
@ -74,27 +73,98 @@ impl Cli {
let left_tos = PortConnect::collect(&self.left_to, empty, empty);
let right_froms = PortConnect::collect(&self.right_from, empty, empty);
let right_tos = PortConnect::collect(&self.right_to, empty, empty);
let audio_froms = &[left_froms.as_slice(), right_froms.as_slice()];
let audio_tos = &[left_tos.as_slice(), right_tos.as_slice() ];
let jack = jack.run(|jack|match self.mode {
Mode::Clock => Tek::new_clock(
jack, self.bpm, self.sync_lead, self.sync_follow,
&midi_froms, &midi_tos),
Mode::Sequencer => Tek::new_sequencer(
jack, self.bpm, self.sync_lead, self.sync_follow,
&midi_froms, &midi_tos),
Mode::Groovebox => Tek::new_groovebox(
jack, self.bpm, self.sync_lead, self.sync_follow,
&midi_froms, &midi_tos,
&audio_froms, &audio_tos),
Mode::Arranger { scenes, tracks, track_width, .. } => Tek::new_arranger(
jack, self.bpm, self.sync_lead, self.sync_follow,
&midi_froms, &midi_tos,
&audio_froms, &audio_tos,
scenes, tracks, track_width),
_ => todo!()
let audio_froms = &[
left_froms.as_slice(),
right_froms.as_slice()
];
let audio_tos = &[left_tos.as_slice(), right_tos.as_slice()];
let clip = match mode {
Mode::Sequencer | Mode::Groovebox => Some(Arc::new(RwLock::new(MidiClip::new(
"Clip", true, 384usize, None, Some(ItemColor::random().into())),
))),
_ => None,
};
let scenes = vec![];
let jack = Jack::new(name)?;
let jack = jack.run(|jack|{
let mut midi_ins = vec![];
let mut midi_outs = vec![];
for (index, connect) in midi_froms.iter().enumerate() {
let port = JackMidiIn::new(jack, &format!("M/{index}"), &[connect.clone()])?;
midi_ins.push(port);
}
for (index, connect) in midi_tos.iter().enumerate() {
let port = JackMidiOut::new(jack, &format!("{index}/M"), &[connect.clone()])?;
midi_outs.push(port);
}
let mut app = Tek {
jack: jack.clone(),
view: SourceIter(match mode {
Mode::Clock => include_str!("./view_transport.edn"),
Mode::Sequencer => include_str!("./view_sequencer.edn"),
Mode::Groovebox => include_str!("./view_groovebox.edn"),
Mode::Arranger { .. } => include_str!("./view_arranger.edn"),
_ => todo!("{mode:?}"),
}),
pool: match mode {
Mode::Sequencer | Mode::Groovebox => clip.as_ref().map(Into::into),
Mode::Arranger { .. } => Some(Default::default()),
_ => None,
},
editor: match mode {
Mode::Sequencer | Mode::Groovebox => clip.as_ref().map(Into::into),
Mode::Arranger { .. } => Some(Default::default()),
_ => None
},
midi_ins,
midi_outs,
midi_buf: match mode {
Mode::Clock => vec![],
Mode::Sequencer | Mode::Groovebox | Mode::Arranger {..} => vec![vec![];65536],
_ => todo!("{mode:?}"),
},
color: ItemPalette::random(),
clock: Clock::new(jack, self.bpm)?,
keys: SourceIter(KEYS_APP),
keys_clip: SourceIter(KEYS_CLIP),
keys_track: SourceIter(KEYS_TRACK),
keys_scene: SourceIter(KEYS_SCENE),
keys_mix: SourceIter(KEYS_MIX),
tracks: match mode {
Mode::Sequencer => vec![Track::default()],
Mode::Groovebox => vec![Track {
devices: vec![
Sampler::new(
jack,
&"sampler",
midi_froms.as_slice(),
audio_froms,
audio_tos
)?.boxed()
],
..Track::default()
}],
_ => vec![]
},
scenes,
..Default::default()
};
if let &Mode::Arranger { scenes, tracks, track_width, .. } = mode {
app.arranger = Default::default();
app.selected = Selection::Clip(1, 1);
app.scenes_add(scenes);
app.tracks_add(tracks, Some(track_width), &[], &[]);
}
jack.sync_lead(self.sync_lead, |mut state|{
let clock = app.clock();
clock.playhead.update_from_sample(state.position.frame() as f64);
state.position.bbt = Some(clock.bbt());
state.position
});
jack.sync_follow(self.sync_follow);
Ok(app)
})?;
engine.run(&jack)
Tui::new()?.run(&jack)
}
}

0
app/edn/view_arranger.edn → cli/view_arranger.edn
View file

0
app/edn/view_groovebox.edn → cli/view_groovebox.edn
View file

0
app/edn/view_sequencer.edn → cli/view_sequencer.edn
View file

1
cli/view_transport.edn Normal file
View file

@ -0,0 +1 @@
:transport