Files
texturecraft/crates/ui-egui/src/theme.rs
2026-11-01 20:40:48 +07:00

445 lines
19 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Design tokens and egui styling: the Craft look shared with the sibling apps (cool slate greys in
//! four brightness levels, flat faces with soft corners, panels as rounded cards and one accent
//! colour). Our own palette and widgets; no third-party assets.
use egui::{Color32, CornerRadius, FontFamily, FontId, Stroke, TextStyle, Visuals};
use serde::{Deserialize, Serialize};
use crate::i18n::n_;
/// Settings › Interface › Brightness: the greys of the interface. The 3D and 2D views keep their
/// studio slate in every level (they show a render, not chrome).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Brightness {
Dark,
MediumLight,
Light,
/// Charcoal, the default. An unknown value (a newer settings file) loads as this (serde wants
/// it last).
#[default]
#[serde(other)]
MediumDark,
}
impl Brightness {
pub const ALL: [Brightness; 4] = [Brightness::Dark, Brightness::MediumDark, Brightness::MediumLight, Brightness::Light];
/// The English label (translated where it is shown).
pub fn label(self) -> &'static str {
match self {
Brightness::Dark => n_("Dark"),
Brightness::MediumDark => n_("Medium dark"),
Brightness::MediumLight => n_("Medium light"),
Brightness::Light => n_("Light"),
}
}
}
/// Settings › Interface › Accent color: the one colour for what is on, chosen or focused. Copper,
/// the default, is the app icon's.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Accent {
Coral,
Blue,
Violet,
Green,
Amber,
Pink,
/// An unknown value (a newer settings file) loads as this (serde wants it last).
#[default]
#[serde(other)]
Copper,
}
impl Accent {
pub const ALL: [Accent; 7] = [Accent::Copper, Accent::Coral, Accent::Blue, Accent::Violet, Accent::Green, Accent::Amber, Accent::Pink];
/// The English label (translated where it is shown).
pub fn label(self) -> &'static str {
match self {
Accent::Copper => n_("Copper"),
Accent::Coral => n_("Coral"),
Accent::Blue => n_("Blue"),
Accent::Violet => n_("Violet"),
Accent::Green => n_("Green"),
Accent::Amber => n_("Amber"),
Accent::Pink => n_("Pink"),
}
}
/// (accent, accent_strong) on dark panels and on light ones; the strong one fills buttons
/// with white lettering. The values other than Copper's are VectorCraft's.
pub(crate) fn colors(self, dark: bool) -> (Color32, Color32) {
let (a, strong) = match (self, dark) {
// The app icon's copper (#c2672b, assets/app-icon/texturecraft.svg).
(Accent::Copper, true) => (0xe58a4e, 0xc2672b),
(Accent::Copper, false) => (0xae5419, 0xb85c22),
(Accent::Coral, true) => (0xf06a52, 0xe8573f),
(Accent::Coral, false) => (0xd9472f, 0xd14a33),
(Accent::Blue, true) => (0x5b96ff, 0x2f74f0),
(Accent::Blue, false) => (0x2563eb, 0x1f5ad6),
(Accent::Violet, true) => (0xa98bff, 0x7c55f0),
(Accent::Violet, false) => (0x7146dc, 0x6a3fd4),
(Accent::Green, true) => (0x3fcf8e, 0x1f9d63),
(Accent::Green, false) => (0x16955a, 0x14874f),
(Accent::Amber, true) => (0xf5b544, 0xc47f0e),
(Accent::Amber, false) => (0xb06d06, 0xb06d06),
(Accent::Pink, true) => (0xf36aa3, 0xdb3f7c),
(Accent::Pink, false) => (0xcc3672, 0xc22e69),
};
(hex(a), hex(strong))
}
}
const fn hex(s: u32) -> Color32 {
Color32::from_rgb((s >> 16) as u8, (s >> 8) as u8, s as u8)
}
/// Colors and metrics used across the UI, fetched each frame with [`Tokens::get`]. Never
/// hard-code a colour elsewhere.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Tokens {
/// Light lettering on dark faces (false for the light brightness levels).
pub dark: bool,
/// The window's frame: menu bar, status bar and the margins around the cards.
pub chrome: Color32,
/// Card faces: dock panels, tool bar, tool shelf, rail.
pub panel: Color32,
/// Insets on a card: list rows, output templates.
pub row: Color32,
pub row_hover: Color32,
/// Selected rows: the panel tinted towards the accent.
pub row_selected: Color32,
/// Hairlines inside cards.
pub separator: Color32,
pub text: Color32,
pub text_dim: Color32,
pub text_strong: Color32,
/// What is on, chosen or focused.
pub accent: Color32,
/// Buttons filled with the accent (white lettering).
pub accent_strong: Color32,
/// Accent-tinted fills: selected buttons and text, drop targets.
pub accent_dim: Color32,
/// Text fields.
pub field: Color32,
pub field_border: Color32,
/// Flat button faces.
pub button: Color32,
/// Slider rails and outlines that must show on a card.
pub button_border: Color32,
/// The well behind an active tool or a toggled button (accent-tinted).
pub tool_active: Color32,
pub danger: Color32,
/// Warnings and the mask-view marker.
pub warning: Color32,
/// The 3D and 2D views' background (the middle of the renderer's studio backdrop): a dark,
/// faintly cool slate in every brightness, so colors are judged against the same ground.
pub viewport: Color32,
/// Lettering drawn over the views (always on their dark slate).
pub viewport_text: Color32,
/// The accent drawn over the views (its dark-panel shade, whatever the brightness).
pub viewport_accent: Color32,
pub radius: u8,
}
impl Default for Tokens {
fn default() -> Self {
Tokens::for_brightness(Brightness::default()).with_accent(Accent::default())
}
}
impl Tokens {
/// The greys of brightness `b` (VectorCraft's values, mapped onto these names); the accent
/// colours are placeholders until [`Tokens::with_accent`].
pub fn for_brightness(b: Brightness) -> Self {
let base = Tokens {
dark: true,
chrome: hex(0x0b0d12),
panel: hex(0x181b22),
row: hex(0x13161c),
row_hover: hex(0x262b35),
row_selected: hex(0x3a2a2c),
separator: hex(0x232832),
text: hex(0xdfe4ec),
text_dim: hex(0x969faf),
text_strong: hex(0xffffff),
accent: hex(0xe58a4e),
accent_strong: hex(0xc2672b),
accent_dim: hex(0x5a3e30),
field: hex(0x0f1116),
field_border: hex(0x2c323e),
button: hex(0x282d37),
button_border: hex(0x4a5363),
tool_active: hex(0x2f3541),
danger: hex(0xe0554a),
warning: hex(0xe0b040),
viewport: hex(0x272b31),
viewport_text: hex(0x9aa1ad),
viewport_accent: hex(0xe58a4e),
radius: 5,
};
let light = Tokens { dark: false, text: hex(0x1b1f27), text_strong: hex(0x000000), danger: hex(0xc8372d), warning: hex(0x8f5f00), ..base };
match b {
Brightness::Dark => base,
Brightness::MediumDark => Tokens {
chrome: hex(0x1b1f27),
panel: hex(0x272c36),
row: hex(0x21262f),
row_hover: hex(0x353c49),
separator: hex(0x323946),
text: hex(0xe4e9f1),
text_dim: hex(0x99a2b2),
field: hex(0x1a1e26),
field_border: hex(0x3a414e),
button: hex(0x39404d),
button_border: hex(0x5a6476),
tool_active: hex(0x3d4553),
..base
},
Brightness::MediumLight => Tokens {
chrome: hex(0xc4cad4),
panel: hex(0xd3d8e0),
row: hex(0xc9cfd8),
row_hover: hex(0xc5ccd6),
separator: hex(0xbcc3ce),
text_dim: hex(0x4a5160),
field: hex(0xe9ecf1),
field_border: hex(0x9aa2b0),
button: hex(0xc9d0da),
button_border: hex(0x8a93a2),
tool_active: hex(0xb6bec9),
..light
},
Brightness::Light => Tokens {
chrome: hex(0xe6e9ee),
panel: hex(0xf3f5f8),
row: hex(0xe9ecf1),
row_hover: hex(0xe3e7ed),
separator: hex(0xdde1e8),
text_dim: hex(0x58606e),
field: hex(0xffffff),
field_border: hex(0xc3c9d3),
button: hex(0xe3e7ed),
button_border: hex(0xa4abb8),
tool_active: hex(0xd5dbe3),
..light
},
}
}
/// These tokens with `accent`: the accent, buttons filled with it, and selected rows, active
/// tools and selections (the panel tinted towards it).
pub fn with_accent(self, accent: Accent) -> Self {
let (a, strong) = accent.colors(self.dark);
let tint = |k: f32| {
let mix = |p: u8, q: u8| (f32::from(p) + (f32::from(q) - f32::from(p)) * k).round() as u8;
Color32::from_rgb(mix(self.panel.r(), a.r()), mix(self.panel.g(), a.g()), mix(self.panel.b(), a.b()))
};
Tokens {
accent: a,
accent_strong: strong,
accent_dim: tint(0.4),
row_selected: tint(if self.dark { 0.24 } else { 0.2 }),
tool_active: tint(if self.dark { 0.3 } else { 0.24 }),
viewport_accent: accent.colors(true).0,
..self
}
}
/// The tokens [`apply`] installed (the defaults before the first frame).
pub fn get(ctx: &egui::Context) -> Tokens {
ctx.data(|d| d.get_temp::<Tokens>(egui::Id::NULL)).unwrap_or_default()
}
pub fn cr(&self) -> CornerRadius {
CornerRadius::same(self.radius)
}
}
/// The corner radius of floating windows and menus.
pub const CARD_RADIUS: u8 = 8;
/// The window-frame gap between neighbouring cards and dock groups (the dock's own gap).
pub const GUTTER: i8 = 6;
/// The tool bar, the tool shelf, the rail and side panels are cards: `body` drawn `padding` inside
/// the panel colour, `margin` of the window's frame colour around it. Square like the dock's
/// groups, so the frame reads as one set of tiles with even gutters.
pub fn card<R>(ui: &mut egui::Ui, t: &Tokens, margin: egui::Margin, padding: egui::Margin, body: impl FnOnce(&mut egui::Ui) -> R) -> R {
egui::Frame::NONE
.fill(t.chrome)
.inner_margin(margin)
.show(ui, |ui| {
egui::Frame::NONE
.fill(t.panel)
.inner_margin(padding)
.show(ui, |ui| {
ui.set_min_size(ui.available_size());
body(ui)
})
.inner
})
.inner
}
/// Interface text in the semibold weight: headings and window titles.
pub fn semibold(size: f32) -> FontId {
FontId::new(size, FontFamily::Name(SEMIBOLD.into()))
}
/// The semibold family: Inter SemiBold, the regular font without it.
pub(crate) const SEMIBOLD: &str = "ui-semibold";
/// The app's fonts: Inter (regular and semibold) when built with craft-fonts, egui's defaults
/// otherwise, egui's monospace face for values, and the Phosphor icon font (`fonts::UiFonts`
/// adds CJK).
pub fn font_definitions() -> egui::FontDefinitions {
use std::sync::Arc;
let mut fonts = egui::FontDefinitions::default();
let face = |style: &str| crate::fonts::CRAFT_FONTS.iter().find(|f| f.family == "Inter" && f.style == style && !f.bytes.is_empty());
// Inter is drawn a little under its size, as in VectorCraft: its letters are wide.
let inter = |bytes: &'static [u8]| Arc::new(egui::FontData::from_static(bytes).tweak(egui::FontTweak { scale: 0.92, ..Default::default() }));
let mut semibold = None;
if let (Some(regular), Some(bold)) = (face("Regular"), face("SemiBold")) {
fonts.font_data.insert("inter".into(), inter(regular.bytes));
fonts.font_data.insert("inter-semibold".into(), inter(bold.bytes));
if let Some(list) = fonts.families.get_mut(&FontFamily::Proportional) {
list.insert(0, "inter".into());
}
semibold = Some("inter-semibold");
}
egui_phosphor::add_to_fonts(&mut fonts, egui_phosphor::Variant::Regular);
// The semibold family: the regular family with its first face swapped for the weight.
let mut list = fonts.families.get(&FontFamily::Proportional).cloned().unwrap_or_default();
if let (Some(w), Some(first)) = (semibold, list.first_mut()) {
*first = w.to_string();
}
fonts.families.insert(FontFamily::Name(SEMIBOLD.into()), list);
fonts
}
/// Install the fonts (once, at startup; the app applies the style from its settings).
pub fn install(ctx: &egui::Context) {
ctx.set_fonts(font_definitions());
}
/// Apply brightness `b` and `accent`: store the tokens for [`Tokens::get`] and style egui with
/// them. Cheap enough to call on a settings change, not meant for every frame.
pub fn apply(ctx: &egui::Context, b: Brightness, accent: Accent) {
let t = Tokens::for_brightness(b).with_accent(accent);
ctx.data_mut(|d| d.insert_temp(egui::Id::NULL, t));
ctx.all_styles_mut(|s| {
// VectorCraft's type scale: 11 small print, 13 body and controls, 15 headings (semibold),
// 11.5 values in the monospace face.
s.text_styles = [
(TextStyle::Small, FontId::new(11.0, FontFamily::Proportional)),
(TextStyle::Body, FontId::new(13.0, FontFamily::Proportional)),
(TextStyle::Button, FontId::new(13.0, FontFamily::Proportional)),
(TextStyle::Heading, semibold(15.0)),
(TextStyle::Monospace, FontId::new(11.5, FontFamily::Monospace)),
]
.into();
// A 2-4-6-8-12 spacing scale: 6 between items, 4 between rows, controls 24 high.
s.spacing.item_spacing = egui::vec2(6.0, 4.0);
s.spacing.button_padding = egui::vec2(8.0, 3.0);
s.spacing.interact_size = egui::vec2(24.0, 24.0);
s.spacing.slider_width = 120.0;
s.spacing.menu_margin = egui::Margin::same(6);
s.spacing.window_margin = egui::Margin::same(12);
s.animation_time = 0.08;
let mut v = if t.dark { Visuals::dark() } else { Visuals::light() };
v.panel_fill = t.panel;
v.window_fill = t.panel;
v.extreme_bg_color = t.field;
v.text_edit_bg_color = Some(t.field);
v.faint_bg_color = t.row;
v.code_bg_color = t.field;
v.window_stroke = Stroke::new(1.0, t.separator);
v.window_corner_radius = CornerRadius::same(CARD_RADIUS);
v.menu_corner_radius = CornerRadius::same(CARD_RADIUS);
v.popup_shadow = egui::epaint::Shadow { offset: [0, 4], blur: 14, spread: 0, color: Color32::from_black_alpha(if t.dark { 120 } else { 60 }) };
v.window_shadow = egui::epaint::Shadow { offset: [0, 8], blur: 28, spread: 0, color: Color32::from_black_alpha(if t.dark { 140 } else { 70 }) };
v.selection.bg_fill = t.accent_dim;
// Selected options and selected text are lettered in the strong colour: the accent on its
// own tint is hard to read.
v.selection.stroke = Stroke::new(1.0, t.text_strong);
v.hyperlink_color = t.accent;
let w = &mut v.widgets;
craft_ui::theme::WidgetPalette { noninteractive: t.panel, inactive: t.button, hovered: t.row_hover, active: t.tool_active, open: t.row_hover }
.apply_to(w, t.cr(), Stroke::new(1.0, t.text));
// Hovered and pressed lettering, and `RichText::strong` (captions), in the strong colour.
w.hovered.fg_stroke.color = t.text_strong;
w.active.fg_stroke.color = t.text_strong;
w.noninteractive.bg_stroke = Stroke::new(1.0, t.separator);
// Flat buttons: the outline is the face's own colour, so only text fields show it.
w.inactive.bg_stroke = Stroke::new(1.0, t.button);
w.hovered.bg_stroke = Stroke::new(1.0, t.field_border);
w.active.bg_stroke = Stroke::new(1.0, t.accent);
v.slider_trailing_fill = true;
v.striped = false;
s.visuals = v;
});
}
/// A section caption inside a panel: semibold in the strong colour, as written (no capitals).
pub fn caption(text: &str) -> egui::RichText {
egui::RichText::new(text).font(semibold(12.5)).strong()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn settings_round_trip_and_unknown_values_load_the_defaults() {
for b in Brightness::ALL {
let json = serde_json::to_value(b).unwrap();
assert_eq!(serde_json::from_value::<Brightness>(json).unwrap(), b);
}
for a in Accent::ALL {
let json = serde_json::to_value(a).unwrap();
assert_eq!(serde_json::from_value::<Accent>(json).unwrap(), a);
}
assert_eq!(serde_json::to_value(Brightness::MediumDark).unwrap(), "mediumDark");
assert_eq!(serde_json::from_value::<Brightness>("sepia".into()).unwrap(), Brightness::MediumDark);
assert_eq!(serde_json::from_value::<Accent>("teal".into()).unwrap(), Accent::Copper);
}
#[test]
fn every_brightness_and_accent_reads() {
// Relative luminance (WCAG) and contrast ratio.
let lum = |c: Color32| {
let ch = |v: u8| {
let v = f32::from(v) / 255.0;
if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
};
0.2126 * ch(c.r()) + 0.7152 * ch(c.g()) + 0.0722 * ch(c.b())
};
let contrast = |a: Color32, b: Color32| {
let (x, y) = (lum(a), lum(b));
(x.max(y) + 0.05) / (x.min(y) + 0.05)
};
for b in Brightness::ALL {
for a in Accent::ALL {
let t = Tokens::for_brightness(b).with_accent(a);
assert_eq!(t.dark, matches!(b, Brightness::Dark | Brightness::MediumDark));
assert!(contrast(t.text, t.panel) >= 7.0, "{b:?}: text on panel");
assert!(contrast(t.text_dim, t.panel) >= 4.5, "{b:?}: dim text on panel");
assert!(contrast(t.text, t.row_selected) >= 4.5, "{b:?} {a:?}: text on a selected row");
assert!(contrast(t.text_strong, t.accent_dim) >= 4.5, "{b:?} {a:?}: a selected option's lettering");
assert!(contrast(t.danger, t.panel) >= 3.0 && contrast(t.warning, t.panel) >= 3.0, "{b:?}: warnings on panel");
assert!(contrast(t.accent, t.panel) >= 2.5, "{b:?} {a:?}: accent on panel");
assert!(contrast(Color32::WHITE, t.accent_strong) >= 2.5, "{b:?} {a:?}: white on accent button");
assert!(contrast(t.viewport_text, t.viewport) >= 3.0, "{b:?}: lettering on the views");
// Slider rails show on the card.
assert!(contrast(t.button_border, t.panel) >= 1.6, "{b:?}: rail on panel");
}
}
// The views keep their studio slate.
assert_eq!(Tokens::for_brightness(Brightness::Light).viewport, Tokens::for_brightness(Brightness::Dark).viewport);
}
}