nvrl
f36ff0780c
Check and Windows preview / check (anvil) (push) Successful in 2m41s
Check and Windows preview / check (crucible) (push) Successful in 2m7s
Check and Windows preview / check (patina) (push) Successful in 2m5s
Check and Windows preview / check (rivet) (push) Successful in 1m33s
Check and Windows preview / previews (push) Successful in 1m10s
Check and Windows preview / windows (push) Successful in 2m2s
Independent plugin release / publish (push) Successful in 8s
Independent plugin release / plan (push) Successful in 7s
Independent plugin release / build (push) Successful in 3m3s
Two new CLAP effects aimed at riddim and dubstep production, plus shared crates so all four plugins keep one look and reuse DSP. Anvil 0.1.0 (io.storyboard.sub-anchor): - Replaces the band below Split with a clean mono sine. Every note gets the same peak level and restarts at the same phase, so switch-ups keep their weight and kick hits line up. - Pitch and note starts come from the audio (YIN, 80 ms lookahead reported to the host) or from MIDI notes sent to the effect. - Dynamics, Drive, Octave, Glide, Phase, Gate and Keep; Solo sub monitor, note readout, level meters and a low-band oscilloscope. Crucible 0.1.0 (io.storyboard.resampler): - Records its input continuously in a lock-free ring with host transport markers. Capture takes the newest 1-16 complete bars on the bar grid, following tempo changes, or the newest audio when stopped. - Grid (straight and triplet) or transient slicing, manual cuts, slice audition without audio-thread allocation. - Export writes the loop, trimmed, declicked and normalised slices named and tagged with their root note, and an optional 2048-sample wavetable for Serum and Vital. Shared: - common-ui holds the palette, fonts, knobs and panels taken from Patina; Patina renders identically. Rotary knobs at their minimum no longer tessellate a zero-length arc into NaN vertices. - common-dsp holds biquads, a Linkwitz-Riley crossover, YIN, note helpers and a float WAV writer with sampler root and Serum frame chunks. - Catalog, CI matrix, release tags, editor previews and docs cover both plugins; a script test keeps the catalog and workflows in step.
321 lines
11 KiB
Rust
321 lines
11 KiB
Rust
//! Shared hardware look for every plugin editor: palette, fonts, knobs, panels.
|
||
use egui::{self, Color32, FontId, Pos2, Rect, RichText, Sense, Stroke, Vec2};
|
||
|
||
// Dark anodized hardware: graphite surfaces, one signal colour, steel data traces.
|
||
pub const BG: Color32 = Color32::from_rgb(14, 15, 17);
|
||
pub const PANEL: Color32 = Color32::from_rgb(25, 27, 31);
|
||
pub const PANEL_TOP: Color32 = Color32::from_rgb(34, 36, 41);
|
||
pub const EDGE: Color32 = Color32::from_rgb(44, 47, 53);
|
||
pub const SCREEN: Color32 = Color32::from_rgb(9, 10, 11);
|
||
pub const TEXT: Color32 = Color32::from_rgb(232, 233, 236);
|
||
pub const MUTED: Color32 = Color32::from_rgb(140, 146, 156);
|
||
pub const DIM: Color32 = Color32::from_rgb(70, 74, 82);
|
||
/// Signal colour: cuts, active states, value arcs.
|
||
pub const ACCENT: Color32 = Color32::from_rgb(255, 1, 96);
|
||
/// Measured input and neutral data.
|
||
pub const STEEL: Color32 = Color32::from_rgb(184, 192, 204);
|
||
/// Focus / protect curve, distinct from cuts without competing with them.
|
||
pub const FOCUS: Color32 = Color32::from_rgb(126, 167, 216);
|
||
pub fn style(ctx: &egui::Context) {
|
||
let mut fonts = egui::FontDefinitions::default();
|
||
fonts.font_data.insert(
|
||
"regular".into(),
|
||
egui::FontData::from_static(include_bytes!("../assets/RobotoCondensed-Regular.ttf")).into(),
|
||
);
|
||
fonts.font_data.insert(
|
||
"medium".into(),
|
||
egui::FontData::from_static(include_bytes!("../assets/RobotoCondensed-Medium.ttf")).into(),
|
||
);
|
||
fonts
|
||
.families
|
||
.get_mut(&egui::FontFamily::Proportional)
|
||
.unwrap()
|
||
.insert(0, "regular".into());
|
||
fonts.families.insert(
|
||
egui::FontFamily::Name("medium".into()),
|
||
vec![
|
||
"medium".into(),
|
||
"Ubuntu-Light".into(),
|
||
"NotoEmoji-Regular".into(),
|
||
"emoji-icon-font".into(),
|
||
],
|
||
);
|
||
ctx.set_fonts(fonts);
|
||
let mut s = (*ctx.style()).clone();
|
||
let v = &mut s.visuals;
|
||
*v = egui::Visuals::dark();
|
||
v.panel_fill = BG;
|
||
v.window_fill = PANEL;
|
||
v.extreme_bg_color = SCREEN;
|
||
v.faint_bg_color = PANEL;
|
||
v.override_text_color = Some(TEXT);
|
||
v.selection.bg_fill = Color32::from_rgb(110, 6, 46);
|
||
v.selection.stroke = Stroke::new(1.0_f32, ACCENT);
|
||
v.hyperlink_color = ACCENT;
|
||
v.window_stroke = Stroke::new(1.0_f32, EDGE);
|
||
for (w, fill, stroke) in [
|
||
(&mut v.widgets.noninteractive, PANEL, EDGE),
|
||
(&mut v.widgets.inactive, Color32::from_rgb(35, 38, 43), EDGE),
|
||
(
|
||
&mut v.widgets.hovered,
|
||
Color32::from_rgb(45, 48, 54),
|
||
Color32::from_rgb(78, 82, 90),
|
||
),
|
||
(&mut v.widgets.active, Color32::from_rgb(58, 18, 34), ACCENT),
|
||
(&mut v.widgets.open, Color32::from_rgb(35, 38, 43), EDGE),
|
||
] {
|
||
w.bg_fill = fill;
|
||
w.weak_bg_fill = fill;
|
||
w.bg_stroke = Stroke::new(1.0_f32, stroke);
|
||
w.corner_radius = 3.into();
|
||
}
|
||
v.widgets.noninteractive.fg_stroke = Stroke::new(1.0_f32, TEXT);
|
||
v.widgets.inactive.fg_stroke = Stroke::new(1.0_f32, TEXT);
|
||
v.slider_trailing_fill = true;
|
||
s.spacing.item_spacing = Vec2::new(10., 8.);
|
||
s.spacing.button_padding = Vec2::new(12., 6.);
|
||
s.text_styles
|
||
.insert(egui::TextStyle::Body, FontId::proportional(16.));
|
||
s.text_styles
|
||
.insert(egui::TextStyle::Button, FontId::proportional(16.));
|
||
ctx.set_style(s);
|
||
}
|
||
/// Disc with a vertical light-to-dark gradient, like brushed metal lit from above.
|
||
pub fn metal_disc(p: &egui::Painter, center: Pos2, radius: f32, top: Color32, bottom: Color32) {
|
||
let mut mesh = egui::Mesh::default();
|
||
let mix = |t: f32| {
|
||
let l = |a: u8, b: u8| (a as f32 + (b as f32 - a as f32) * t).round() as u8;
|
||
Color32::from_rgb(
|
||
l(top.r(), bottom.r()),
|
||
l(top.g(), bottom.g()),
|
||
l(top.b(), bottom.b()),
|
||
)
|
||
};
|
||
mesh.colored_vertex(center, mix(0.5));
|
||
let n = 48;
|
||
for i in 0..=n {
|
||
let a = std::f32::consts::TAU * i as f32 / n as f32;
|
||
let point = center + Vec2::angled(a) * radius;
|
||
mesh.colored_vertex(point, mix((point.y - (center.y - radius)) / (2. * radius)));
|
||
if i > 0 {
|
||
mesh.add_triangle(0, i, i + 1);
|
||
}
|
||
}
|
||
p.add(egui::Shape::mesh(mesh));
|
||
}
|
||
#[allow(clippy::too_many_arguments)]
|
||
pub fn rotary(
|
||
ui: &mut egui::Ui,
|
||
name: &str,
|
||
value: &mut f32,
|
||
range: std::ops::RangeInclusive<f32>,
|
||
default: f32,
|
||
unit: &str,
|
||
size: f32,
|
||
color: Color32,
|
||
) -> egui::Response {
|
||
let low = *range.start();
|
||
let high = *range.end();
|
||
let (rect, response) = ui.allocate_exact_size(Vec2::splat(size), Sense::click_and_drag());
|
||
if response.drag_started() {
|
||
response.request_focus();
|
||
}
|
||
if response.dragged() {
|
||
let delta = ui.input(|i| i.pointer.delta().y);
|
||
let fine = if ui.input(|i| i.modifiers.shift) {
|
||
0.1
|
||
} else {
|
||
1.
|
||
};
|
||
*value = (*value - delta * (high - low) / 180. * fine).clamp(low, high);
|
||
}
|
||
if response.double_clicked() {
|
||
*value = default;
|
||
}
|
||
if response.has_focus() {
|
||
let step = if ui.input(|i| i.modifiers.shift) {
|
||
0.1
|
||
} else {
|
||
1.
|
||
};
|
||
if ui.input(|i| i.key_pressed(egui::Key::ArrowUp) || i.key_pressed(egui::Key::ArrowRight)) {
|
||
*value = (*value + step).min(high);
|
||
}
|
||
if ui.input(|i| i.key_pressed(egui::Key::ArrowDown) || i.key_pressed(egui::Key::ArrowLeft))
|
||
{
|
||
*value = (*value - step).max(low);
|
||
}
|
||
}
|
||
let center = rect.center();
|
||
let radius = size * 0.46;
|
||
let p = ui.painter();
|
||
let start = std::f32::consts::PI * 0.75;
|
||
let span = std::f32::consts::PI * 1.5;
|
||
let normalized = ((*value - low) / (high - low)).clamp(0., 1.);
|
||
// Scale track and value arc around the knob.
|
||
for (fraction, stroke) in [
|
||
(1., Stroke::new(2.5_f32, DIM)),
|
||
(normalized, Stroke::new(2.5_f32, color)),
|
||
] {
|
||
// A zero-length polyline tessellates to NaN vertices.
|
||
if fraction < 1e-3 {
|
||
continue;
|
||
}
|
||
let points: Vec<_> = (0..=64)
|
||
.map(|i| {
|
||
let a = start + span * fraction * i as f32 / 64.;
|
||
center + Vec2::angled(a) * (radius - 1.5)
|
||
})
|
||
.collect();
|
||
p.add(egui::Shape::line(points, stroke));
|
||
}
|
||
// Machined body: drop shadow, brushed gradient skirt, flat cap.
|
||
let body = radius - 7.;
|
||
p.circle_filled(
|
||
center + Vec2::new(0., 2.),
|
||
body + 1.,
|
||
Color32::from_black_alpha(140),
|
||
);
|
||
metal_disc(
|
||
p,
|
||
center,
|
||
body,
|
||
Color32::from_rgb(78, 82, 90),
|
||
Color32::from_rgb(28, 30, 34),
|
||
);
|
||
p.circle_stroke(
|
||
center,
|
||
body,
|
||
Stroke::new(1.0_f32, Color32::from_rgb(10, 11, 12)),
|
||
);
|
||
let cap = body * 0.74;
|
||
metal_disc(
|
||
p,
|
||
center,
|
||
cap,
|
||
Color32::from_rgb(44, 47, 52),
|
||
Color32::from_rgb(33, 35, 40),
|
||
);
|
||
p.circle_stroke(
|
||
center,
|
||
cap,
|
||
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 22)),
|
||
);
|
||
let angle = start + span * normalized;
|
||
p.line_segment(
|
||
[
|
||
center + Vec2::angled(angle) * (cap * 0.35),
|
||
center + Vec2::angled(angle) * (cap - 2.),
|
||
],
|
||
Stroke::new(2.0_f32, TEXT),
|
||
);
|
||
if response.has_focus() {
|
||
p.circle_stroke(center, radius + 2., Stroke::new(1.0_f32, color));
|
||
}
|
||
ui.label(
|
||
RichText::new(name.to_uppercase())
|
||
.size(if size > 100. { 14. } else { 12. })
|
||
.color(MUTED),
|
||
);
|
||
ui.add(
|
||
egui::DragValue::new(value)
|
||
.range(range)
|
||
.speed(0.1)
|
||
.suffix(unit),
|
||
);
|
||
response
|
||
}
|
||
/// Vertical gradient rectangle, used for panel faces.
|
||
pub fn gradient(rect: Rect, top: Color32, bottom: Color32) -> egui::Shape {
|
||
let mut mesh = egui::Mesh::default();
|
||
for (pos, color) in [
|
||
(rect.left_top(), top),
|
||
(rect.right_top(), top),
|
||
(rect.right_bottom(), bottom),
|
||
(rect.left_bottom(), bottom),
|
||
] {
|
||
mesh.colored_vertex(pos, color);
|
||
}
|
||
mesh.add_triangle(0, 1, 2);
|
||
mesh.add_triangle(0, 2, 3);
|
||
egui::Shape::mesh(mesh)
|
||
}
|
||
/// Raised hardware panel: graphite face, hairline edge, faint top highlight.
|
||
pub fn panel<R>(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui) -> R) -> R {
|
||
let face = ui.painter().add(egui::Shape::Noop);
|
||
let inner = egui::Frame::new()
|
||
.inner_margin(14.)
|
||
.stroke(Stroke::new(1.0_f32, EDGE))
|
||
.show(ui, add);
|
||
let r = inner.response.rect;
|
||
ui.painter().set(face, gradient(r, PANEL_TOP, PANEL));
|
||
ui.painter().line_segment(
|
||
[
|
||
r.left_top() + Vec2::new(1., 1.),
|
||
r.right_top() + Vec2::new(-1., 1.),
|
||
],
|
||
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 16)),
|
||
);
|
||
inner.inner
|
||
}
|
||
pub fn caption(ui: &mut egui::Ui, text: &str) {
|
||
ui.label(RichText::new(text).size(11.).color(MUTED));
|
||
}
|
||
/// Small labelled hardware-style readout.
|
||
pub fn readout(ui: &mut egui::Ui, label: &str, value: String, color: Color32) {
|
||
ui.label(RichText::new(label).size(11.).color(MUTED));
|
||
ui.label(RichText::new(value).monospace().size(13.).color(color));
|
||
ui.add_space(10.);
|
||
}
|
||
/// Product header: accent mark, product name, subtitle, then right-aligned controls.
|
||
pub fn header(ui: &mut egui::Ui, name: &str, subtitle: &str, right: impl FnOnce(&mut egui::Ui)) {
|
||
ui.horizontal(|ui| {
|
||
let (mark, _) = ui.allocate_exact_size(Vec2::new(4., 26.), Sense::hover());
|
||
ui.painter().rect_filled(mark, 1., ACCENT);
|
||
ui.label(
|
||
RichText::new(name)
|
||
.font(FontId::new(26., egui::FontFamily::Name("medium".into())))
|
||
.color(TEXT),
|
||
);
|
||
ui.label(RichText::new(subtitle).size(12.).color(MUTED));
|
||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), right);
|
||
});
|
||
}
|
||
/// Full-window backdrop gradient used behind every editor.
|
||
pub fn backdrop(ui: &egui::Ui) {
|
||
ui.painter()
|
||
.add(gradient(ui.max_rect(), Color32::from_rgb(20, 21, 24), BG));
|
||
}
|
||
/// Horizontal level bar in dBFS (−60..0) with a hairline frame.
|
||
pub fn meter(ui: &mut egui::Ui, label: &str, db: f32, color: Color32, width: f32) {
|
||
ui.horizontal(|ui| {
|
||
ui.add_sized(
|
||
Vec2::new(70., 16.),
|
||
egui::Label::new(RichText::new(label).size(11.).color(MUTED)),
|
||
);
|
||
let (rect, _) = ui.allocate_exact_size(Vec2::new(width, 10.), Sense::hover());
|
||
let p = ui.painter();
|
||
p.rect_filled(rect, 1., SCREEN);
|
||
let t = ((db + 60.) / 60.).clamp(0., 1.);
|
||
let mut fill = rect;
|
||
fill.set_width(rect.width() * t);
|
||
p.rect_filled(fill, 1., color);
|
||
p.rect_stroke(
|
||
rect,
|
||
1.,
|
||
Stroke::new(1.0_f32, EDGE),
|
||
egui::StrokeKind::Inside,
|
||
);
|
||
ui.label(
|
||
RichText::new(if db <= -60. {
|
||
"−∞".to_string()
|
||
} else {
|
||
format!("{db:.1} dB")
|
||
})
|
||
.monospace()
|
||
.size(12.)
|
||
.color(TEXT),
|
||
);
|
||
});
|
||
}
|