feat: add production UI gallery and inspector system
CI / Format, lint, test, build (push) Waiting to run
CI / Format, lint, test, build (push) Waiting to run
This commit is contained in:
1 parent
cf6eaba534
commit
53dc1e44d8
95 files changed
+11003
-1652
No files matched your search
@@ -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, §ion, |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)
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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)))),
|
||||
)
|
||||
}
|
||||
@@ -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],
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user