mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-19 22:10:42 +01:00
445 lines
19 KiB
Rust
445 lines
19 KiB
Rust
//! 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);
|
||
}
|
||
}
|