Files
solidcraft/crates/ui-egui/src/dialogs_appearance.rs
T

1199 lines
57 KiB
Rust

//! The Appearance dialog: library swatches (named looks), the looks in this design, a colour
//! picker with opacity, and the objects to apply to (bodies, or faces). A swatch dragged onto a
//! body or face in the viewport, or onto a body's row in the Browser, applies at once; Apply
//! (and OK) gives the picked objects the current look.
use crate::ui_kit::BackingTooltipExt as _;
use egui::Color32;
use serde_json::{Value, json};
use solidcraft_engine::Sel;
use solidcraft_engine::doc::pbr_appearance::PbrParameters;
use crate::SolveApp;
use crate::dialogs::{Kind, combo};
use crate::selection::{BODIES, FACES, SelInput};
use crate::ui_kit;
use crate::viewport::Hit;
/// A named look: colour and opacity.
#[derive(Clone, Debug, PartialEq)]
pub struct Look {
pub preset: Option<PresetMetadata>,
pub name: String,
pub category: String,
pub color: [u8; 3],
pub opacity: f64,
pub pbr: Option<PbrParameters>,
}
/// Transient library admission metadata, never saved as a second catalog.
#[derive(Clone, Debug, PartialEq)]
pub struct PresetMetadata {
pub id: String,
pub available: bool,
pub requirements: Vec<String>,
pub preview_note: String,
}
fn library_look(x: &Value) -> Option<Look> {
let preset = if let Some(id) = x.get("id") {
let id = id.as_str()?;
let note = x.get("preview_note")?.as_str()?;
let requirements = x.get("requirements")?.as_array()?;
if id.is_empty() || id.len() > 128 || note.len() > 1024 || requirements.len() > 8 {
return None;
}
let requirements = requirements
.iter()
.map(|value| {
let value = value.as_str()?;
(value.len() <= 128).then(|| value.to_string())
})
.collect::<Option<Vec<_>>>()?;
Some(PresetMetadata { id: id.to_string(), available: x.get("available")?.as_bool()?, requirements, preview_note: note.to_string() })
} else {
None
};
Some(Look {
preset,
name: x.get("name")?.as_str()?.to_string(),
category: match x.get("category").and_then(Value::as_str).unwrap_or("Library") {
"wood" => "Wood",
"metal" => "Metal",
"plastic" => "Plastic",
"glass" => "Glass",
"solar" => "Solar",
"regolith" => "Regolith",
other => other,
}
.to_string(),
color: parse_color(x.get("color")?)?,
opacity: x.get("opacity").and_then(Value::as_f64).unwrap_or(1.0),
pbr: x.get("pbr").and_then(|p| serde_json::from_value(p.clone()).ok()),
})
}
fn choose_look(k: &mut Ap, look: &Look) -> Result<(), String> {
if let Some(preset) = &look.preset
&& !preset_available(look)
{
return Err(format!("{}: {} ({})", look.name, preset.preview_note, preset.requirements.join(", ")));
}
k.color = look.color;
k.opacity = look.opacity;
k.pbr = look.pbr;
k.look = Some(look.name.clone());
k.preset_id = look.preset.as_ref().map(|p| p.id.clone());
k.note = look.preset.as_ref().map(|p| p.preview_note.clone()).filter(|note| !note.is_empty());
k.remove_override = false;
Ok(())
}
fn preset_available(look: &Look) -> bool {
look.preset.as_ref().is_none_or(|preset| {
preset.available
&& preset.requirements.len() == 1
&& preset.requirements.first().is_some_and(|requirement| requirement == "opaque_pbr")
&& look.pbr.is_some()
&& look.opacity == 1.0
})
}
/// Editing leaves a literal owned label, with no live recipe selection.
fn detach_preset(k: &mut Ap) {
k.preset_id = None;
}
fn matches_library_filter(look: &Look, category: Option<&str>, query: &str, only_available: bool) -> bool {
category.is_none_or(|category| look.category == category)
&& (look.name.to_lowercase().contains(query) || look.preset.as_ref().is_some_and(|p| p.id.to_lowercase().contains(query)))
&& (!only_available || preset_available(look))
}
/// Built-in looks, used until the engine offers a library (`appearance.library`).
pub(crate) fn builtin() -> Vec<Look> {
let l =
|cat: &str, name: &str, c: [u8; 3], o: f64| Look { preset: None, name: name.into(), category: cat.into(), color: c, opacity: o, pbr: None };
vec![
l("Metal", "Aluminum - Satin", [196, 199, 204], 1.0),
l("Metal", "Steel - Brushed", [160, 164, 170], 1.0),
l("Metal", "Stainless Steel", [182, 186, 190], 1.0),
l("Metal", "Brass", [196, 160, 80], 1.0),
l("Metal", "Copper", [184, 115, 72], 1.0),
l("Metal", "Chrome", [222, 226, 232], 1.0),
l("Metal", "Anodized Black", [42, 44, 48], 1.0),
l("Plastic", "ABS - White", [236, 236, 232], 1.0),
l("Plastic", "ABS - Black", [34, 34, 36], 1.0),
l("Plastic", "ABS - Grey", [128, 130, 134], 1.0),
l("Plastic", "Polycarbonate - Clear", [210, 226, 240], 0.35),
l("Plastic", "Nylon - Natural", [228, 222, 204], 1.0),
l("Plastic", "Rubber - Black", [26, 26, 26], 1.0),
l("Paint", "Paint - Red", [196, 40, 36], 1.0),
l("Paint", "Paint - Orange", [232, 120, 30], 1.0),
l("Paint", "Paint - Yellow", [236, 196, 40], 1.0),
l("Paint", "Paint - Green", [52, 140, 72], 1.0),
l("Paint", "Paint - Blue", [36, 92, 180], 1.0),
l("Paint", "Paint - Purple", [112, 64, 156], 1.0),
l("Wood", "Oak", [190, 150, 100], 1.0),
l("Wood", "Walnut", [110, 76, 50], 1.0),
l("Glass", "Glass - Clear", [220, 236, 244], 0.25),
l("Glass", "Glass - Smoked", [90, 96, 104], 0.5),
]
}
/// The library: the engine's when it has one, else the built-in looks.
pub fn library(app: &mut SolveApp) -> Vec<Look> {
let from_engine = app.session.execute("appearance.library", &json!({})).ok().and_then(|v| {
let list = v.get("appearances").or(v.get("library")).unwrap_or(&v).as_array()?.clone();
let looks: Vec<Look> = list.iter().filter_map(library_look).collect();
(!looks.is_empty()).then_some(looks)
});
from_engine.unwrap_or_else(builtin)
}
/// "#rrggbb" or [r, g, b].
pub fn parse_color(v: &Value) -> Option<[u8; 3]> {
if let Some(s) = v.as_str() {
let h = s.trim().trim_start_matches('#');
if h.len() != 6 {
return None;
}
let byte = |i: usize| h.get(i..i + 2).and_then(|x| u8::from_str_radix(x, 16).ok());
return Some([byte(0)?, byte(2)?, byte(4)?]);
}
let a = v.as_array()?;
let c = |i: usize| a.get(i).and_then(Value::as_u64).filter(|x| *x <= 255).map(|x| x as u8);
Some([c(0)?, c(1)?, c(2)?])
}
pub fn hex(c: [u8; 3]) -> String {
format!("#{:02x}{:02x}{:02x}", c[0], c[1], c[2])
}
#[derive(Clone, Debug)]
pub struct Ap {
pub preset_id: Option<String>,
pub only_available: bool,
pub local: crate::dialogs_library::LocalLibrary,
/// Apply to faces instead of bodies.
pub faces: bool,
pub color: [u8; 3],
pub opacity: f64,
pub pbr: Option<PbrParameters>,
/// The look picked last (its name), if the colour came from one.
pub look: Option<String>,
/// Library category shown (0: all).
pub category: usize,
/// Library names can be searched without changing the selected look.
pub search: String,
/// A Browser component target, inherited by its bodies unless they have overrides.
pub component: Option<String>,
pub remove_override: bool,
/// The last successful immediate Apply/drop, so OK does not duplicate its undo step.
pub applied: Option<Value>,
/// What the last drop or Apply did.
pub note: Option<String>,
}
/// The dialog for the Appearance command.
pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {
(id == "appearance.assign").then(|| {
let faces = app.session.selection.iter().any(|s| matches!(s, Sel::Face { .. }))
&& !app.session.selection.iter().any(|s| matches!(s, Sel::Body { .. }));
let state = crate::open_meshing::session_world(&app.session);
let body_look = |body: &solidcraft_engine::doc::ModelBody| {
app.session.doc.model_body_look(body).or_else(|| {
(body.body.paint().is_some() || body.imported.is_some() || body.body.color().is_some()).then(|| {
let color =
app.session.doc.body_color(body).map(|rgb| rgb.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8)).unwrap_or([196, 199, 204]);
solidcraft_engine::doc::appearance::Look::custom(color, app.session.doc.model_body_opacity(body))
})
})
};
let existing = app.session.selection.iter().find_map(|sel| match sel {
Sel::Body { name } => state.body(name).and_then(body_look),
Sel::Face { body, index, .. } => state
.body(body)
.and_then(|b| app.session.doc.face_colors(b).into_iter().find(|(i, _)| i == index).map(|(_, look)| look).or_else(|| body_look(b))),
_ => None,
});
(
Kind::Appearance(Ap {
preset_id: None,
only_available: false,
local: Default::default(),
faces,
color: existing.as_ref().map_or([196, 199, 204], |l| l.color),
opacity: existing.as_ref().map_or(1.0, |l| l.opacity),
pbr: existing.as_ref().and_then(|l| l.pbr),
look: existing.map(|l| l.name),
category: 0,
search: String::new(),
component: None,
remove_override: false,
applied: None,
note: None,
}),
vec![SelInput::new("Objects", if faces { FACES } else { BODIES }, true)],
)
})
}
/// The command giving `targets` (bodies or faces) a look.
pub(crate) fn apply_params(targets: &[Sel], color: [u8; 3], opacity: f64, look: Option<&str>, pbr: Option<PbrParameters>) -> Option<Value> {
let bodies: Vec<String> = targets.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None }).collect();
let faces: Vec<Value> = targets
.iter()
.filter_map(|x| if let Sel::Face { body, point, .. } = x { Some(json!({"body": body, "point": [point.x, point.y, point.z]})) } else { None })
.collect();
if bodies.is_empty() && faces.is_empty() {
return None;
}
let mut p = json!({"color": hex(color), "pbr": pbr});
if !bodies.is_empty() {
p["bodies"] = json!(bodies);
}
if !faces.is_empty() {
p["faces"] = json!(faces);
// An engine without face looks: their bodies.
if bodies.is_empty() && solidcraft_engine::find_command("appearance.list").is_none() {
let mut owners: Vec<String> =
targets.iter().filter_map(|x| if let Sel::Face { body, .. } = x { Some(body.clone()) } else { None }).collect();
owners.dedup();
p["bodies"] = json!(owners);
}
}
p["opacity"] = json!(opacity);
if let Some(n) = look {
p["name"] = json!(n);
}
Some(p)
}
/// The commands OK runs: the current look on the picked objects (nothing when none are picked).
pub fn commands(k: &Ap, inputs: &[SelInput]) -> Vec<(String, Value)> {
// Explicit library material imports only copy definitions. Closing their mode
// must not also assign an unrelated appearance draft to the selected bodies.
// Remove override already ran immediately, so it also has no second undo step.
if k.remove_override || k.local.materials {
return Vec::new();
}
let items = inputs.first().map(|i| i.items.as_slice()).unwrap_or(&[]);
let p = selected_params(k, items);
if p.as_ref().is_some_and(|p| k.applied.as_ref() == Some(p)) {
return Vec::new();
}
p.map(|p| vec![("appearance.assign".to_string(), p)]).unwrap_or_default()
}
pub(super) fn selected_params(k: &Ap, items: &[Sel]) -> Option<Value> {
let mut p = if let Some(component) = &k.component {
Some(json!({"components": [component], "color": hex(k.color), "opacity": k.opacity, "name": k.look}))
} else {
apply_params(items, k.color, k.opacity, k.look.as_deref(), k.pbr)
}?;
// All entry points apply the complete owned response, including explicit clearing.
p["pbr"] = json!(k.pbr);
if let Some(id) = &k.preset_id {
if let Some(object) = p.as_object_mut() {
object.remove("name");
}
p["appearance"] = json!(id);
}
Some(p)
}
/// Removing an override restores the inherited component or material appearance.
fn clear_params(k: &Ap, items: &[Sel]) -> Option<Value> {
Some(without_look(selected_params(k, items)?))
}
/// Shared clear form for dialogs and the selection Inspector.
pub(crate) fn without_look(mut p: Value) -> Value {
if let Some(obj) = p.as_object_mut() {
obj.remove("appearance");
obj.remove("name");
obj.remove("color");
obj.remove("opacity");
obj.remove("pbr");
}
p
}
/// What a swatch dropped now would land on: the face or body under the cursor in the viewport,
/// or the bodies of the Browser row under it.
fn drop_target(app: &SolveApp, faces: bool) -> Vec<Sel> {
match &app.viewport.hover {
Some(Hit::Face { body, index, point }) if faces => vec![Sel::Face { body: body.clone(), index: *index, point: *point }],
Some(Hit::Face { body, .. } | Hit::Edge { body, .. } | Hit::Vertex { body, .. }) => vec![Sel::Body { name: body.clone() }],
_ => app.viewport.hover_bodies.iter().map(|n| Sel::Body { name: n.clone() }).collect(),
}
}
/// The looks in this design (colour and how many items wear it): the engine's list when it has
/// one, else the body colours.
fn in_design(app: &mut SolveApp) -> Vec<(Look, usize)> {
if let Ok(v) = app.session.execute("appearance.list", &json!({}))
&& let Some(list) = v.get("in_design").and_then(Value::as_array)
{
let count = |x: &Value, k: &str| x.get(k).and_then(Value::as_array).map_or(0, Vec::len);
return list
.iter()
.filter_map(|x| {
Some((
Look {
preset: None,
name: x.get("name").and_then(Value::as_str).unwrap_or("Custom").to_string(),
category: "In This Design".into(),
color: parse_color(x.get("color")?)?,
opacity: x.get("opacity").and_then(Value::as_f64).unwrap_or(1.0),
pbr: x.get("pbr").and_then(|p| serde_json::from_value(p.clone()).ok()),
},
count(x, "bodies") + count(x, "faces") + count(x, "components"),
))
})
.collect();
}
let mut out: Vec<(Look, usize)> = Vec::new();
for l in app.session.doc.appearances.bodies.values() {
let look = Look { preset: None, name: l.name.clone(), category: "In This Design".into(), color: l.color, opacity: l.opacity, pbr: l.pbr };
match out.iter_mut().find(|(x, _)| *x == look) {
Some(e) => e.1 += 1,
None => out.push((look, 1)),
}
}
out
}
/// Replacement pickers share the dialog's design looks and admitted library recipes.
pub(crate) fn replacement_library(app: &mut SolveApp) -> Vec<Look> {
let mut looks: Vec<_> = in_design(app).into_iter().map(|(look, _)| look).collect();
for look in library(app).into_iter().filter(preset_available) {
if !looks.iter().any(|saved| saved.name == look.name && saved.color == look.color && saved.opacity == look.opacity && saved.pbr == look.pbr) {
looks.push(look);
}
}
looks
}
fn c32(c: [u8; 3], opacity: f64) -> Color32 {
Color32::from_rgba_unmultiplied(c[0], c[1], c[2], (opacity.clamp(0.0, 1.0) * 255.0) as u8)
}
/// The dialog's rows (after the Objects input); applies drops and Apply at once.
pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Ap, inputs: &mut [SelInput]) -> bool {
// Apply To: bodies or faces (the input follows).
if let Some(component) = &k.component {
ui_kit::row(ui, "Apply To", |ui| ui_kit::text(ui, &format!("Component: {component}"), ui_kit::Text::Cell));
if ui_kit::row(ui, "", |ui| ui_kit::button(ui, crate::i18n::tr_label("Select bodies or faces instead"), ui_kit::Button::Normal)).clicked() {
k.component = None;
}
} else {
let mut mode = usize::from(k.faces);
ui_kit::row(ui, "Apply To", |ui| combo(ui, "ap_mode", &["Bodies", "Faces"], &mut mode));
if (mode == 1) != k.faces {
k.faces = mode == 1;
if let Some(input) = inputs.first_mut() {
*input = SelInput::new("Objects", if k.faces { FACES } else { BODIES }, true);
}
}
}
ui_kit::row(ui, "Colour", |ui| {
let response =
if k.pbr.is_none() { ui_kit::color_field_with_opacity(ui, &mut k.color, &mut k.opacity) } else { ui_kit::color_field(ui, &mut k.color) };
if response.changed() {
detach_preset(k);
k.look = None;
k.remove_override = false;
}
ui_kit::text(ui, &k.look.clone().unwrap_or_else(|| hex(k.color)), ui_kit::Text::MonoCell);
});
ui_kit::row(ui, "Opacity", |ui| {
if ui.add_enabled_ui(k.pbr.is_none(), |ui| ui_kit::slider(ui, &mut k.opacity, 0.0..=1.0, Default::default())).inner.changed() {
detach_preset(k);
k.remove_override = false;
}
});
let mut enabled = k.pbr.is_some();
let toggle = ui_kit::row(ui, app.tr("appearance.surface_response"), |ui| ui_kit::checkbox(ui, app.tr("appearance.pbr_opaque"), &mut enabled))
.backing_on_hover_text(app.tr("appearance.pbr_help"));
crate::scenario::publish_handle("appearance:pbr", toggle.rect.center());
if toggle.changed() {
detach_preset(k);
k.pbr = enabled.then(PbrParameters::default);
if enabled {
k.opacity = 1.0;
}
k.remove_override = false;
}
if let Some(parameters) = k.pbr {
let mut metallic = parameters.metallic();
let mut roughness = parameters.roughness();
let mut ior = parameters.dielectric_ior();
for (label, handle, value, range) in [
("appearance.metallic", "appearance:metallic", &mut metallic, 0.0..=1.0),
("appearance.roughness", "appearance:roughness", &mut roughness, 0.045..=1.0),
("appearance.dielectric_ior", "appearance:ior", &mut ior, 1.0..=3.0),
] {
let response = ui_kit::row(ui, app.tr(label), |ui| ui_kit::scalar_field(ui, value, range));
crate::scenario::publish_handle(handle, response.rect.center());
if response.changed() {
detach_preset(k);
k.remove_override = false;
}
}
if let Ok(parameters) = PbrParameters::new(metallic, roughness, ior) {
k.pbr = Some(parameters);
}
}
let picked: Vec<Sel> = inputs.first().map(|i| i.items.clone()).unwrap_or_default();
ui.horizontal_wrapped(|ui| {
let has_target = !picked.is_empty() || k.component.is_some();
if ui_kit::button(ui, "Apply to selection", ui_kit::Button::Enabled(has_target)).clicked()
&& let Some(p) = selected_params(k, &picked)
{
k.remove_override = false;
k.note = Some(match app.run("appearance.assign", p.clone()) {
Ok(_) => {
k.applied = Some(p);
"Appearance applied".into()
}
Err(e) => e,
});
}
if ui_kit::button(ui, "Remove override", ui_kit::Button::Enabled(has_target))
.backing_on_hover_text(crate::i18n::tr_label("Restore the inherited component or physical material appearance"))
.clicked()
&& let Some(p) = clear_params(k, &picked)
{
k.note = Some(match app.run("appearance.assign", p) {
Ok(_) => {
k.remove_override = true;
k.applied = None;
"Inherited appearance restored".into()
}
Err(e) => e,
});
}
});
crate::dialogs_library::rows(app, ui, k, inputs);
// In this design.
let used = in_design(app);
if !used.is_empty() {
ui_kit::section_count(ui, "in_design", "In This Design", true, Some(used.len()), |ui| {
let items: Vec<_> = used.iter().enumerate().collect();
ui_kit::swatch_grid(ui, &items, |ui, (i, (look, n))| {
if ui_kit::color_swatch(
ui,
egui::Id::new(("ap_used", *i)),
c32(look.color, look.opacity),
k.color == look.color && k.opacity == look.opacity && k.pbr == look.pbr,
&format!("{} · {n} item(s)", look.name),
look.clone(),
)
.clicked()
&& let Err(error) = choose_look(k, look)
{
k.note = Some(error);
}
});
});
}
// The library, by category.
let lib = library(app);
let mut cats: Vec<String> = vec!["All".into()];
for l in &lib {
if !cats.contains(&l.category) {
cats.push(l.category.clone());
}
}
let refs: Vec<&str> = cats.iter().map(String::as_str).collect();
ui_kit::row(ui, "Library", |ui| combo(ui, "ap_cat", &refs, &mut k.category));
let search = ui_kit::row(ui, "Search", |ui| {
let id = ui.make_persistent_id("ap_search");
ui_kit::search_field(ui, id, &mut k.search, "Appearance name")
});
crate::scenario::publish_handle("appearance:search", search.rect.center());
ui_kit::row(ui, "", |ui| ui_kit::checkbox(ui, app.tr("appearance.only_available"), &mut k.only_available));
let want = cats.get(k.category).cloned().unwrap_or_default();
let query = k.search.trim().to_lowercase();
let shown: Vec<(usize, &Look)> = lib
.iter()
.enumerate()
.filter(|(_, l)| matches_library_filter(l, (k.category != 0).then_some(want.as_str()), &query, k.only_available))
.collect();
if shown.is_empty() {
ui_kit::text(ui, crate::i18n::tr_label("No matching appearances"), ui_kit::Text::Note("appearances_empty"));
}
ui_kit::swatch_grid(ui, &shown, |ui, (i, l)| {
let picked_look = k.look.as_deref() == Some(l.name.as_str()) && k.pbr == l.pbr;
let available = preset_available(l);
let tip = l.preset.as_ref().map_or_else(
|| format!("{} (drag onto a body or face)", l.name),
|p| format!("{}\n{}\n{}", l.name, p.preview_note, p.requirements.join(", ")),
);
ui.add_enabled_ui(available, |ui| {
let response = ui_kit::color_swatch(ui, egui::Id::new(("ap_lib", *i)), c32(l.color, l.opacity), picked_look, &tip, (*l).clone());
if let Some(preset) = &l.preset {
crate::scenario::publish_handle(&format!("appearance:preset:{}", preset.id), response.rect.center());
}
if response.clicked()
&& let Err(error) = choose_look(k, l)
{
k.note = Some(error);
}
})
.response
.backing_on_hover_text(tip);
});
// A swatch dropped on the model or the Browser.
let released = ui.input(|i| i.pointer.any_released());
if released && let Some(look) = egui::DragAndDrop::take_payload::<Look>(ui.ctx()) {
if let Err(error) = choose_look(k, &look) {
k.note = Some(error);
return false;
}
let targets = drop_target(app, k.faces);
if let Some(mut p) = apply_params(&targets, look.color, look.opacity, k.look.as_deref(), look.pbr) {
if let Some(pbr) = look.pbr {
p["pbr"] = json!(pbr);
}
if let Some(id) = &k.preset_id {
if let Some(object) = p.as_object_mut() {
object.remove("name");
}
p["appearance"] = json!(id);
}
k.note = Some(match app.run("appearance.assign", p.clone()) {
Ok(_) => {
k.applied = Some(p);
format!("{} on {}", look.name, target_names(&targets))
}
Err(e) => e,
});
}
}
if let Some(n) = &k.note {
ui_kit::text(ui, n, ui_kit::Text::Report("appearance_status", false));
}
false
}
fn target_names(targets: &[Sel]) -> String {
targets
.iter()
.map(|x| match x {
Sel::Body { name } => name.clone(),
Sel::Face { body, .. } => format!("a face of {body}"),
_ => String::new(),
})
.collect::<Vec<_>>()
.join(", ")
}
#[cfg(test)]
mod tests {
use solidcore_record::Vec3;
use solidcraft_engine::Session;
use super::*;
use crate::Services;
use crate::dialogs::apply_commands;
fn app() -> SolveApp {
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
s.execute("solid.box", &json!({"length": 5, "width": 5, "height": 5, "corner": [20, 0, 0]})).unwrap();
SolveApp::new(s, Services::default())
}
#[test]
fn clicked_pbr_editor_commits_once_and_reopens_without_changing_mass() {
let mut h = crate::scenario::Harness::new();
h.call("ui.resize", json!({"width":1600,"height":1400}));
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
let mass = h.app.session.execute("component.properties", &json!({})).unwrap();
let before = h.app.session.undo.len();
h.app.start("appearance.assign");
h.frames(3);
h.step(&json!({"click":{"handle":"appearance:pbr"}})).unwrap();
h.step(&json!({"widget":"Apply to selection"})).unwrap();
assert!(h.app.session.doc.appearances.bodies["Body1"].pbr.is_some());
assert_eq!(h.app.session.undo.len(), before + 1);
h.step(&json!({"widget":"OK"})).unwrap();
assert_eq!(h.app.session.undo.len(), before + 1);
assert_eq!(h.app.session.execute("component.properties", &json!({})).unwrap(), mass);
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
h.app.start("appearance.assign");
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!(k.pbr, Some(PbrParameters::default()));
assert_eq!(k.opacity, 1.0);
let params = selected_params(k, &h.app.dialog.as_ref().unwrap().inputs[0].items).unwrap();
assert_eq!(params["pbr"]["roughness"], 0.5);
}
#[test]
fn colours_parse_both_ways() {
assert_eq!(parse_color(&json!("#0a1B2c")), Some([10, 27, 44]));
assert_eq!(parse_color(&json!([1, 2, 3])), Some([1, 2, 3]));
assert_eq!(parse_color(&json!([1, 2, 300])), None);
assert_eq!(parse_color(&json!("#12345")), None);
assert_eq!(hex([10, 27, 44]), "#0a1b2c");
}
/// Pre-selected bodies are the objects; OK gives them the picked look.
#[test]
fn ok_applies_the_look_to_the_objects() {
let mut a = app();
a.session.selection = vec![Sel::Body { name: "Body1".into() }, Sel::Body { name: "Body2".into() }];
a.start("appearance.assign");
let mut d = a.dialog.clone().unwrap();
assert_eq!(d.inputs[0].items.len(), 2);
if let Kind::Appearance(k) = &mut d.kind {
k.color = [196, 40, 36];
k.look = Some("Paint - Red".into());
}
let c = apply_commands(&a, &d).unwrap();
assert_eq!(c[0].0, "appearance.assign");
assert_eq!(c[0].1["color"], "#c42824");
assert_eq!(c[0].1["bodies"], json!(["Body1", "Body2"]));
for (id, p) in c {
a.run(&id, p).unwrap();
}
assert_eq!(a.session.doc.appearances.bodies.get("Body2").map(|l| l.color), Some([196, 40, 36]));
let used = in_design(&mut a);
assert_eq!(used.len(), 1);
assert_eq!(used[0].0.color, [196, 40, 36]);
assert_eq!(used[0].0.name, "Paint - Red");
assert_eq!(used[0].1, 2);
}
/// A swatch dropped on a face in face mode targets the face; otherwise its body.
#[test]
fn drops_land_on_what_is_under_the_cursor() {
let mut a = app();
let p = Vec3::new(5.0, 5.0, 10.0);
a.viewport.hover = Some(Hit::Face { body: "Body1".into(), index: 0, point: p });
assert_eq!(drop_target(&a, false), vec![Sel::Body { name: "Body1".into() }]);
assert_eq!(drop_target(&a, true), vec![Sel::Face { body: "Body1".into(), index: 0, point: p }]);
a.viewport.hover = None;
a.viewport.hover_bodies = vec!["Body2".into()];
assert_eq!(drop_target(&a, false), vec![Sel::Body { name: "Body2".into() }]);
let face = apply_params(&[Sel::Face { body: "Body1".into(), index: 0, point: p }], [1, 2, 3], 0.5, None, None).unwrap();
assert_eq!(face["faces"][0]["body"], "Body1");
assert_eq!(face["opacity"], 0.5);
assert!(!library(&mut a).is_empty());
}
#[test]
fn face_preselection_keeps_the_face_and_remove_survives_ok() {
let mut a = app();
let point = Vec3::new(5.0, 5.0, 10.0);
let selected = vec![Sel::Face { body: "Body1".into(), index: 0, point }];
a.session.selection = selected.clone();
a.start("appearance.assign");
let mut d = a.dialog.clone().unwrap();
assert_eq!(d.inputs[0].items, selected);
let Kind::Appearance(k) = &mut d.kind else { panic!("appearance dialog") };
assert!(k.faces);
k.color = [10, 20, 30];
k.opacity = 0.25;
for (id, p) in commands(k, &d.inputs) {
a.run(&id, p).unwrap();
}
assert_eq!(a.session.doc.appearances.faces.len(), 1);
assert!(a.session.doc.appearances.bodies.is_empty());
a.run("appearance.assign", clear_params(k, &d.inputs[0].items).unwrap()).unwrap();
k.remove_override = true;
assert!(commands(k, &d.inputs).is_empty());
assert!(a.session.doc.appearances.faces.is_empty());
a.run("edit.undo", json!({})).unwrap();
assert_eq!(a.session.doc.appearances.faces.len(), 1);
}
#[test]
fn reused_design_look_preserves_transparency_and_name() {
let mut a = app();
a.run("appearance.assign", json!({"bodies": ["Body1"], "color": "#abcdef", "appearance": "Tinted glass", "opacity": 0.25})).unwrap();
let used = in_design(&mut a);
let look = &used[0].0;
assert_eq!(look.opacity, 0.25);
assert_eq!(look.name, "Tinted glass");
a.session.selection = vec![Sel::Body { name: "Body1".into() }];
a.start("appearance.assign");
let Kind::Appearance(k) = &a.dialog.as_ref().unwrap().kind else { panic!("appearance dialog") };
assert_eq!(k.opacity, 0.25);
assert_eq!(k.look.as_deref(), Some("Tinted glass"));
let p = apply_params(&[Sel::Body { name: "Body2".into() }], look.color, look.opacity, Some(&look.name), look.pbr).unwrap();
a.run("appearance.assign", p).unwrap();
assert_eq!(a.session.doc.appearances.bodies.get("Body1"), a.session.doc.appearances.bodies.get("Body2"));
}
#[test]
fn header_chevron_folds_and_restores_appearance_inputs() {
let mut h = crate::scenario::Harness::new();
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
h.app.start("appearance.assign");
h.frames(3);
let before = h.app.dialog.clone().unwrap();
h.step(&json!({"click":{"handle":"dialog:collapse"}})).unwrap();
assert!(h.app.dialog.as_ref().unwrap().collapsed);
assert!(h.widget("Appearance name").is_none());
h.step(&json!({"click":{"handle":"dialog:collapse"}})).unwrap();
let after = h.app.dialog.as_ref().unwrap();
assert!(!after.collapsed);
assert_eq!(format!("{:?}", after.inputs), format!("{:?}", before.inputs));
let (Kind::Appearance(before), Kind::Appearance(after)) = (&before.kind, &after.kind) else { panic!("appearance dialog") };
assert_eq!(before.color, after.color);
assert_eq!(before.opacity, after.opacity);
assert_eq!(before.search, after.search);
}
#[test]
fn real_frames_and_unchanged_apply_keep_precise_opacity() {
let mut h = crate::scenario::Harness::new();
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.run("appearance.assign", json!({"bodies":["Body1"],"color":"#abcdef","opacity":0.123456})).unwrap();
for cancel in [true, false] {
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
h.app.start("appearance.assign");
h.frames(3);
let Kind::Appearance(appearance) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance dialog") };
assert_eq!(appearance.opacity, 0.123456);
h.step(&json!({"key":if cancel {"Escape"} else {"Enter"}})).unwrap();
assert!(h.app.dialog.is_none(), "{:?}", h.app.dialog);
assert_eq!(h.app.session.doc.appearances.bodies["Body1"].opacity, 0.123456);
}
}
#[test]
fn hex_picker_preserves_precise_opacity_and_applies_alpha_without_losing_rgb_or_pbr() {
let mut h = crate::scenario::Harness::new();
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.run("appearance.assign", json!({"bodies":["Body1"],"color":"#abcdef","opacity":0.123456,"appearance":"Named tint"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
h.app.start("appearance.assign");
h.frames(3);
h.step(&json!({"click":{"handle":"dialog:color:Colour"}})).unwrap();
for mode in ["Hex", "F", "U8", "Hex"] {
h.step(&json!({"click":{"handle":format!("color:format:{mode}")}})).unwrap();
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!((k.color, k.opacity, k.look.as_deref()), ([171, 205, 239], 0.123456, Some("Named tint")));
}
let paste = |h: &mut crate::scenario::Harness, text: &str| {
h.step(&json!({"click":{"handle":"color:hex"}})).unwrap();
h.step(&json!({"key":"A","cmd":true,"ctrl":true})).unwrap();
h.frame_with(vec![egui::Event::Paste(text.into())]);
};
for text in ["#abc", "#abcdefz0"] {
paste(&mut h, text);
h.frames(2);
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!((k.color, k.opacity, k.look.as_deref()), ([171, 205, 239], 0.123456, Some("Named tint")));
assert!(h.widget(text).is_some(), "invalid text remains editable");
}
for (text, color, opacity) in [
("#AbCdEf", [171, 205, 239], 0.123456),
("#AbCdEf80", [171, 205, 239], 128.0 / 255.0),
("#0102fe00", [1, 2, 254], 0.0),
("#fE8001", [254, 128, 1], 0.0),
] {
paste(&mut h, text);
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!((k.color, k.opacity), (color, opacity), "{text} applies immediately without premultiplying RGB");
if text == "#AbCdEf" {
assert_eq!(k.look.as_deref(), Some("Named tint"), "re-entering unchanged RGB is not a manual colour change");
}
if text.len() == 9 {
assert!(k.look.is_none() && k.preset_id.is_none(), "an alpha-only colour edit also detaches the named look");
}
}
let copy = crate::scenario::handle_at("color:copy").unwrap();
h.frame_with(crate::test_support::pointer(copy, true));
h.frame_with(crate::test_support::pointer(copy, false));
assert!(
h.output.commands.iter().any(|command| matches!(command, egui::OutputCommand::CopyText(text) if text.eq_ignore_ascii_case("#fe8001")))
);
let Kind::Appearance(k) = &mut h.app.dialog.as_mut().unwrap().kind else { panic!("appearance editor") };
k.opacity = 0.25;
h.frames(2);
assert!(h.widget("#fe800140").is_some(), "external opacity edits synchronise the displayed Hex text");
h.step(&json!({"click":{"handle":"dialog:color:Colour"}})).unwrap();
h.step(&json!({"click":{"handle":"appearance:pbr"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:color:Colour"}})).unwrap();
paste(&mut h, "#22334480");
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!((k.color, k.opacity, k.pbr), ([254, 128, 1], 1.0, Some(PbrParameters::default())));
paste(&mut h, "#223344ff");
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!((k.color, k.opacity, k.pbr), ([34, 51, 68], 1.0, Some(PbrParameters::default())));
}
#[test]
fn immediate_apply_then_ok_has_one_undo_and_retains_precise_opacity() {
let mut a = app();
a.run("appearance.assign", json!({"bodies": ["Body1"], "color": "#abcdef", "opacity": 0.123456})).unwrap();
a.session.selection = vec![Sel::Body { name: "Body1".into() }];
a.start("appearance.assign");
let mut d = a.dialog.clone().unwrap();
let Kind::Appearance(k) = &mut d.kind else { panic!("appearance dialog") };
assert_eq!(commands(k, &d.inputs)[0].1["opacity"], json!(0.123456));
k.color = [1, 2, 3];
let p = selected_params(k, &d.inputs[0].items).unwrap();
a.run("appearance.assign", p.clone()).unwrap();
k.applied = Some(p);
assert!(commands(k, &d.inputs).is_empty());
a.run("edit.undo", json!({})).unwrap();
let restored = a.session.doc.appearances.bodies.get("Body1").unwrap();
assert_eq!(restored.color, [171, 205, 239]);
assert_eq!(restored.opacity, 0.123456);
k.opacity = 0.5;
assert_eq!(commands(k, &d.inputs).len(), 1, "changed look still applies on OK");
k.opacity = 0.123456;
d.inputs[0].items = vec![Sel::Body { name: "Body2".into() }];
assert_eq!(commands(k, &d.inputs).len(), 1, "changed target still applies on OK");
}
#[test]
fn inventory_rows_controls_sections_and_component_mode_remain_reachable() {
let mut h = crate::scenario::Harness::new();
h.call("ui.resize", json!({"width":1600,"height":2000}));
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.run("appearance.assign", json!({"bodies":["Body1"],"color":"#abcdef","opacity":0.25,"appearance":"Tinted glass"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
h.app.start("appearance.assign");
h.frames(5);
for handle in [
"dialog:Objects",
"dialog:clear:Objects",
"dialog:Apply To",
"dialog:color:Colour",
"dialog:slider:Opacity",
"appearance:pbr",
"appearance:search",
"dialog:section:Local library",
"dialog:section:In This Design",
"dialog:Library",
"dialog:button::Apply to selection",
"dialog:button::Remove override",
"library:export",
"dialog:ok",
"dialog:cancel",
"dialog:collapse",
] {
assert!(crate::scenario::handle_at(handle).is_some(), "missing {handle}");
}
for label in ["Objects", "Apply To", "Colour", "Opacity", "Surface response", "Library", "Search"] {
assert!(crate::scenario::rect_of(&format!("dialog:row:{label}")).is_some(), "missing row {label}");
}
h.step(&json!({"click":{"handle":"dialog:Apply To"}})).unwrap();
h.frames(2);
for option in ["Bodies", "Faces"] {
assert!(crate::scenario::handle_at(&format!("dialog:Apply To:{option}")).is_some());
}
h.step(&json!({"click":{"handle":"dialog:Apply To:Bodies"}})).unwrap();
h.step(&json!({"click":{"handle":"appearance:pbr"}})).unwrap();
for handle in ["appearance:metallic", "appearance:roughness", "appearance:ior"] {
assert!(crate::scenario::handle_at(handle).is_some(), "missing {handle}");
}
let Kind::Appearance(k) = &mut h.app.dialog.as_mut().unwrap().kind else { panic!("Appearance") };
k.component = Some("Example component".into());
k.note = Some("Appearance applied".into());
h.frames(4);
assert!(h.widget("Appearance applied").is_some());
assert!(crate::scenario::handle_at("dialog:button::Select bodies or faces instead").is_some());
assert!(crate::scenario::handle_at("dialog:cell:Component: Example component").is_some());
h.step(&json!({"widget":"Select bodies or faces instead"})).unwrap();
assert!(crate::scenario::handle_at("dialog:Apply To").is_some());
h.step(&json!({"click":{"handle":"dialog:clear:Objects"}})).unwrap();
assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());
h.step(&json!({"click":{"handle":"dialog:color:Colour"}})).unwrap();
h.frames(3);
for handle in [
"color:format:U8",
"color:format:F",
"color:copy",
"color:channel:R",
"color:channel:G",
"color:channel:B",
"color:sv",
"color:hue",
"color:current",
] {
assert!(crate::scenario::handle_at(handle).is_some(), "missing {handle}");
}
}
fn pack_entry(available: bool) -> Value {
json!({"id":"starter.wood.test-preview","name":"Uniform wood preview","category":"Wood","color":[110,76,50],"opacity":1.0,
"pbr":{"metallic":0.0,"roughness":0.6,"dielectric_ior":1.5},"available":available,
"requirements":["opaque_pbr"],"preview_note":"Uniform color preview; no grain maps."})
}
#[test]
fn pack_ui_filter_and_selection_keep_exact_id_and_explicit_preview_note() {
let mut app = app();
app.start("appearance.assign");
let Kind::Appearance(k) = &mut app.dialog.as_mut().unwrap().kind else { panic!("appearance editor") };
let look = library_look(&pack_entry(true)).unwrap();
assert!(matches_library_filter(&look, Some("Wood"), "uniform", true));
assert!(matches_library_filter(&look, None, "starter.wood", true));
assert!(!matches_library_filter(&look, Some("Metal"), "", false));
choose_look(k, &look).unwrap();
assert_eq!(k.look.as_deref(), Some("Uniform wood preview"));
assert!(k.note.as_ref().unwrap().contains("no grain maps"));
let params = selected_params(k, &[Sel::Body { name: "Body1".into() }]).unwrap();
assert_eq!(params["appearance"], "starter.wood.test-preview");
assert_eq!(params["opacity"], 1.0);
assert_eq!(params["pbr"]["roughness"], 0.6);
}
#[test]
fn unavailable_pack_recipe_refuses_before_editor_document_or_history_mutation() {
let mut app = app();
app.start("appearance.assign");
let doc = app.session.doc.clone();
let history = (app.session.undo.len(), app.session.redo.len(), app.session.is_dirty());
let Kind::Appearance(k) = &mut app.dialog.as_mut().unwrap().kind else { panic!("appearance editor") };
let before = format!("{k:?}");
let mut value = pack_entry(false);
value["id"] = json!("starter.glass.test-recipe");
value["requirements"] = json!(["refraction", "certified_thin_or_closed"]);
value["preview_note"] = json!("Requires certified glass transport; alpha is not refraction.");
let look = library_look(&value).unwrap();
assert!(choose_look(k, &look).unwrap_err().contains("certified_thin_or_closed"));
assert_eq!(format!("{k:?}"), before);
assert!(!matches_library_filter(&look, None, "", true));
assert!(matches_library_filter(&look, None, "", false));
assert!(std::sync::Arc::ptr_eq(&doc, &app.session.doc));
assert_eq!(history, (app.session.undo.len(), app.session.redo.len(), app.session.is_dirty()));
let mut invalid = pack_entry(true);
invalid.as_object_mut().unwrap().remove("available");
assert!(library_look(&invalid).is_none(), "pack metadata cannot silently become a legacy look");
value["available"] = json!(true);
assert!(choose_look(k, &library_look(&value).unwrap()).is_err(), "unsupported optical requirements cannot masquerade as an opaque preset");
}
#[test]
fn actual_opaque_pack_ui_selection_applies_once_and_undo_preserves_physics() {
let mut app = app();
let look = library(&mut app)
.into_iter()
.find(|look| look.preset.as_ref().is_some_and(|p| p.available && p.id.starts_with("starter.metal.")))
.expect("opaque pack entry");
app.session.selection = vec![Sel::Body { name: "Body1".into() }];
let physical = app.session.execute("component.properties", &json!({})).unwrap();
let before = app.session.undo.len();
app.start("appearance.assign");
let mut dialog = app.dialog.clone().unwrap();
let Kind::Appearance(k) = &mut dialog.kind else { panic!("appearance editor") };
choose_look(k, &look).unwrap();
let params = selected_params(k, &dialog.inputs[0].items).unwrap();
assert_eq!(params["appearance"], look.preset.as_ref().unwrap().id);
app.run("appearance.assign", params.clone()).unwrap();
k.applied = Some(params);
assert!(commands(k, &dialog.inputs).is_empty(), "OK must not duplicate immediate Apply");
assert_eq!(app.session.undo.len(), before + 1);
assert_eq!(app.session.execute("component.properties", &json!({})).unwrap(), physical);
app.run("edit.undo", json!({})).unwrap();
assert!(!app.session.doc.appearances.bodies.contains_key("Body1"));
assert_eq!(app.session.execute("component.properties", &json!({})).unwrap(), physical);
}
#[test]
fn actual_pack_provider_all_ids_requirements_and_disabled_glass_survive_ui_parsing() {
use solidcraft_engine::doc::appearance_pack::STARTER_PACK;
let mut app = app();
let looks = library(&mut app);
for preset in STARTER_PACK {
let matching: Vec<_> = looks.iter().filter(|look| look.preset.as_ref().is_some_and(|p| p.id == preset.id)).collect();
assert_eq!(matching.len(), 1, "actual provider entry missing from UI: {}", preset.id);
let look = matching[0];
let metadata = look.preset.as_ref().unwrap();
assert_eq!(metadata.preview_note, preset.preview_note);
assert_eq!(serde_json::to_value(&metadata.requirements).unwrap(), serde_json::to_value(preset.requirements).unwrap());
assert_eq!(preset_available(look), preset.is_opaque());
}
let pack: Vec<_> = looks.iter().filter(|look| look.preset.is_some()).collect();
assert!(pack.len() >= 40);
assert!(pack.iter().filter(|look| preset_available(look)).count() >= 34);
assert!(pack.iter().filter(|look| !preset_available(look)).count() >= 6);
for &(name, color, opacity) in solidcraft_engine::doc::appearance::LIBRARY {
let look = looks.iter().find(|look| look.name == name).unwrap();
assert_eq!((look.color, look.opacity, look.pbr, look.preset.as_ref()), (color, opacity, None, None));
}
// The six published finishes remain independent of starter metadata.
for &(name, color, metallic, roughness) in solidcraft_engine::doc::appearance::OPAQUE_FINISHES {
let matching: Vec<_> = looks.iter().filter(|look| look.name == name).collect();
assert_eq!(matching.len(), 1);
let look = matching[0];
assert_eq!(look.color, color);
assert_eq!(look.opacity, 1.0);
assert_eq!(look.pbr, Some(PbrParameters::new(metallic, roughness, 1.5).unwrap()));
assert!(look.preset.is_none() && preset_available(look));
}
assert!(!looks.is_empty());
let mut names = std::collections::BTreeSet::new();
assert!(looks.iter().all(|look| names.insert(look.name.to_ascii_lowercase())));
assert!(looks.iter().filter(|look| preset_available(look)).count() >= 60);
assert!(looks.iter().filter(|look| preset_available(look) && look.opacity == 1.0).count() >= 58);
assert!(looks.iter().filter(|look| look.opacity != 1.0).count() >= 2);
}
#[test]
fn manual_edit_of_selected_or_reopened_pack_look_does_not_resolve_preset_again() {
use solidcraft_engine::doc::appearance_pack::STARTER_PACK;
for reopened in [false, true] {
let mut app = app();
let preset = STARTER_PACK.iter().find(|p| p.is_opaque()).unwrap();
app.run("appearance.assign", json!({"bodies":["Body1"],"appearance":preset.id})).unwrap();
app.session.selection = vec![Sel::Body { name: "Body1".into() }];
app.start("appearance.assign");
let mut dialog = app.dialog.clone().unwrap();
let Kind::Appearance(k) = &mut dialog.kind else { panic!("appearance editor") };
if !reopened {
k.preset_id = Some(preset.id.into());
}
assert_eq!(k.look.as_deref(), Some(preset.name));
detach_preset(k);
k.pbr = None;
k.opacity = 0.5;
let params = selected_params(k, &dialog.inputs[0].items).unwrap();
assert!(params.get("appearance").is_none());
app.run("appearance.assign", params).unwrap();
let result = app.session.doc.appearances.bodies.get("Body1").unwrap();
assert!(result.pbr.is_none());
assert_eq!(result.opacity, 0.5);
}
}
#[test]
fn manual_edit_of_published_finish_keeps_scalar_override_after_selection_and_editor_reopen() {
for &(name, ..) in solidcraft_engine::doc::appearance::OPAQUE_FINISHES {
for reopened in [false, true] {
let mut app = app();
let look = library(&mut app).into_iter().find(|look| look.name == name).unwrap();
app.run("appearance.assign", json!({"bodies":["Body1"],"appearance":name})).unwrap();
let physical = app.session.execute("component.properties", &json!({})).unwrap();
app.session.selection = vec![Sel::Body { name: "Body1".into() }];
app.start("appearance.assign");
let mut dialog = app.dialog.clone().unwrap();
let Kind::Appearance(k) = &mut dialog.kind else { panic!("appearance editor") };
if !reopened {
choose_look(k, &look).unwrap();
}
assert_eq!(k.look.as_deref(), Some(name));
assert!(k.pbr.is_some() && k.preset_id.is_none());
detach_preset(k);
assert_eq!(k.look.as_deref(), Some(name));
assert!(k.preset_id.is_none());
k.pbr = None;
k.opacity = 0.5;
let params = selected_params(k, &dialog.inputs[0].items).unwrap();
assert_eq!(params["name"], name);
assert!(params.get("color").is_some());
let undo = app.session.undo.len();
app.run("appearance.assign", params).unwrap();
let result = app.session.doc.appearances.bodies.get("Body1").unwrap();
assert_eq!(result.name, name);
assert!(result.pbr.is_none());
assert_eq!(result.opacity, 0.5);
assert_eq!(app.session.undo.len(), undo + 1);
assert_eq!(app.session.execute("component.properties", &json!({})).unwrap(), physical);
}
}
}
#[test]
fn clicked_starter_swatch_applies_once_and_disabled_glass_cannot_replace_it() {
let mut h = crate::scenario::Harness::new();
h.call("ui.resize", json!({"width":1600,"height":1400}));
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Body1".into() }];
let mass = h.app.session.execute("component.properties", &json!({})).unwrap();
let before = h.app.session.undo.len();
h.app.start("appearance.assign");
let Kind::Appearance(k) = &mut h.app.dialog.as_mut().unwrap().kind else { panic!("appearance editor") };
k.search = "starter.metal.gold-warm".into();
h.frames(3);
h.step(&json!({"click":{"handle":"appearance:preset:starter.metal.gold-warm"}})).unwrap();
h.step(&json!({"widget":"Apply to selection"})).unwrap();
assert_eq!(h.app.session.doc.appearances.bodies["Body1"].name, "Metal - Warm Reflective Gold");
assert_eq!(h.app.session.doc.appearances.bodies["Body1"].pbr.unwrap().metallic(), 1.0);
assert_eq!(h.app.session.undo.len(), before + 1);
let Kind::Appearance(k) = &mut h.app.dialog.as_mut().unwrap().kind else { panic!("appearance editor") };
k.search = "starter.glass.clear-soda-lime".into();
let selected = (k.preset_id.clone(), k.color, k.opacity, k.pbr);
h.frames(3);
h.step(&json!({"click":{"handle":"appearance:preset:starter.glass.clear-soda-lime"}})).unwrap();
let Kind::Appearance(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("appearance editor") };
assert_eq!((k.preset_id.clone(), k.color, k.opacity, k.pbr), selected);
h.step(&json!({"widget":"OK"})).unwrap();
assert_eq!(h.app.session.undo.len(), before + 1);
assert_eq!(h.app.session.execute("component.properties", &json!({})).unwrap(), mass);
}
#[test]
fn selectable_library_entries_exclude_unavailable_starter_glass_recipes() {
let mut h = crate::scenario::Harness::new();
let listed = h.app.session.execute("appearance.library", &json!({})).unwrap();
let rows = listed["appearances"].as_array().unwrap();
let available = rows.iter().filter(|row| row.get("available").and_then(Value::as_bool) != Some(false)).count();
let selectable: Vec<_> = library(&mut h.app).into_iter().filter(preset_available).collect();
assert_eq!(selectable.len(), available);
for preset in solidcraft_engine::doc::appearance_pack::STARTER_PACK {
assert_eq!(selectable.iter().any(|look| look.name == preset.name), preset.is_opaque());
}
}
#[test]
fn applying_and_clearing_owned_recipe_labels_never_resolves_the_recipe() {
let mut h = crate::scenario::Harness::new();
h.app.run("solid.box", json!({"body_name":"Owned","length":10,"width":10,"height":10})).unwrap();
for name in ["starter.glass.clear-soda-lime", "Glass Recipe - Low Iron Clear", "Metal - Warm Reflective Gold"] {
h.app.run("appearance.assign", json!({"bodies":["Owned"],"name":name,"color":[31,61,91],"pbr":null})).unwrap();
let original = h.app.session.doc.appearances.bodies["Owned"].clone();
h.app.session.selection = vec![Sel::Body { name: "Owned".into() }];
h.app.start("appearance.assign");
let dialog = h.app.dialog.as_ref().unwrap();
let Kind::Appearance(state) = &dialog.kind else { panic!("appearance editor expected") };
let params = selected_params(state, &dialog.inputs[0].items).unwrap();
let clear = clear_params(state, &dialog.inputs[0].items).unwrap();
assert_eq!(params["name"], name);
assert!(params.get("appearance").is_none());
assert_eq!(params["pbr"], Value::Null);
h.app.run("appearance.assign", params).unwrap();
assert_eq!(h.app.session.doc.appearances.bodies["Owned"], original);
assert!(clear.get("name").is_none() && clear.get("appearance").is_none());
h.app.run("appearance.assign", clear).unwrap();
assert!(!h.app.session.doc.appearances.bodies.contains_key("Owned"));
}
}
#[test]
fn dropped_scalar_and_pbr_requests_match_ok_without_an_extra_undo() {
for response in [None, Some(PbrParameters::new(0.7, 0.25, 1.5).unwrap())] {
let mut a = app();
a.session.selection = vec![Sel::Body { name: "Body1".into() }];
a.start("appearance.assign");
let mut dialog = a.dialog.clone().unwrap();
let Kind::Appearance(state) = &mut dialog.kind else { panic!("appearance editor") };
state.look = Some("Owned swatch".into());
state.color = [31, 61, 91];
state.opacity = 1.0;
state.pbr = response;
let params = apply_params(&dialog.inputs[0].items, state.color, state.opacity, state.look.as_deref(), state.pbr).unwrap();
assert!(params.get("pbr").is_some(), "the complete owned response is explicit");
assert_eq!(params["pbr"], json!(response));
let original = a.session.doc.clone();
let undo = a.session.undo.len();
a.run("appearance.assign", params.clone()).unwrap();
state.applied = Some(params);
assert_eq!(a.session.undo.len(), undo + 1);
assert!(commands(state, &dialog.inputs).is_empty(), "OK after a drop is not another edit");
a.run("edit.undo", json!({})).unwrap();
assert_eq!(a.session.doc, original);
}
}
}