mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 19:56:42 +01:00
353 lines
14 KiB
Rust
353 lines
14 KiB
Rust
use crate::*;
|
|
|
|
/// Contains state for viewing and editing a phrase
|
|
pub struct PhraseEditor<E: Engine> {
|
|
_engine: PhantomData<E>,
|
|
/// Phrase being played
|
|
pub phrase: Option<Arc<RwLock<Phrase>>>,
|
|
/// Length of note that will be inserted, in pulses
|
|
pub note_len: usize,
|
|
/// The full piano keys are rendered to this buffer
|
|
pub keys: Buffer,
|
|
/// The full piano roll is rendered to this buffer
|
|
pub buffer: BigBuffer,
|
|
/// Cursor/scroll/zoom in pitch axis
|
|
pub note_axis: RwLock<FixedAxis<usize>>,
|
|
/// Cursor/scroll/zoom in time axis
|
|
pub time_axis: RwLock<ScaledAxis<usize>>,
|
|
/// Whether this widget is focused
|
|
pub focused: bool,
|
|
/// Whether note enter mode is enabled
|
|
pub entered: bool,
|
|
/// Display mode
|
|
pub mode: bool,
|
|
/// Notes currently held at input
|
|
pub notes_in: Arc<RwLock<[bool; 128]>>,
|
|
/// Notes currently held at output
|
|
pub notes_out: Arc<RwLock<[bool; 128]>>,
|
|
/// Current position of global playhead
|
|
pub now: Arc<Pulse>,
|
|
/// Width of notes area at last render
|
|
pub width: AtomicUsize,
|
|
/// Height of notes area at last render
|
|
pub height: AtomicUsize,
|
|
}
|
|
|
|
impl Content for PhraseEditor<Tui> {
|
|
type Engine = Tui;
|
|
fn content (&self) -> impl Widget<Engine = Tui> {
|
|
let Self { focused, entered, keys, phrase, buffer, note_len, .. } = self;
|
|
let FixedAxis {
|
|
start: note_start, point: note_point, clamp: note_clamp
|
|
} = *self.note_axis.read().unwrap();
|
|
let ScaledAxis {
|
|
start: time_start, point: time_point, clamp: time_clamp, scale: time_scale
|
|
} = *self.time_axis.read().unwrap();
|
|
//let color = Color::Rgb(0,255,0);
|
|
//let color = phrase.as_ref().map(|p|p.read().unwrap().color.base.rgb).unwrap_or(color);
|
|
let keys = CustomWidget::new(|to:[u16;2]|Ok(Some(to.clip_w(5))), move|to: &mut TuiOutput|{
|
|
Ok(if to.area().h() >= 2 {
|
|
to.buffer_update(to.area().set_w(5), &|cell, x, y|{
|
|
let y = y + (note_start / 2) as u16;
|
|
if x < keys.area.width && y < keys.area.height {
|
|
*cell = keys.get(x, y).clone()
|
|
}
|
|
});
|
|
})
|
|
}).fill_y();
|
|
let notes_bg_null = Color::Rgb(28, 35, 25);
|
|
let notes = CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
|
|
let area = to.area();
|
|
let h = area.h() as usize;
|
|
self.height.store(h, Ordering::Relaxed);
|
|
self.width.store(area.w() as usize, Ordering::Relaxed);
|
|
let mut axis = self.note_axis.write().unwrap();
|
|
if let Some(point) = axis.point {
|
|
if point.saturating_sub(axis.start) > (h * 2).saturating_sub(1) {
|
|
axis.start += 2;
|
|
}
|
|
}
|
|
Ok(if to.area().h() >= 2 {
|
|
let area = to.area();
|
|
to.buffer_update(area, &move |cell, x, y|{
|
|
cell.set_bg(notes_bg_null);
|
|
let src_x = (x as usize + time_start) * time_scale;
|
|
let src_y = y as usize + note_start / 2;
|
|
if src_x < buffer.width && src_y < buffer.height - 1 {
|
|
buffer.get(src_x, buffer.height - src_y - 2).map(|src|{
|
|
cell.set_symbol(src.symbol());
|
|
cell.set_fg(src.fg);
|
|
cell.set_bg(src.bg);
|
|
});
|
|
}
|
|
});
|
|
})
|
|
}).fill_x();
|
|
let cursor = CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
|
|
Ok(if *focused && *entered {
|
|
let area = to.area();
|
|
if let (Some(time), Some(note)) = (time_point, note_point) {
|
|
let x1 = area.x() + (time / time_scale) as u16;
|
|
let x2 = x1 + (self.note_len / time_scale) as u16;
|
|
let y = area.y() + note.saturating_sub(note_start) as u16 / 2;
|
|
let c = if note % 2 == 0 { "▀" } else { "▄" };
|
|
for x in x1..x2 {
|
|
to.blit(&c, x, y, Some(Style::default().fg(Color::Rgb(0,255,0))));
|
|
}
|
|
}
|
|
})
|
|
});
|
|
let playhead_inactive = Style::default().fg(Color::Rgb(255,255,255)).bg(Color::Rgb(40,50,30));
|
|
let playhead_active = playhead_inactive.clone().yellow().bold().not_dim();
|
|
let playhead = CustomWidget::new(
|
|
|to:[u16;2]|Ok(Some(to.clip_h(1))),
|
|
move|to: &mut TuiOutput|{
|
|
if let Some(_) = phrase {
|
|
let now = self.now.get() as usize; // TODO FIXME: self.now % phrase.read().unwrap().length;
|
|
let time_clamp = time_clamp
|
|
.expect("time_axis of sequencer expected to be clamped");
|
|
for x in 0..(time_clamp/time_scale).saturating_sub(time_start) {
|
|
let this_step = time_start + (x + 0) * time_scale;
|
|
let next_step = time_start + (x + 1) * time_scale;
|
|
let x = to.area().x() + x as u16;
|
|
let active = this_step <= now && now < next_step;
|
|
let character = if active { "|" } else { "·" };
|
|
let style = if active { playhead_active } else { playhead_inactive };
|
|
to.blit(&character, x, to.area.y(), Some(style));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
).push_x(6).align_sw();
|
|
let border_color = if *focused{Color::Rgb(100, 110, 40)}else{Color::Rgb(70, 80, 50)};
|
|
let title_color = if *focused{Color::Rgb(150, 160, 90)}else{Color::Rgb(120, 130, 100)};
|
|
let border = Lozenge(Style::default().bg(Color::Rgb(40, 50, 30)).fg(border_color));
|
|
let note_area = lay!(notes, cursor).fill_x();
|
|
let piano_roll = row!(keys, note_area).fill_x();
|
|
let content = piano_roll.bg(Color::Rgb(40, 50, 30)).border(border);
|
|
let content = lay!(content, playhead);
|
|
let mut upper_left = format!("[{}] Sequencer", if *entered {"■"} else {" "});
|
|
if let Some(phrase) = phrase {
|
|
upper_left = format!("{upper_left}: {}", phrase.read().unwrap().name);
|
|
}
|
|
let mut lower_right = format!(
|
|
"┤{}x{}├",
|
|
self.width.load(Ordering::Relaxed),
|
|
self.height.load(Ordering::Relaxed),
|
|
);
|
|
lower_right = format!("┤Zoom: {}├─{lower_right}", pulses_to_name(time_scale));
|
|
//lower_right = format!("Zoom: {} (+{}:{}*{}|{})",
|
|
//pulses_to_name(time_scale),
|
|
//time_start, time_point.unwrap_or(0),
|
|
//time_scale, time_clamp.unwrap_or(0),
|
|
//);
|
|
if *focused && *entered {
|
|
lower_right = format!("┤Note: {} {}├─{lower_right}",
|
|
self.note_axis.read().unwrap().point.unwrap(),
|
|
pulses_to_name(*note_len));
|
|
//lower_right = format!("Note: {} (+{}:{}|{}) {upper_right}",
|
|
//pulses_to_name(*note_len),
|
|
//note_start,
|
|
//note_point.unwrap_or(0),
|
|
//note_clamp.unwrap_or(0),
|
|
//);
|
|
}
|
|
let upper_right = if let Some(phrase) = phrase {
|
|
format!("┤Length: {}├", phrase.read().unwrap().length)
|
|
} else {
|
|
String::new()
|
|
};
|
|
lay!(
|
|
content,
|
|
TuiStyle::fg(upper_left.to_string(), title_color).push_x(1).align_nw().fill_xy(),
|
|
TuiStyle::fg(upper_right.to_string(), title_color).pull_x(1).align_ne().fill_xy(),
|
|
TuiStyle::fg(lower_right.to_string(), title_color).pull_x(1).align_se().fill_xy(),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<E: Engine> PhraseEditor<E> {
|
|
pub fn new () -> Self {
|
|
Self {
|
|
_engine: Default::default(),
|
|
phrase: None,
|
|
note_len: 24,
|
|
notes_in: Arc::new(RwLock::new([false;128])),
|
|
notes_out: Arc::new(RwLock::new([false;128])),
|
|
keys: keys_vert(),
|
|
buffer: Default::default(),
|
|
focused: false,
|
|
entered: false,
|
|
mode: false,
|
|
now: Arc::new(0.into()),
|
|
width: 0.into(),
|
|
height: 0.into(),
|
|
note_axis: RwLock::new(FixedAxis {
|
|
start: 12,
|
|
point: Some(36),
|
|
clamp: Some(127)
|
|
}),
|
|
time_axis: RwLock::new(ScaledAxis {
|
|
start: 00,
|
|
point: Some(00),
|
|
clamp: Some(000),
|
|
scale: 24
|
|
}),
|
|
}
|
|
}
|
|
|
|
pub fn time_cursor_advance (&self) {
|
|
let point = self.time_axis.read().unwrap().point;
|
|
let length = self.phrase.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);
|
|
let forward = |time|(time + self.note_len) % length;
|
|
self.time_axis.write().unwrap().point = point.map(forward);
|
|
}
|
|
|
|
pub fn put (&mut self) {
|
|
if let (Some(phrase), Some(time), Some(note)) = (
|
|
&self.phrase,
|
|
self.time_axis.read().unwrap().point,
|
|
self.note_axis.read().unwrap().point,
|
|
) {
|
|
let mut phrase = phrase.write().unwrap();
|
|
let key: u7 = u7::from((127 - note) as u8);
|
|
let vel: u7 = 100.into();
|
|
let start = time;
|
|
let end = (start + self.note_len) % phrase.length;
|
|
phrase.notes[time].push(MidiMessage::NoteOn { key, vel });
|
|
phrase.notes[end].push(MidiMessage::NoteOff { key, vel });
|
|
self.buffer = Self::redraw(&phrase);
|
|
}
|
|
}
|
|
/// Select which pattern to display. This pre-renders it to the buffer at full resolution.
|
|
pub fn show (&mut self, phrase: Option<&Arc<RwLock<Phrase>>>) {
|
|
if let Some(phrase) = phrase {
|
|
self.phrase = Some(phrase.clone());
|
|
self.time_axis.write().unwrap().clamp = Some(phrase.read().unwrap().length);
|
|
self.buffer = Self::redraw(&*phrase.read().unwrap());
|
|
} else {
|
|
self.phrase = None;
|
|
self.time_axis.write().unwrap().clamp = Some(0);
|
|
self.buffer = Default::default();
|
|
}
|
|
}
|
|
fn redraw (phrase: &Phrase) -> BigBuffer {
|
|
let mut buf = BigBuffer::new(usize::MAX.min(phrase.length), 65);
|
|
Self::fill_seq_bg(&mut buf, phrase.length, phrase.ppq);
|
|
Self::fill_seq_fg(&mut buf, &phrase);
|
|
buf
|
|
}
|
|
fn fill_seq_bg (buf: &mut BigBuffer, length: usize, ppq: usize) {
|
|
for x in 0..buf.width {
|
|
// Only fill as far as phrase length
|
|
if x as usize >= length { break }
|
|
// Fill each row with background characters
|
|
for y in 0 .. buf.height {
|
|
buf.get_mut(x, y).map(|cell|{
|
|
cell.set_char(if ppq == 0 {
|
|
'·'
|
|
} else if x % (4 * ppq) == 0 {
|
|
'│'
|
|
} else if x % ppq == 0 {
|
|
'╎'
|
|
} else {
|
|
'·'
|
|
});
|
|
cell.set_fg(Color::Rgb(48, 64, 56));
|
|
cell.modifier = Modifier::DIM;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
fn fill_seq_fg (buf: &mut BigBuffer, phrase: &Phrase) {
|
|
let mut notes_on = [false;128];
|
|
for x in 0..buf.width {
|
|
if x as usize >= phrase.length {
|
|
break
|
|
}
|
|
if let Some(notes) = phrase.notes.get(x as usize) {
|
|
if phrase.percussive {
|
|
for note in notes {
|
|
match note {
|
|
MidiMessage::NoteOn { key, .. } =>
|
|
notes_on[key.as_int() as usize] = true,
|
|
_ => {}
|
|
}
|
|
}
|
|
} else {
|
|
for note in notes {
|
|
match note {
|
|
MidiMessage::NoteOn { key, .. } =>
|
|
notes_on[key.as_int() as usize] = true,
|
|
MidiMessage::NoteOff { key, .. } =>
|
|
notes_on[key.as_int() as usize] = false,
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
for y in 0..buf.height {
|
|
if y >= 64 {
|
|
break
|
|
}
|
|
if let Some(block) = half_block(
|
|
notes_on[y as usize * 2],
|
|
notes_on[y as usize * 2 + 1],
|
|
) {
|
|
buf.get_mut(x, y).map(|cell|{
|
|
cell.set_char(block);
|
|
cell.set_fg(Color::White);
|
|
});
|
|
}
|
|
}
|
|
if phrase.percussive {
|
|
notes_on.fill(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Colors of piano keys
|
|
const KEY_COLORS: [(Color, Color);6] = [
|
|
(Color::Rgb(255, 255, 255), Color::Rgb(255, 255, 255)),
|
|
(Color::Rgb(0, 0, 0), Color::Rgb(255, 255, 255)),
|
|
(Color::Rgb(0, 0, 0), Color::Rgb(255, 255, 255)),
|
|
(Color::Rgb(0, 0, 0), Color::Rgb(255, 255, 255)),
|
|
(Color::Rgb(255, 255, 255), Color::Rgb(0, 0, 0)),
|
|
(Color::Rgb(255, 255, 255), Color::Rgb(0, 0, 0)),
|
|
];
|
|
|
|
pub(crate) fn keys_vert () -> Buffer {
|
|
let area = [0, 0, 5, 64];
|
|
let mut buffer = Buffer::empty(Rect {
|
|
x: area.x(), y: area.y(), width: area.w(), height: area.h()
|
|
});
|
|
buffer_update(&mut buffer, area, &|cell, x, y| {
|
|
let y = 63 - y;
|
|
match x {
|
|
0 => {
|
|
cell.set_char('▀');
|
|
let (fg, bg) = KEY_COLORS[((6 - y % 6) % 6) as usize];
|
|
cell.set_fg(fg);
|
|
cell.set_bg(bg);
|
|
},
|
|
1 => {
|
|
cell.set_char('▀');
|
|
cell.set_fg(Color::White);
|
|
cell.set_bg(Color::White);
|
|
},
|
|
2 => if y % 6 == 0 {
|
|
cell.set_char('C');
|
|
},
|
|
3 => if y % 6 == 0 {
|
|
cell.set_symbol(NTH_OCTAVE[(y / 6) as usize]);
|
|
},
|
|
_ => {}
|
|
}
|
|
});
|
|
buffer
|
|
}
|
|
|
|
const NTH_OCTAVE: [&'static str; 11] = [
|
|
"-2", "-1", "0", "1", "2", "3", "4", "5", "6", "7", "8",
|
|
];
|