feat: add production UI gallery and inspector system
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-07-18 12:05:26 -04:00
1 parent cf6eaba534
commit 53dc1e44d8
95 files changed
+11003 -1652

No files matched your search

+818
View File
@@ -0,0 +1,818 @@
use std::path::PathBuf;
use editor_ui::inspector::{ComponentCardOptions, ComponentCardViewModel};
use editor_ui::materials::{
material_input_schema_editor, material_slot_panel, material_surface_options_ui,
materials_section, MaterialHealth, MaterialSlotAction, MaterialThumbnailPresentation,
MaterialsSectionViewModel,
};
use editor_ui::renderer::{
renderer_array_header, renderer_material_slot_row, renderer_material_slots_header,
renderer_panel, renderer_panel_header, renderer_properties_header,
RendererPanelHeaderViewModel,
};
use egui_phosphor_icons::icons;
use material_schema::{standard_lit_input_schema, MaterialShaderKind};
use crate::fixtures::{FixtureId, FixtureModel};
use crate::reference::{
difference_image, ComparisonMode, DifferenceStats, GalleryPreset, ReferenceImage,
};
use crate::reload::RuntimeDocuments;
pub struct UiGalleryApp {
preset: GalleryPreset,
comparison: ComparisonMode,
overlay_opacity: f32,
fixture_id: FixtureId,
fixture: FixtureModel,
fixture_textures: Vec<egui::TextureHandle>,
documents: RuntimeDocuments,
references: Vec<(GalleryPreset, ReferenceImage)>,
reference_error: Option<String>,
last_live_rect: Option<egui::Rect>,
last_reference_rect: Option<egui::Rect>,
difference_texture: Option<egui::TextureHandle>,
difference_stats: Option<DifferenceStats>,
difference_dirty: bool,
capture: Option<CaptureRequest>,
renderer_open: [bool; 3],
}
#[derive(Clone, Copy)]
struct CaptureRequest {
preset: GalleryPreset,
live_rect: egui::Rect,
reference_rect: egui::Rect,
pixels_per_point: f32,
}
impl UiGalleryApp {
pub fn new(creation: &eframe::CreationContext<'_>) -> Self {
creation
.egui_ctx
.set_fonts(editor_ui::fonts::font_definitions());
editor_ui::theme::apply_editor_theme(&creation.egui_ctx);
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("../..")
.canonicalize()
.unwrap_or_else(|_| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../.."));
let mut documents = RuntimeDocuments::new(&root);
documents.poll(0.0);
if let Ok(palette) = documents.theme_value.palette() {
editor_ui::theme::apply_editor_theme_with_palette(&creation.egui_ctx, palette);
}
let fixture_textures = make_fixture_textures(&creation.egui_ctx);
let (material_thumbnail, texture_thumbnails) = fixture_thumbnail_ids(&fixture_textures);
let fixture_id = FixtureId::Reference;
let fixture = FixtureModel::new(
fixture_id,
&documents.fixture_value,
material_thumbnail,
texture_thumbnails,
);
let mut references = Vec::new();
let mut reference_error = None;
for preset in GalleryPreset::ALL {
match ReferenceImage::load(&creation.egui_ctx, &root, preset) {
Ok(reference) => references.push((preset, reference)),
Err(error) => reference_error = Some(error),
}
}
Self {
preset: GalleryPreset::Materials620,
comparison: ComparisonMode::SideBySide,
overlay_opacity: 0.5,
fixture_id,
fixture,
fixture_textures,
documents,
references,
reference_error,
last_live_rect: None,
last_reference_rect: None,
difference_texture: None,
difference_stats: None,
difference_dirty: true,
capture: None,
renderer_open: [true, false, false],
}
}
fn rebuild_fixture(&mut self, ctx: &egui::Context) {
let (material_thumbnail, texture_thumbnails) =
fixture_thumbnail_ids(&self.fixture_textures);
self.fixture = FixtureModel::new(
self.fixture_id,
&self.documents.fixture_value,
material_thumbnail,
texture_thumbnails,
);
ctx.request_repaint();
self.difference_dirty = true;
}
fn select_preset(&mut self, ctx: &egui::Context, preset: GalleryPreset) {
if self.preset == preset {
return;
}
self.preset = preset;
if preset.is_renderer() && !self.fixture_id.is_renderer() {
self.fixture_id = FixtureId::StaticMesh;
self.rebuild_fixture(ctx);
}
self.difference_dirty = true;
}
fn select_fixture(&mut self, ctx: &egui::Context, fixture: FixtureId) {
if self.fixture_id == fixture {
return;
}
self.fixture_id = fixture;
self.rebuild_fixture(ctx);
}
fn select_comparison(&mut self, comparison: ComparisonMode) {
if self.comparison == comparison {
return;
}
self.comparison = comparison;
self.difference_dirty = true;
}
fn handle_shortcuts(&mut self, ctx: &egui::Context) {
let (function_key, shift, previous_fixture, next_fixture) = ctx.input(|input| {
let function_key = [egui::Key::F1, egui::Key::F2, egui::Key::F3, egui::Key::F4]
.into_iter()
.position(|key| input.key_pressed(key));
(
function_key,
input.modifiers.shift,
input.key_pressed(egui::Key::PageUp),
input.key_pressed(egui::Key::PageDown),
)
});
if let Some(index) = function_key {
if shift {
self.select_comparison(ComparisonMode::ALL[index]);
} else {
self.select_preset(ctx, GalleryPreset::ALL[index]);
}
}
if previous_fixture || next_fixture {
let current = FixtureId::ALL
.iter()
.position(|fixture| *fixture == self.fixture_id)
.unwrap_or_default();
let next = if previous_fixture {
current.checked_sub(1).unwrap_or(FixtureId::ALL.len() - 1)
} else {
(current + 1) % FixtureId::ALL.len()
};
self.select_fixture(ctx, FixtureId::ALL[next]);
}
}
fn reference(&self) -> Option<&ReferenceImage> {
self.references
.iter()
.find_map(|(preset, image)| (*preset == self.preset).then_some(image))
}
fn handle_screenshot_events(&mut self, ctx: &egui::Context) {
let screenshots = ctx.input(|input| {
input
.raw
.events
.iter()
.filter_map(|event| match event {
egui::Event::Screenshot { image, .. } => Some(image.clone()),
_ => None,
})
.collect::<Vec<_>>()
});
let Some(request) = self.capture.take() else {
return;
};
let Some(screenshot) = screenshots.last() else {
self.capture = Some(request);
return;
};
let (difference, stats) = difference_image(
screenshot,
request.live_rect,
request.reference_rect,
request.pixels_per_point,
request.preset,
);
if let Some(texture) = &mut self.difference_texture {
texture.set(difference, egui::TextureOptions::NEAREST);
} else {
self.difference_texture = Some(ctx.load_texture(
"blacksite-ui-gallery-difference",
difference,
egui::TextureOptions::NEAREST,
));
}
self.difference_stats = Some(stats);
self.difference_dirty = false;
}
fn toolbar(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
ui.horizontal_wrapped(|ui| {
ui.strong("Blacksite UI Gallery");
ui.separator();
egui::ComboBox::from_id_salt("gallery_preset")
.selected_text(self.preset.label())
.show_ui(ui, |ui| {
for preset in GalleryPreset::ALL {
let selected = self.preset == preset;
if ui.selectable_label(selected, preset.label()).clicked() {
self.select_preset(ctx, preset);
}
}
});
egui::ComboBox::from_id_salt("gallery_fixture")
.selected_text(self.fixture_id.label())
.show_ui(ui, |ui| {
for fixture in FixtureId::ALL {
let selected = self.fixture_id == fixture;
if ui.selectable_label(selected, fixture.label()).clicked() {
self.select_fixture(ctx, fixture);
}
}
});
for mode in ComparisonMode::ALL {
let selected = self.comparison == mode;
if ui.selectable_label(selected, mode.label()).clicked() {
self.select_comparison(mode);
}
}
if self.comparison == ComparisonMode::Overlay {
ui.add(
egui::Slider::new(&mut self.overlay_opacity, 0.0..=1.0)
.text("Reference opacity")
.show_value(false),
);
}
if self.comparison == ComparisonMode::Difference
&& ui.button("Refresh difference").clicked()
{
self.difference_dirty = true;
}
});
ui.horizontal_wrapped(|ui| {
ui.small(format!(
"Canvas: {} px · reference: {}",
self.preset.width() as u32,
self.preset.file_name()
));
ui.separator();
ui.small("Theme and fixture JSON reload without rebuilding");
ui.separator();
ui.small("F1–F4 presets · Shift+F1–F4 modes · PgUp/PgDn fixtures");
if let Some(stats) = self.difference_stats {
ui.separator();
ui.small(format!(
"Δ mean {:.2} · max {} · {:.1}% pixels > 8",
stats.mean_channel_delta, stats.max_channel_delta, stats.changed_percent
));
}
if let Some(error) = self
.documents
.error
.as_deref()
.or(self.reference_error.as_deref())
{
ui.colored_label(editor_ui::theme::ERROR, error);
}
});
}
fn render_comparison(&mut self, ui: &mut egui::Ui) {
let preset = self.preset;
match self.comparison {
ComparisonMode::Live => {
self.last_live_rect = Some(self.render_live_canvas(ui));
}
ComparisonMode::SideBySide => {
ui.horizontal_top(|ui| {
ui.vertical(|ui| {
ui.strong("Penpot reference");
if let Some(reference) = self.reference() {
reference.paint(ui, preset, 1.0);
}
});
ui.add_space(16.0);
ui.vertical(|ui| {
ui.strong("Production component");
self.last_live_rect = Some(self.render_live_canvas(ui));
});
});
}
ComparisonMode::Overlay => {
self.last_live_rect = Some(self.render_live_canvas(ui));
if let (Some(rect), Some(reference)) = (self.last_live_rect, self.reference()) {
let mut overlay_ui = ui.new_child(
egui::UiBuilder::new()
.max_rect(rect)
.layout(egui::Layout::top_down(egui::Align::Min)),
);
reference.paint(&mut overlay_ui, preset, self.overlay_opacity);
}
}
ComparisonMode::Difference => {
ui.horizontal_top(|ui| {
self.last_live_rect = Some(self.render_live_canvas(ui));
ui.add_space(16.0);
if self.difference_dirty || self.capture.is_some() {
self.last_reference_rect = self
.reference()
.map(|reference| reference.paint(ui, preset, 1.0).rect);
} else if let Some(texture) = &self.difference_texture {
self.last_reference_rect = None;
ui.image((
texture.id(),
egui::vec2(preset.width(), preset.target_height()),
));
} else {
ui.allocate_ui(egui::vec2(preset.width(), preset.target_height()), |ui| {
ui.centered_and_justified(|ui| {
ui.label("Difference capture pending…");
});
});
}
});
}
}
}
fn render_live_canvas(&mut self, ui: &mut egui::Ui) -> egui::Rect {
let size = egui::vec2(self.preset.width(), self.preset.target_height());
let (rect, _) = ui.allocate_exact_size(size, egui::Sense::hover());
let palette = editor_ui::design_system::palette(ui);
let (canvas_fill, canvas_radius) = if self.preset.is_renderer() {
(palette.recessed, 4.0)
} else {
(palette.panel, 7.0)
};
ui.painter().rect(
rect,
canvas_radius,
canvas_fill,
egui::Stroke::new(1.0_f32, palette.border_strong),
egui::StrokeKind::Inside,
);
// Penpot material boards are complete Inspector canvases, while renderer boards include a
// authored top inset before the component card. The preset owns both cases.
let content_rect = self.preset.content_rect(rect);
let mut child = ui.new_child(
egui::UiBuilder::new()
.max_rect(content_rect)
.layout(egui::Layout::top_down(egui::Align::Min)),
);
child.set_clip_rect(rect.intersect(ui.clip_rect()));
let previous_inputs = self.fixture.inputs.clone();
let previous_renderer_inputs = self
.fixture
.renderer_slots
.iter()
.map(|fixture| fixture.inputs.clone())
.collect::<Vec<_>>();
if self.preset.is_renderer() {
self.render_renderer_fixture(&mut child);
} else {
self.render_material_fixture(&mut child);
}
if previous_inputs != self.fixture.inputs
|| previous_renderer_inputs
!= self
.fixture
.renderer_slots
.iter()
.map(|fixture| fixture.inputs.clone())
.collect::<Vec<_>>()
{
self.difference_dirty = true;
}
rect
}
fn render_renderer_fixture(&mut self, ui: &mut egui::Ui) {
let title = if self.fixture_id == FixtureId::SkinnedMesh {
"Skinned Mesh Renderer"
} else {
"Static Mesh Renderer"
};
let component = ComponentCardViewModel {
options: ComponentCardOptions {
type_name: "gallery::Renderer",
title,
icon: icons::CUBE,
active_toggle: true,
removable: true,
reorderable: true,
resettable: true,
copyable: true,
summary: "3 renderers · 5 material slots",
body_margin: 0,
},
active: true,
collapsed: false,
pasteable: false,
can_move_up: false,
can_move_down: true,
};
editor_ui::inspector::component_card(ui, &component, |ui| {
let _ = renderer_array_header(ui, self.renderer_open.len());
ui.add_space(26.0);
for renderer_index in 0..self.renderer_open.len() {
let renderer_label = match renderer_index {
0 => "metal_office_desk / Primitive 0",
1 => "metal_office_desk_drawer_06 / Primitive 0",
_ => "metal_office_desk_tray_01 / Primitive 0",
};
renderer_panel(ui, |ui| {
renderer_panel_header(
ui,
RendererPanelHeaderViewModel {
index: renderer_index,
label: renderer_label,
path: "draw:scene0:node2:mesh2:primitive0",
slot_count: if renderer_index == 0 { 3 } else { 1 },
texture_id: None,
},
&mut self.renderer_open[renderer_index],
|ui| {
editor_ui::design_system::controls::icon_button(
ui,
icons::DOTS_THREE_VERTICAL,
"Renderer actions",
true,
);
editor_ui::design_system::controls::icon_button(
ui,
icons::X,
"Remove renderer",
true,
);
editor_ui::design_system::controls::icon_button(
ui,
icons::CROSSHAIR,
"Locate mesh",
true,
);
editor_ui::design_system::controls::icon_button(
ui,
icons::FOLDER_OPEN,
"Browse mesh",
true,
);
},
);
if !self.renderer_open[renderer_index] {
return;
}
renderer_properties_fixture(ui, renderer_label);
let slot_count = if renderer_index == 0 { 3 } else { 1 };
renderer_material_slots_header(ui, slot_count);
if renderer_index == 0 {
for slot_index in 0..self.fixture.renderer_slots.len() {
renderer_material_slot_row(ui, slot_index, |ui| {
self.render_renderer_material_slot(ui, slot_index);
});
}
}
});
}
});
}
fn render_material_fixture(&mut self, ui: &mut egui::Ui) {
let section = MaterialsSectionViewModel {
slot_ids: vec![self.fixture.slot.slot_id.clone()],
};
materials_section(ui, &section, |ui| {
let slot = &mut self.fixture.slot;
let render_state = &mut self.fixture.render_state;
let inputs = &mut self.fixture.inputs;
let textures = &self.fixture.textures;
let response = material_slot_panel(
ui,
("gallery-slot", &slot.slot_id),
slot,
|ui| {
material_surface_options_ui(ui, render_state, Some(inputs));
ui.add_space(4.0);
material_input_schema_editor(
ui,
&standard_lit_input_schema(),
inputs,
textures,
None,
);
},
|ui| {
ui.label(format!("Stable slot: {}", slot.slot_id));
ui.label("Gallery fixture — no project state is loaded");
},
);
for action in response.actions {
apply_slot_action(slot, action.action);
}
});
}
fn render_renderer_material_slot(&mut self, ui: &mut egui::Ui, slot_index: usize) {
let preset_label = self.preset.label();
let fixture = &mut self.fixture.renderer_slots[slot_index];
let slot_id = fixture.slot.slot_id.clone();
fixture.slot.expanded_header_when_parameters_closed = true;
fixture.slot.parameters_initially_open =
slot_index == 0 && self.preset == GalleryPreset::Renderer760;
let textures = &self.fixture.textures;
ui.push_id(
(
"gallery-renderer-slot-scope",
preset_label,
slot_id.as_str(),
),
|ui| {
let response = material_slot_panel(
ui,
"material-panel",
&fixture.slot,
|ui| {
material_surface_options_ui(
ui,
&mut fixture.render_state,
Some(&mut fixture.inputs),
);
ui.add_space(4.0);
material_input_schema_editor(
ui,
&standard_lit_input_schema(),
&mut fixture.inputs,
textures,
None,
);
},
|ui| {
ui.label(format!("Stable slot: {}", fixture.slot.slot_id));
ui.label("Gallery renderer fixture — no project state is loaded");
},
);
for action in response.actions {
apply_slot_action(&mut fixture.slot, action.action);
}
},
);
}
}
impl eframe::App for UiGalleryApp {
fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
self.handle_screenshot_events(ctx);
self.handle_shortcuts(ctx);
let now = ctx.input(|input| input.time);
if self.documents.poll(now) {
if let Ok(palette) = self.documents.theme_value.palette() {
editor_ui::theme::apply_editor_theme_with_palette(ctx, palette);
}
self.rebuild_fixture(ctx);
}
ctx.request_repaint_after(std::time::Duration::from_millis(250));
}
fn ui(&mut self, root: &mut egui::Ui, _frame: &mut eframe::Frame) {
let ctx = root.ctx().clone();
egui::CentralPanel::default().show_inside(root, |ui| {
self.toolbar(&ctx, ui);
ui.separator();
egui::ScrollArea::both()
.id_salt("gallery_canvas_scroll")
.auto_shrink([false, false])
.show(ui, |ui| self.render_comparison(ui));
if self.comparison == ComparisonMode::Difference
&& self.difference_dirty
&& self.capture.is_none()
{
if let (Some(live_rect), Some(reference_rect)) =
(self.last_live_rect, self.last_reference_rect)
{
self.capture = Some(CaptureRequest {
preset: self.preset,
live_rect,
reference_rect,
pixels_per_point: ctx.pixels_per_point(),
});
ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(egui::UserData::new(
"blacksite-ui-gallery-difference",
)));
}
}
});
}
}
fn renderer_properties_fixture(ui: &mut egui::Ui, name: &str) {
let palette = editor_ui::design_system::palette(ui);
let mut name_buffer = name.to_owned();
egui::Frame::new()
.inner_margin(egui::Margin::symmetric(12, 10))
.show(ui, |ui| {
renderer_properties_header(ui);
ui.add_space(2.0);
property_fixture_row(ui, "Name", |ui| {
ui.add_sized(
[ui.available_width().max(1.0), 24.0],
egui::TextEdit::singleline(&mut name_buffer),
);
});
ui.add_space(4.0);
property_fixture_row(ui, "Mesh", |ui| {
let field = ui.available_rect_before_wrap();
let field =
egui::Rect::from_min_size(field.min, egui::vec2(field.width().max(1.0), 38.0));
ui.allocate_rect(field, egui::Sense::hover());
ui.painter().rect(
field,
4.0,
palette.control,
egui::Stroke::new(1.0_f32, palette.border),
egui::StrokeKind::Inside,
);
ui.painter().text(
field.left_center() + egui::vec2(10.0, -7.0),
egui::Align2::LEFT_CENTER,
name,
editor_ui::design_system::typography::TypeRole::Body.font(),
palette.text_primary,
);
ui.painter().text(
field.left_center() + egui::vec2(10.0, 8.0),
egui::Align2::LEFT_CENTER,
"assets/Furniture/Office/metal_office_desk.mesh",
editor_ui::design_system::typography::TypeRole::Small.font(),
palette.text_muted,
);
});
ui.add_space(4.0);
property_fixture_row(ui, "Flags", |ui| {
let mut visible = true;
let mut cast_shadows = true;
let mut receive_shadows = true;
ui.horizontal_wrapped(|ui| {
ui.checkbox(&mut visible, "Visible");
ui.checkbox(&mut cast_shadows, "Cast shadows");
ui.checkbox(&mut receive_shadows, "Receive shadows");
});
});
ui.add_space(4.0);
});
}
fn property_fixture_row(ui: &mut egui::Ui, label: &str, add_value: impl FnOnce(&mut egui::Ui)) {
ui.horizontal_top(|ui| {
ui.allocate_ui_with_layout(
egui::vec2(72.0, 28.0),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
ui.label(label);
},
);
ui.vertical(add_value);
});
}
fn apply_slot_action(
slot: &mut editor_ui::materials::MaterialSlotPanelViewModel,
action: MaterialSlotAction,
) {
match action {
MaterialSlotAction::Assign { reference, .. } => {
slot.label = reference.label.clone();
slot.path = reference.source_path.clone();
slot.assigned = Some(reference);
slot.health = MaterialHealth::Dirty;
}
MaterialSlotAction::Clear => {
slot.assigned = None;
slot.health = MaterialHealth::Dirty;
}
MaterialSlotAction::SetShader(kind) => {
slot.shader_kind = Some(kind);
slot.shader = match kind {
MaterialShaderKind::StandardLit => "Standard Lit",
MaterialShaderKind::Unlit => "Unlit",
MaterialShaderKind::Custom => "Custom Surface",
}
.to_owned();
slot.health = MaterialHealth::Dirty;
}
MaterialSlotAction::BrowseLibrary
| MaterialSlotAction::Locate
| MaterialSlotAction::ExtractEditable
| MaterialSlotAction::CreateInstance => {}
}
}
fn make_fixture_textures(ctx: &egui::Context) -> Vec<egui::TextureHandle> {
let mut handles = vec![make_material_thumbnail(ctx)];
handles.extend([
checker_thumbnail(ctx, "gallery-base-color", [126, 100, 74], [87, 69, 51]),
checker_thumbnail(ctx, "gallery-orm", [198, 238, 18], [103, 164, 8]),
checker_thumbnail(ctx, "gallery-normal", [116, 92, 232], [73, 145, 242]),
]);
handles
}
fn fixture_thumbnail_ids(
handles: &[egui::TextureHandle],
) -> (
MaterialThumbnailPresentation,
[MaterialThumbnailPresentation; 3],
) {
(
MaterialThumbnailPresentation::Ready(handles[0].id()),
[
MaterialThumbnailPresentation::Ready(handles[1].id()),
MaterialThumbnailPresentation::Ready(handles[2].id()),
MaterialThumbnailPresentation::Ready(handles[3].id()),
],
)
}
fn make_material_thumbnail(ctx: &egui::Context) -> egui::TextureHandle {
let size = 64;
let mut image = egui::ColorImage::new([size, size], vec![egui::Color32::BLACK; size * size]);
for y in 0..size {
for x in 0..size {
image[(x, y)] = if (x / 16 + y / 16) % 2 == 0 {
egui::Color32::from_rgb(32, 37, 43)
} else {
egui::Color32::from_rgb(43, 50, 58)
};
}
}
paint_fixture_ellipse(&mut image, [37.0, 42.0], [19.0, 19.0], [17, 22, 27], 0.8);
paint_fixture_ellipse(&mut image, [34.0, 38.0], [20.0, 20.0], [109, 123, 138], 1.0);
paint_fixture_ellipse(&mut image, [27.0, 28.5], [6.0, 4.5], [199, 211, 221], 0.85);
paint_fixture_ellipse(&mut image, [38.0, 42.0], [9.0, 9.0], [63, 74, 86], 1.0);
ctx.load_texture(
"gallery-material-sphere",
image,
egui::TextureOptions::NEAREST,
)
}
fn paint_fixture_ellipse(
image: &mut egui::ColorImage,
center: [f32; 2],
radius: [f32; 2],
color: [u8; 3],
opacity: f32,
) {
for y in 0..image.size[1] {
for x in 0..image.size[0] {
let dx = (x as f32 + 0.5 - center[0]) / radius[0];
let dy = (y as f32 + 0.5 - center[1]) / radius[1];
let distance = (dx * dx + dy * dy).sqrt();
let coverage = ((1.0 - distance) * radius[0].min(radius[1])).clamp(0.0, 1.0);
let alpha = coverage * opacity;
if alpha <= 0.0 {
continue;
}
let previous = image[(x, y)];
let blend = |source: u8, destination: u8| {
(source as f32 * alpha + destination as f32 * (1.0 - alpha)).round() as u8
};
image[(x, y)] = egui::Color32::from_rgb(
blend(color[0], previous.r()),
blend(color[1], previous.g()),
blend(color[2], previous.b()),
);
}
}
}
fn checker_thumbnail(
ctx: &egui::Context,
name: &str,
first: [u8; 3],
second: [u8; 3],
) -> egui::TextureHandle {
let size = 18;
let mut image = egui::ColorImage::new([size, size], vec![egui::Color32::BLACK; size * size]);
for y in 0..size {
for x in 0..size {
let color = if (x / 3 + y / 3) % 2 == 0 {
first
} else {
second
};
image[(x, y)] = egui::Color32::from_rgb(color[0], color[1], color[2]);
}
}
ctx.load_texture(name, image, egui::TextureOptions::NEAREST)
}
+457
View File
@@ -0,0 +1,457 @@
use editor_ui::materials::{
MaterialHealth, MaterialLayerBadge, MaterialLocateTarget, MaterialPickerCandidate,
MaterialSlotPanelViewModel, MaterialTextureCandidate, MaterialThumbnailPresentation,
};
use material_schema::{
standard_lit_input_schema, ColorDesc, EditorAssetRef, MaterialInputSet, MaterialParameter,
MaterialParameterValue, MaterialRenderState, MaterialShaderKind, MaterialTextureBinding,
TextureChannel,
};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FixtureId {
Reference,
Primitive,
StaticMesh,
SkinnedMesh,
Inherited,
Imported,
Dirty,
Processing,
Failed,
ReadOnly,
BuiltIn,
}
impl FixtureId {
pub const ALL: [Self; 11] = [
Self::Reference,
Self::Primitive,
Self::StaticMesh,
Self::SkinnedMesh,
Self::Inherited,
Self::Imported,
Self::Dirty,
Self::Processing,
Self::Failed,
Self::ReadOnly,
Self::BuiltIn,
];
pub const fn label(self) -> &'static str {
match self {
Self::Reference => "Penpot Layout",
Self::Primitive => "Primitive",
Self::StaticMesh => "Static Mesh",
Self::SkinnedMesh => "Skinned Mesh",
Self::Inherited => "Inherited",
Self::Imported => "Imported Source",
Self::Dirty => "Dirty",
Self::Processing => "Processing",
Self::Failed => "Failed",
Self::ReadOnly => "Read only",
Self::BuiltIn => "Built-in DefaultGrid",
}
}
pub const fn is_renderer(self) -> bool {
matches!(self, Self::StaticMesh | Self::SkinnedMesh)
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct FixtureOverrides {
pub material_label: Option<String>,
pub material_path: Option<String>,
pub metallic: Option<f32>,
pub roughness: Option<f32>,
pub occlusion: Option<f32>,
pub normal_strength: Option<f32>,
pub emissive_intensity: Option<f32>,
pub uv_tiling: Option<[f32; 2]>,
}
pub struct FixtureModel {
pub slot: MaterialSlotPanelViewModel,
pub render_state: MaterialRenderState,
pub inputs: MaterialInputSet,
pub renderer_slots: Vec<RendererMaterialFixture>,
pub textures: Vec<MaterialTextureCandidate>,
}
pub struct RendererMaterialFixture {
pub slot: MaterialSlotPanelViewModel,
pub render_state: MaterialRenderState,
pub inputs: MaterialInputSet,
}
impl FixtureModel {
pub fn new(
id: FixtureId,
overrides: &FixtureOverrides,
material_thumbnail: MaterialThumbnailPresentation,
texture_thumbnails: [MaterialThumbnailPresentation; 3],
) -> Self {
let material_ref = EditorAssetRef::new(
"c07a5b05-f27d-46c6-8b8c-9de9cdd1472c",
"material:source",
"M_Wood_Planks",
)
.with_source_path("materials/wood/M_Wood_Planks.mat");
let label = overrides
.material_label
.clone()
.unwrap_or_else(|| fixture_material_label(id).to_owned());
let path = overrides
.material_path
.clone()
.unwrap_or_else(|| fixture_material_path(id).to_owned());
let (health, inherited, can_edit_shader, can_clear) = fixture_state(id);
let slot = MaterialSlotPanelViewModel {
slot_id: fixture_slot_id(id).to_owned(),
label,
path: Some(path),
shader: "Standard Lit".to_owned(),
shader_kind: Some(MaterialShaderKind::StandardLit),
can_edit_shader,
thumbnail: material_thumbnail,
inherited,
health,
assigned: (!matches!(id, FixtureId::Inherited | FixtureId::BuiltIn))
.then_some(material_ref.clone()),
effective: Some(material_ref),
candidates: material_candidates(material_thumbnail),
drop_candidate: None,
invalid_drop_reason: None,
can_locate: !matches!(id, FixtureId::BuiltIn),
can_clear,
can_extract: matches!(id, FixtureId::Imported),
can_create_instance: !matches!(id, FixtureId::Imported | FixtureId::BuiltIn),
parameters_initially_open: true,
expanded_header_when_parameters_closed: false,
};
let textures = texture_candidates(texture_thumbnails);
let inputs = fixture_inputs(id, overrides, &textures);
let renderer_slots = renderer_material_fixtures(&slot, &inputs);
Self {
slot,
render_state: MaterialRenderState::default(),
inputs,
renderer_slots,
textures,
}
}
}
fn renderer_material_fixtures(
primary: &MaterialSlotPanelViewModel,
inputs: &MaterialInputSet,
) -> Vec<RendererMaterialFixture> {
let mut painted = primary.clone();
painted.slot_id = "slot:draw:scene0:node2:mesh2:primitive1".to_owned();
painted.label = "M_Painted_Metal".to_owned();
painted.path = Some("assets/materials/office/M_Painted_Metal.mat".to_owned());
painted.assigned = painted.assigned.as_ref().map(|_| {
EditorAssetRef::new(
"gallery-painted-metal",
"material:source",
"M_Painted_Metal",
)
.with_source_path("assets/materials/office/M_Painted_Metal.mat")
});
painted.effective = painted.assigned.clone();
painted.parameters_initially_open = false;
let mut empty = primary.clone();
empty.slot_id = "slot:draw:scene0:node2:mesh2:primitive2".to_owned();
empty.label = "No material assigned".to_owned();
empty.path = None;
empty.shader.clear();
empty.shader_kind = None;
empty.can_edit_shader = false;
empty.thumbnail = MaterialThumbnailPresentation::Empty;
empty.health = MaterialHealth::Healthy;
empty.assigned = None;
empty.effective = None;
empty.can_locate = false;
empty.can_clear = false;
empty.can_create_instance = false;
empty.parameters_initially_open = false;
[primary.clone(), painted, empty]
.into_iter()
.map(|slot| RendererMaterialFixture {
slot,
render_state: MaterialRenderState::default(),
inputs: inputs.clone(),
})
.collect()
}
fn fixture_state(id: FixtureId) -> (MaterialHealth, Option<MaterialLayerBadge>, bool, bool) {
match id {
FixtureId::Inherited => (
MaterialHealth::Healthy,
Some(MaterialLayerBadge::ModelDefault),
false,
false,
),
FixtureId::Imported => (
MaterialHealth::ReadOnly,
Some(MaterialLayerBadge::ModelSource),
false,
false,
),
FixtureId::Dirty => (MaterialHealth::Dirty, None, true, true),
FixtureId::Processing => (MaterialHealth::Processing, None, true, true),
FixtureId::Failed => (MaterialHealth::Broken, None, false, true),
FixtureId::ReadOnly => (MaterialHealth::ReadOnly, None, false, false),
FixtureId::BuiltIn => (
MaterialHealth::ReadOnly,
Some(MaterialLayerBadge::DefaultGrid),
false,
false,
),
FixtureId::Reference
| FixtureId::Primitive
| FixtureId::StaticMesh
| FixtureId::SkinnedMesh => (MaterialHealth::Healthy, None, true, true),
}
}
fn fixture_slot_id(id: FixtureId) -> &'static str {
match id {
FixtureId::Reference => "slot:gallery:penpot-reference",
FixtureId::Primitive => "slot:primitive:surface",
FixtureId::StaticMesh => "slot:draw:scene0:node2:mesh2:primitive0",
FixtureId::SkinnedMesh => "slot:skin:scene0:node1:mesh0:primitive0",
_ => "slot:gallery:surface",
}
}
fn fixture_material_label(id: FixtureId) -> &'static str {
match id {
FixtureId::Imported => "metal_office_desk",
FixtureId::BuiltIn => "Default Grid — Engine Built-in",
FixtureId::Failed => "Missing explicit material",
_ => "M_Wood_Planks",
}
}
fn fixture_material_path(id: FixtureId) -> &'static str {
match id {
FixtureId::Imported => "assets/Furniture/Office/metal_office_desk_2k.gltf#material:0",
FixtureId::BuiltIn => "builtin://materials/default-grid",
FixtureId::Failed => "assets/materials/missing.material.ron",
_ => "materials/wood/M_Wood_Planks.mat",
}
}
fn material_candidates(thumbnail: MaterialThumbnailPresentation) -> Vec<MaterialPickerCandidate> {
["M_Wood_Planks", "M_Painted_Metal", "M_Concrete"]
.into_iter()
.enumerate()
.map(|(index, label)| MaterialPickerCandidate {
reference: EditorAssetRef::new(
format!("gallery-material-{index}"),
"material:source",
label,
)
.with_source_path(format!("assets/materials/{label}.material.ron")),
label: label.to_owned(),
detail: format!("assets/materials/{label}.material.ron"),
thumbnail,
})
.collect()
}
fn texture_candidates(
thumbnails: [MaterialThumbnailPresentation; 3],
) -> Vec<MaterialTextureCandidate> {
[
("T_Wood_ORM", "materials/textures/T_Wood_ORM.png"),
("T_Wood_ORM", "materials/textures/T_Wood_ORM.png"),
("T_Wood_ORM", "materials/textures/T_Wood_ORM.png"),
]
.into_iter()
.enumerate()
.map(|(index, (label, path))| MaterialTextureCandidate {
label: label.to_owned(),
detail: path.to_owned(),
reference: EditorAssetRef::new(format!("gallery-texture-{index}"), "texture:source", label)
.with_source_path(path),
locate: MaterialLocateTarget::File(path.to_owned()),
thumbnail: thumbnails[index],
})
.collect()
}
fn fixture_inputs(
id: FixtureId,
overrides: &FixtureOverrides,
textures: &[MaterialTextureCandidate],
) -> MaterialInputSet {
let schema = standard_lit_input_schema();
let mut set = MaterialInputSet::default();
for input in &schema.inputs {
if let Some(value) = input.default_value.clone() {
set.values.push(MaterialParameter {
name: input.name.clone(),
value,
});
}
if let Some(texture) = input.texture.as_ref() {
set.textures.push(MaterialTextureBinding {
name: input.name.clone(),
texture: None,
channel: texture.default_channel,
});
}
}
set_value(
&mut set,
"base_color",
MaterialParameterValue::Color(ColorDesc::srgb(231.0 / 255.0, 212.0 / 255.0, 180.0 / 255.0)),
);
set_value(
&mut set,
"emissive_color",
MaterialParameterValue::Color(ColorDesc::srgb(231.0 / 255.0, 212.0 / 255.0, 180.0 / 255.0)),
);
set_float(&mut set, "metallic", overrides.metallic.unwrap_or(0.72));
set_float(&mut set, "roughness", overrides.roughness.unwrap_or(0.72));
set_float(&mut set, "occlusion", overrides.occlusion.unwrap_or(0.72));
set_float(
&mut set,
"normal",
overrides.normal_strength.unwrap_or(0.72),
);
set_float(
&mut set,
"emissive_intensity",
overrides.emissive_intensity.unwrap_or(0.0),
);
if let Some([x, y]) = overrides.uv_tiling {
if let Some(parameter) = set
.values
.iter_mut()
.find(|value| value.name == "uv_tiling")
{
if let MaterialParameterValue::Vec2(value) = &mut parameter.value {
value.x = x;
value.y = y;
}
}
}
bind(&mut set, "base_color", &textures[0], TextureChannel::Rgba);
for (name, channel) in [
("occlusion", TextureChannel::R),
("roughness", TextureChannel::G),
("metallic", TextureChannel::B),
] {
bind(&mut set, name, &textures[1], channel);
}
bind(&mut set, "normal", &textures[2], TextureChannel::Rgb);
if id == FixtureId::Reference {
// Penpot's sample binds the same mock texture to Emissive. Its all-G scalar labels conflict
// with the simultaneously selected ORM mode; keep Blacksite's valid R/G/B contract and
// document those three sample glyphs as an intentional handoff delta.
bind(
&mut set,
"emissive_color",
&textures[1],
TextureChannel::Rgb,
);
}
set
}
fn set_float(inputs: &mut MaterialInputSet, name: &str, value: f32) {
set_value(inputs, name, MaterialParameterValue::Float(value));
}
fn set_value(inputs: &mut MaterialInputSet, name: &str, value: MaterialParameterValue) {
if let Some(parameter) = inputs.values.iter_mut().find(|item| item.name == name) {
parameter.value = value;
}
}
fn bind(
inputs: &mut MaterialInputSet,
name: &str,
candidate: &MaterialTextureCandidate,
channel: TextureChannel,
) {
if let Some(binding) = inputs.textures.iter_mut().find(|item| item.name == name) {
binding.texture = Some(candidate.reference.clone());
binding.channel = channel;
}
}
#[cfg(test)]
mod tests {
use super::*;
fn test_textures() -> Vec<MaterialTextureCandidate> {
texture_candidates([MaterialThumbnailPresentation::Pending; 3])
}
#[test]
fn reference_fixture_keeps_valid_orm_channels_and_adds_penpot_emissive_sample() {
let textures = test_textures();
let reference = fixture_inputs(
FixtureId::Reference,
&FixtureOverrides::default(),
&textures,
);
assert_eq!(
reference
.texture("occlusion")
.map(|binding| binding.channel),
Some(TextureChannel::R)
);
assert_eq!(
reference
.texture("roughness")
.map(|binding| binding.channel),
Some(TextureChannel::G)
);
assert_eq!(
reference.texture("metallic").map(|binding| binding.channel),
Some(TextureChannel::B)
);
assert!(reference
.texture("emissive_color")
.and_then(|binding| binding.texture.as_ref())
.is_some());
let primitive = fixture_inputs(
FixtureId::Primitive,
&FixtureOverrides::default(),
&textures,
);
assert_eq!(
primitive
.texture("occlusion")
.map(|binding| binding.channel),
Some(TextureChannel::R)
);
assert_eq!(
primitive
.texture("roughness")
.map(|binding| binding.channel),
Some(TextureChannel::G)
);
assert_eq!(
primitive.texture("metallic").map(|binding| binding.channel),
Some(TextureChannel::B)
);
assert!(primitive
.texture("emissive_color")
.and_then(|binding| binding.texture.as_ref())
.is_none());
}
}
+19
View File
@@ -0,0 +1,19 @@
mod app;
mod fixtures;
mod reference;
mod reload;
fn main() -> eframe::Result {
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_title("Blacksite UI Gallery")
.with_inner_size([1420.0, 940.0])
.with_min_inner_size([900.0, 620.0]),
..Default::default()
};
eframe::run_native(
"Blacksite UI Gallery",
options,
Box::new(|creation| Ok(Box::new(app::UiGalleryApp::new(creation)))),
)
}
+318
View File
@@ -0,0 +1,318 @@
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GalleryPreset {
Materials620,
Materials420,
Renderer760,
Renderer480,
}
impl GalleryPreset {
pub const ALL: [Self; 4] = [
Self::Materials620,
Self::Materials420,
Self::Renderer760,
Self::Renderer480,
];
pub const fn label(self) -> &'static str {
match self {
Self::Materials620 => "Materials · 620",
Self::Materials420 => "Materials · 420",
Self::Renderer760 => "Renderer · 760",
Self::Renderer480 => "Renderer · 480",
}
}
pub const fn width(self) -> f32 {
match self {
Self::Materials620 => 620.0,
Self::Materials420 => 420.0,
Self::Renderer760 => 760.0,
Self::Renderer480 => 480.0,
}
}
pub const fn target_height(self) -> f32 {
match self {
Self::Materials620 => 539.0,
Self::Materials420 => 735.0,
Self::Renderer760 => 1233.0,
Self::Renderer480 => 828.0,
}
}
pub const fn file_name(self) -> &'static str {
match self {
Self::Materials620 => "materials-wide-620.png",
Self::Materials420 => "materials-narrow-420.png",
Self::Renderer760 => "static-mesh-renderer-wide-760.png",
Self::Renderer480 => "static-mesh-renderer-narrow-480.png",
}
}
pub const fn is_renderer(self) -> bool {
matches!(self, Self::Renderer760 | Self::Renderer480)
}
/// Production-content canvas inside the exported Penpot reference.
///
/// Material boards include the Inspector border and its 12 px horizontal / 10 px top inset;
/// renderer boards are already complete component canvases.
pub fn content_rect(self, canvas: egui::Rect) -> egui::Rect {
if self.is_renderer() {
egui::Rect::from_min_max(
canvas.min + egui::vec2(0.0, 12.0),
egui::pos2(canvas.right(), canvas.bottom()),
)
} else {
egui::Rect::from_min_max(
canvas.min + egui::vec2(12.0, 10.0),
egui::pos2(canvas.right() - 12.0, canvas.bottom()),
)
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ComparisonMode {
Live,
SideBySide,
Overlay,
Difference,
}
impl ComparisonMode {
pub const ALL: [Self; 4] = [
Self::Live,
Self::SideBySide,
Self::Overlay,
Self::Difference,
];
pub const fn label(self) -> &'static str {
match self {
Self::Live => "Live",
Self::SideBySide => "Side by side",
Self::Overlay => "Overlay",
Self::Difference => "Difference",
}
}
}
pub struct ReferenceImage {
pub source_size: [usize; 2],
pub texture: egui::TextureHandle,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ReferenceCrop {
origin: [usize; 2],
size: [usize; 2],
}
fn reference_crop(source_size: [usize; 2], preset: GalleryPreset) -> ReferenceCrop {
let target_width = preset.width().round().max(1.0) as usize;
let target_height = preset.target_height().round().max(1.0) as usize;
// Penpot's material exports include the frame's one-pixel outer stroke in their viewBox,
// producing 622/422 px PNGs for 620/420 px boards. That stroke is export overscan, not part of
// the authored canvas. Cropping it preserves direct 1:1 pixels; scaling it into the canvas
// blurs text and introduces a false global geometry delta.
let overscan = source_size[0].saturating_sub(target_width);
let inset = usize::from(overscan == 2);
ReferenceCrop {
origin: [inset, inset],
size: [
target_width.min(source_size[0].saturating_sub(inset)),
target_height.min(source_size[1].saturating_sub(inset)),
],
}
}
impl ReferenceImage {
pub fn load(ctx: &egui::Context, root: &Path, preset: GalleryPreset) -> Result<Self, String> {
let path = reference_path(root, preset);
let bytes = std::fs::read(&path).map_err(|error| format!("{}: {error}", path.display()))?;
let decoded = image::load_from_memory(&bytes)
.map_err(|error| format!("{}: {error}", path.display()))?
.to_rgba8();
let source_size = [decoded.width() as usize, decoded.height() as usize];
let pixels = egui::ColorImage::from_rgba_unmultiplied(source_size, decoded.as_raw());
let texture = ctx.load_texture(
format!("penpot-reference-{}", preset.label()),
pixels.clone(),
egui::TextureOptions::NEAREST,
);
Ok(Self {
source_size,
texture,
})
}
pub fn paint(&self, ui: &mut egui::Ui, preset: GalleryPreset, opacity: f32) -> egui::Response {
let size = egui::vec2(preset.width(), preset.target_height());
let crop = reference_crop(self.source_size, preset);
let uv_min = egui::pos2(
crop.origin[0] as f32 / self.source_size[0] as f32,
crop.origin[1] as f32 / self.source_size[1] as f32,
);
let uv_max = egui::pos2(
(crop.origin[0] + crop.size[0]) as f32 / self.source_size[0] as f32,
(crop.origin[1] + crop.size[1]) as f32 / self.source_size[1] as f32,
);
ui.add(
egui::Image::new((self.texture.id(), size))
.uv(egui::Rect::from_min_max(uv_min, uv_max))
.tint(egui::Color32::from_white_alpha((opacity * 255.0) as u8)),
)
}
}
pub fn difference_image(
screenshot: &egui::ColorImage,
live_rect: egui::Rect,
reference_rect: egui::Rect,
pixels_per_point: f32,
preset: GalleryPreset,
) -> (egui::ColorImage, DifferenceStats) {
let width = preset.width().round().max(1.0) as usize;
let height = preset.target_height().round().max(1.0) as usize;
let mut output =
egui::ColorImage::new([width, height], vec![egui::Color32::BLACK; width * height]);
let mut total = 0_u64;
let mut max_delta = 0_u8;
let mut changed = 0_u64;
for y in 0..height {
for x in 0..width {
let live =
sample_screenshot(screenshot, live_rect, pixels_per_point, x, y, width, height);
let reference_color = sample_screenshot(
screenshot,
reference_rect,
pixels_per_point,
x,
y,
width,
height,
);
let delta = [
live.r().abs_diff(reference_color.r()),
live.g().abs_diff(reference_color.g()),
live.b().abs_diff(reference_color.b()),
];
let peak = *delta.iter().max().unwrap_or(&0);
max_delta = max_delta.max(peak);
total += delta.into_iter().map(u64::from).sum::<u64>();
changed += u64::from(peak > 8);
let amplified = |value: u8| value.saturating_mul(4);
output[(x, y)] = egui::Color32::from_rgb(
amplified(delta[0]),
amplified(delta[1]),
amplified(delta[2]),
);
}
}
let samples = (width * height * 3).max(1) as f32;
let pixels = (width * height).max(1) as f32;
(
output,
DifferenceStats {
mean_channel_delta: total as f32 / samples,
max_channel_delta: max_delta,
changed_percent: changed as f32 * 100.0 / pixels,
},
)
}
#[derive(Debug, Clone, Copy, Default)]
pub struct DifferenceStats {
pub mean_channel_delta: f32,
pub max_channel_delta: u8,
pub changed_percent: f32,
}
fn reference_path(root: &Path, preset: GalleryPreset) -> PathBuf {
root.join("docs/editor/evaluations/content-workspace-m2/penpot")
.join(preset.file_name())
}
fn sample_screenshot(
image: &egui::ColorImage,
rect: egui::Rect,
pixels_per_point: f32,
x: usize,
y: usize,
width: usize,
height: usize,
) -> egui::Color32 {
let px = ((rect.left() + (x as f32 + 0.5) * rect.width() / width as f32) * pixels_per_point)
.floor() as isize;
let py = ((rect.top() + (y as f32 + 0.5) * rect.height() / height as f32) * pixels_per_point)
.floor() as isize;
if px < 0 || py < 0 || px as usize >= image.size[0] || py as usize >= image.size[1] {
return egui::Color32::BLACK;
}
image[(px as usize, py as usize)]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn material_presets_supply_exported_slot_widths() {
for (preset, expected_width) in [
(GalleryPreset::Materials620, 596.0),
(GalleryPreset::Materials420, 396.0),
] {
let canvas = egui::Rect::from_min_size(
egui::Pos2::ZERO,
egui::vec2(preset.width(), preset.target_height()),
);
let content = preset.content_rect(canvas);
assert_eq!(content.left(), 12.0);
assert_eq!(content.top(), 10.0);
assert_eq!(content.width(), expected_width);
}
}
#[test]
fn renderer_presets_preserve_the_exported_top_inset() {
for preset in [GalleryPreset::Renderer760, GalleryPreset::Renderer480] {
let canvas = egui::Rect::from_min_size(
egui::Pos2::ZERO,
egui::vec2(preset.width(), preset.target_height()),
);
let content = preset.content_rect(canvas);
assert_eq!(content.left(), 0.0);
assert_eq!(content.top(), 12.0);
assert_eq!(content.width(), preset.width());
}
}
#[test]
fn material_export_overscan_is_cropped_instead_of_scaled() {
assert_eq!(
reference_crop([622, 661], GalleryPreset::Materials620),
ReferenceCrop {
origin: [1, 1],
size: [620, 539],
}
);
assert_eq!(
reference_crop([422, 857], GalleryPreset::Materials420),
ReferenceCrop {
origin: [1, 1],
size: [420, 735],
}
);
assert_eq!(
reference_crop([760, 1233], GalleryPreset::Renderer760),
ReferenceCrop {
origin: [0, 0],
size: [760, 1233],
}
);
}
}
+243
View File
@@ -0,0 +1,243 @@
use std::fs;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
use editor_ui::theme::{EditorVisualPalette, BLACKSITE_PALETTE};
use serde::{Deserialize, Serialize};
use crate::fixtures::FixtureOverrides;
const POLL_INTERVAL: Duration = Duration::from_millis(300);
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ThemeOverrides {
pub canvas: Option<String>,
pub panel: Option<String>,
pub panel_dark: Option<String>,
pub widget: Option<String>,
pub elevated: Option<String>,
pub accent: Option<String>,
pub selection: Option<String>,
pub text: Option<String>,
pub text_dim: Option<String>,
pub text_muted: Option<String>,
pub border: Option<String>,
pub border_strong: Option<String>,
pub success: Option<String>,
pub warning: Option<String>,
pub error: Option<String>,
}
impl ThemeOverrides {
pub fn palette(&self) -> Result<EditorVisualPalette, String> {
let mut palette = BLACKSITE_PALETTE;
macro_rules! apply {
($field:ident) => {
if let Some(value) = self.$field.as_deref() {
palette.$field = parse_color(value)?;
}
};
}
apply!(canvas);
apply!(panel);
apply!(panel_dark);
apply!(widget);
apply!(elevated);
apply!(accent);
apply!(selection);
apply!(text);
apply!(text_dim);
apply!(text_muted);
apply!(border);
apply!(border_strong);
apply!(success);
apply!(warning);
apply!(error);
Ok(palette)
}
}
pub struct RuntimeDocuments {
theme: ReloadableDocument<ThemeOverrides>,
fixture: ReloadableDocument<FixtureOverrides>,
pub theme_value: ThemeOverrides,
pub fixture_value: FixtureOverrides,
pub error: Option<String>,
}
impl RuntimeDocuments {
pub fn new(root: &Path) -> Self {
Self::from_directory(root.join("crates/ui_gallery/fixtures"))
}
fn from_directory(directory: PathBuf) -> Self {
Self {
theme: ReloadableDocument::new(directory.join("theme.json")),
fixture: ReloadableDocument::new(directory.join("material.json")),
theme_value: ThemeOverrides::default(),
fixture_value: FixtureOverrides::default(),
error: None,
}
}
pub fn poll(&mut self, now: f64) -> bool {
let mut changed = false;
match self.theme.poll(now) {
Ok(Some(value)) => {
self.theme_value = value;
self.error = None;
changed = true;
}
Err(error) => self.error = Some(error),
Ok(None) => {}
}
match self.fixture.poll(now) {
Ok(Some(value)) => {
self.fixture_value = value;
self.error = None;
changed = true;
}
Err(error) => self.error = Some(error),
Ok(None) => {}
}
changed
}
}
struct ReloadableDocument<T> {
path: PathBuf,
modified: Option<SystemTime>,
next_poll: f64,
marker: std::marker::PhantomData<T>,
}
impl<T> ReloadableDocument<T>
where
T: for<'de> Deserialize<'de>,
{
fn new(path: PathBuf) -> Self {
Self {
path,
modified: None,
next_poll: 0.0,
marker: std::marker::PhantomData,
}
}
fn poll(&mut self, now: f64) -> Result<Option<T>, String> {
if now < self.next_poll {
return Ok(None);
}
self.next_poll = now + POLL_INTERVAL.as_secs_f64();
let metadata = fs::metadata(&self.path)
.map_err(|error| format!("{}: {error}", self.path.display()))?;
let modified = metadata.modified().ok();
if self.modified == modified {
return Ok(None);
}
let bytes =
fs::read(&self.path).map_err(|error| format!("{}: {error}", self.path.display()))?;
let value = serde_json::from_slice(&bytes)
.map_err(|error| format!("{}: {error}", self.path.display()))?;
self.modified = modified;
Ok(Some(value))
}
}
fn parse_color(value: &str) -> Result<egui::Color32, String> {
let value = value.trim().trim_start_matches('#');
if value.len() != 6 && value.len() != 8 {
return Err(format!("expected #RRGGBB or #RRGGBBAA, got {value}"));
}
let byte = |offset| {
u8::from_str_radix(&value[offset..offset + 2], 16)
.map_err(|error| format!("invalid color {value}: {error}"))
};
Ok(egui::Color32::from_rgba_unmultiplied(
byte(0)?,
byte(2)?,
byte(4)?,
if value.len() == 8 { byte(6)? } else { 255 },
))
}
#[cfg(test)]
mod tests {
use super::*;
fn temporary_directory() -> PathBuf {
let nonce = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.expect("system clock after epoch")
.as_nanos();
let directory = std::env::temp_dir().join(format!(
"blacksite-ui-gallery-reload-{}-{nonce}",
std::process::id()
));
fs::create_dir_all(&directory).expect("create temporary fixture directory");
directory
}
#[test]
fn runtime_documents_reload_fixture_without_reconstruction() {
let directory = temporary_directory();
fs::write(directory.join("theme.json"), "{}\n").expect("write theme fixture");
fs::write(directory.join("material.json"), "{}\n").expect("write material fixture");
let mut documents = RuntimeDocuments::from_directory(directory.clone());
assert!(documents.poll(0.0));
assert_eq!(documents.fixture_value.material_label, None);
fs::write(
directory.join("material.json"),
r#"{"material_label":"LIVE_RELOAD_PROOF"}"#,
)
.expect("update material fixture");
assert!(documents.poll(1.0));
assert_eq!(
documents.fixture_value.material_label.as_deref(),
Some("LIVE_RELOAD_PROOF")
);
assert_eq!(documents.error, None);
fs::remove_dir_all(directory).expect("remove temporary fixture directory");
}
#[test]
fn invalid_reload_keeps_the_last_valid_document_and_reports_the_error() {
let directory = temporary_directory();
fs::write(directory.join("theme.json"), "{}\n").expect("write theme fixture");
fs::write(
directory.join("material.json"),
r#"{"material_label":"baseline"}"#,
)
.expect("write material fixture");
let mut documents = RuntimeDocuments::from_directory(directory.clone());
assert!(documents.poll(0.0));
fs::write(directory.join("material.json"), "{ invalid json\n")
.expect("write invalid material fixture");
assert!(!documents.poll(1.0));
assert_eq!(
documents.fixture_value.material_label.as_deref(),
Some("baseline")
);
assert!(documents
.error
.as_deref()
.is_some_and(|error| error.contains("material.json")));
fs::remove_dir_all(directory).expect("remove temporary fixture directory");
}
#[test]
fn theme_colors_accept_rgb_and_rgba_hex() {
assert_eq!(
parse_color("#41C6CF").expect("valid RGB"),
egui::Color32::from_rgb(65, 198, 207)
);
assert_eq!(
parse_color("E25E5E80").expect("valid RGBA"),
egui::Color32::from_rgba_unmultiplied(226, 94, 94, 128)
);
assert!(parse_color("#not-a-color").is_err());
}
}