From 40ff251e5fbc8dd0e25b4d830385cecedda943b8 Mon Sep 17 00:00:00 2001 From: Nathan Dane Date: Thu, 29 Oct 2026 03:29:10 +0000 Subject: [PATCH] Render wear: a Wear row and editor for the aging layers (#6281) (#7459) * Render wear: a Wear row and editor for the aging layers * test: read Wear header text from accessibility label values * test: restore body picks for Wear header recovery assertions --- assets/locales/pending/render-wear.json | 74 ++++++++ attribution/pending/render-wear.md | 1 + crates/engine/src/cmd/view_navigation.rs | 53 ++++-- crates/engine/src/schema/view_navigation.rs | 64 ++++++- crates/ui-egui/src/lib.rs | 1 + crates/ui-egui/src/render_ui/scene.rs | 33 ++++ crates/ui-egui/src/render_ui/wear.rs | 171 +++++++++++++++++ crates/ui-egui/src/render_workspace.rs | 14 +- .../ui-egui/src/render_workspace_effects.rs | 147 +-------------- .../ui-egui/src/render_workspace_inspector.rs | 25 ++- .../src/render_workspace_inspector_tests.rs | 174 +++++++++++++++++- crates/ui-egui/src/render_workspace_tests.rs | 41 +++++ 12 files changed, 634 insertions(+), 164 deletions(-) create mode 100644 assets/locales/pending/render-wear.json create mode 100644 attribution/pending/render-wear.md create mode 100644 crates/ui-egui/src/render_ui/wear.rs diff --git a/assets/locales/pending/render-wear.json b/assets/locales/pending/render-wear.json new file mode 100644 index 000000000..cfc22c72f --- /dev/null +++ b/assets/locales/pending/render-wear.json @@ -0,0 +1,74 @@ +{ + "en": { + "render.wear_title": "Wear", + "render.wear_layers": "Layers", + "render.wear_selected_layer": "Selected layer", + "render.wear_applies_to": "Applies to", + "render.wear_no_layers": "No layers", + "render.wear_layer_one": "{count} layer", + "render.wear_layer_count": "{count} layers" + }, + "ja": { + "render.wear_title": "ウェア", + "render.wear_layers": "レイヤー", + "render.wear_selected_layer": "選択したレイヤー", + "render.wear_applies_to": "適用先", + "render.wear_no_layers": "レイヤーなし", + "render.wear_layer_one": "{count} レイヤー", + "render.wear_layer_count": "{count} レイヤー" + }, + "zh": { + "render.wear_title": "表面老化", + "render.wear_layers": "图层", + "render.wear_selected_layer": "所选图层", + "render.wear_applies_to": "应用于", + "render.wear_no_layers": "无图层", + "render.wear_layer_one": "{count} 个图层", + "render.wear_layer_count": "{count} 个图层" + }, + "de": { + "render.wear_title": "Abnutzung", + "render.wear_layers": "Ebenen", + "render.wear_selected_layer": "Ausgewählte Ebene", + "render.wear_applies_to": "Anwenden auf", + "render.wear_no_layers": "Keine Ebenen", + "render.wear_layer_one": "{count} Ebene", + "render.wear_layer_count": "{count} Ebenen" + }, + "ko": { + "render.wear_title": "마모", + "render.wear_layers": "레이어", + "render.wear_selected_layer": "선택한 레이어", + "render.wear_applies_to": "적용 대상", + "render.wear_no_layers": "레이어 없음", + "render.wear_layer_one": "레이어 {count}개", + "render.wear_layer_count": "레이어 {count}개" + }, + "ar": { + "render.wear_title": "البلى", + "render.wear_layers": "الطبقات", + "render.wear_selected_layer": "الطبقة المحددة", + "render.wear_applies_to": "ينطبق على", + "render.wear_no_layers": "لا طبقات", + "render.wear_layer_one": "{count} طبقة", + "render.wear_layer_count": "{count} طبقات" + }, + "he": { + "render.wear_title": "בלאי", + "render.wear_layers": "שכבות", + "render.wear_selected_layer": "שכבה נבחרת", + "render.wear_applies_to": "חל על", + "render.wear_no_layers": "אין שכבות", + "render.wear_layer_one": "שכבה {count}", + "render.wear_layer_count": "{count} שכבות" + }, + "vi": { + "render.wear_title": "Hao mòn", + "render.wear_layers": "Lớp", + "render.wear_selected_layer": "Lớp đã chọn", + "render.wear_applies_to": "Áp dụng cho", + "render.wear_no_layers": "Không có lớp", + "render.wear_layer_one": "{count} lớp", + "render.wear_layer_count": "{count} lớp" + } +} diff --git a/attribution/pending/render-wear.md b/attribution/pending/render-wear.md new file mode 100644 index 000000000..8d0f72642 --- /dev/null +++ b/attribution/pending/render-wear.md @@ -0,0 +1 @@ +| assets/locales/pending/render-wear.json | SolidCraft contributors | Original UI labels and translations | MIT OR Apache-2.0 | diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs index 3a8fb5643..1904773df 100644 --- a/crates/engine/src/cmd/view_navigation.rs +++ b/crates/engine/src/cmd/view_navigation.rs @@ -59,9 +59,11 @@ CommandSpec::new("view.render_browser", "Render Browser", crate::checked!("view. CommandSpec::new("view.render_inspector", "Render Inspector", render_inspector) .icon("inspect").noundo().doc_only() .params("visible: bool → {visible}; per-document Inspector visibility; never edits the design or opens a dialog"), -CommandSpec::new("view.render_select", "Render selection", render_select) +CommandSpec::new("view.render_select", "Render selection", crate::checked!("view.render_select", render_select)) + .contract(&RENDER_SELECT_CONTRACT) + .output(crate::schema::output_schema_for::) .icon("select").noundo().doc_only() - .params("kind: nothing|environment|light|shot|output; id?: bounded nonempty string for light/shot → validated transient Browser focus; never edits the design or opens a dialog"), + .params("kind: nothing|environment|light|shot|output|wear; id?: bounded nonempty string for light/shot → validated transient Browser focus; never edits the design or opens a dialog"), CommandSpec::new("view.render_stage", "Render Stage", render_stage) .icon("render_scene").noundo().doc_only() .params("stage: look|light|frame|output → {stage}; per-document UI state, never edits or evaluates the design; headless validation only"), @@ -267,22 +269,11 @@ fn render_focus(_s: &mut Session, p: &Value) -> Result { Ok(json!(request)) } +const RENDER_SELECT_CONTRACT: crate::schema::TypedContract = crate::schema::TypedContract::new(); + fn render_select(s: &mut Session, p: &Value) -> Result { - #[derive(serde::Deserialize, serde::Serialize)] - #[serde(deny_unknown_fields)] - struct Request { - kind: String, - #[serde(skip_serializing_if = "Option::is_none")] - id: Option, - } - let request: Request = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_select", e.to_string()))?; - let identified = matches!(request.kind.as_str(), "light" | "shot"); - if !matches!(request.kind.as_str(), "nothing" | "environment" | "light" | "shot" | "output") - || identified != request.id.is_some() - || request.id.as_ref().is_some_and(|id| id.trim().is_empty() || id.len() > 1024) - { - return Err(bad("view.render_select", "expected a Browser kind and an id only for light or shot")); - } + let request: crate::schema::view_navigation::RenderSelect = + serde_json::from_value(p.clone()).map_err(|e| bad("view.render_select", e.to_string()))?; let result = serde_json::to_value(request).map_err(|e| bad("view.render_select", e.to_string()))?; if !s.selection.is_empty() { s.selection.clear(); @@ -1148,6 +1139,7 @@ fn render_browser_focus_validates_without_document_changes_or_evaluation() { for request in [ json!({"kind":"nothing"}), json!({"kind":"environment"}), + json!({"kind":"wear"}), json!({"kind":"light","id":"sun:0"}), json!({"kind":"shot","id":"Hero"}), json!({"kind":"output"}), @@ -1158,6 +1150,9 @@ fn render_browser_focus_validates_without_document_changes_or_evaluation() { Value::Null, json!([]), json!({}), + json!({"kind":"wear","id":"extra"}), + json!({"kind":"wear","extra":true}), + json!({"kind":"wear","id":1e300}), json!({"kind":"object"}), json!({"kind":"shot"}), json!({"kind":"light","id":1}), @@ -1172,6 +1167,30 @@ fn render_browser_focus_validates_without_document_changes_or_evaluation() { assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty())); } +#[cfg(test)] +#[test] +fn render_select_wear_schema_and_strict_contract_agree() { + let mut session = Session { param_check: crate::schema::ParamCheck::Strict, ..Session::default() }; + let spec = crate::find_command("view.render_select").unwrap(); + let contract = spec.contract.unwrap(); + assert_eq!(contract.allowed_keys().iter().map(String::as_str).collect::>(), ["id", "kind"]); + let input = contract.input_schema().to_value(); + let output = spec.output.unwrap()().to_value(); + for schema in [input, output] { + assert!(schema["oneOf"][0]["properties"]["kind"]["enum"].as_array().unwrap().contains(&json!("wear"))); + assert_eq!(schema["oneOf"][0]["additionalProperties"], false); + } + let request = json!({"kind":"wear"}); + assert!(contract.check(&request).is_empty()); + assert_eq!(session.execute("view.render_select", &request).unwrap(), request); + for request in [json!({"kind":"wear","id":"extra"}), json!({"kind":"wear","extra":true}), json!({"kind":"wear","id":1e300})] { + assert!(!contract.check(&request).is_empty()); + assert!(session.execute("view.render_select", &request).is_err()); + } + assert!(session.undo.is_empty() && session.redo.is_empty()); + assert_eq!(session.evaluations, 0); +} + #[cfg(test)] #[test] fn render_browser_controls_validate_without_document_changes_or_evaluation() { diff --git a/crates/engine/src/schema/view_navigation.rs b/crates/engine/src/schema/view_navigation.rs index 7bdae0b29..7d1554bcc 100644 --- a/crates/engine/src/schema/view_navigation.rs +++ b/crates/engine/src/schema/view_navigation.rs @@ -1,7 +1,8 @@ //! Render shell requests. The UI applies validated echoes without design edits. -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; +use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema}; +use serde::{Deserialize, Deserializer, Serialize}; use serde_json::Value; +use std::borrow::Cow; #[derive(Debug, Deserialize, Serialize, JsonSchema)] #[serde(deny_unknown_fields)] @@ -85,6 +86,65 @@ pub struct TabStep { pub param_warnings: Vec, } +/// Validated request and echoed result of `view.render_select`. +#[derive(Debug, Serialize)] +pub struct RenderSelect { + pub kind: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub id: Option, +} + +impl<'de> Deserialize<'de> for RenderSelect { + fn deserialize>(d: D) -> Result { + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Request { + kind: String, + id: Option, + } + let request = Request::deserialize(d)?; + let identified = matches!(request.kind.as_str(), "light" | "shot"); + if !matches!(request.kind.as_str(), "nothing" | "environment" | "light" | "shot" | "output" | "wear") + || identified != request.id.is_some() + || request.id.as_ref().is_some_and(|id| id.trim().is_empty() || id.len() > 1024) + { + return Err(serde::de::Error::custom("expected a Browser kind and an id only for light or shot")); + } + Ok(Self { kind: request.kind, id: request.id }) + } +} + +impl JsonSchema for RenderSelect { + fn schema_name() -> Cow<'static, str> { + "RenderSelect".into() + } + fn json_schema(_: &mut SchemaGenerator) -> Schema { + json_schema!({ + "oneOf": [ + { + "type": "object", + "properties": { + "kind": {"type": "string", "enum": ["nothing", "environment", "output", "wear"]}, + "id": {"type": "null"} + }, + "required": ["kind"], + "additionalProperties": false + }, + { + "type": "object", + "properties": { + "kind": {"type": "string", "enum": ["light", "shot"]}, + "id": {"type": "string", "minLength": 1, "maxLength": 1024, "pattern": super::types::not_blank_pattern(), + "description": "A nonblank identity, at most 1024 UTF-8 bytes."} + }, + "required": ["kind", "id"], + "additionalProperties": false + } + ] + }) + } +} + #[cfg(test)] #[path = "view_navigation_tests.rs"] mod tests; diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 57b66799e..c4947813c 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -1108,6 +1108,7 @@ impl SolveApp { use render_workspace::RenderSelection; let selected = match v.get("kind").and_then(Value::as_str) { Some("environment") => RenderSelection::Environment, + Some("wear") => RenderSelection::Wear, Some("output") => RenderSelection::Output, Some("light") => RenderSelection::Light(v.get("id").and_then(Value::as_str).unwrap_or_default().into()), Some("shot") => RenderSelection::Shot(v.get("id").and_then(Value::as_str).unwrap_or_default().into()), diff --git a/crates/ui-egui/src/render_ui/scene.rs b/crates/ui-egui/src/render_ui/scene.rs index 0fcae1ce8..e2778a563 100644 --- a/crates/ui-egui/src/render_ui/scene.rs +++ b/crates/ui-egui/src/render_ui/scene.rs @@ -343,6 +343,38 @@ pub(crate) fn groups(app: &SolveApp) -> Vec { groups } +pub(crate) fn wear_subtitle(app: &SolveApp) -> String { + let count = app.render_workspace.view.studio.aging.len(); + if count == 0 { + app.tr("render.wear_no_layers").into() + } else { + crate::i18n::format(if count == 1 { "render.wear_layer_one" } else { "render.wear_layer_count" }, &[("count", &count.to_string())]) + } +} + +fn wear(app: &mut SolveApp, ui: &mut egui::Ui) { + let subtitle = wear_subtitle(app); + let row = browser::draw_row( + ui, + ui.id().with("render_wear"), + &Row { + depth: 1, + label: app.tr("render.wear_title"), + name: true, + icon: "appearance", + subtitle: &subtitle, + selected: app.render_workspace.view.selection == RenderSelection::Wear, + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target("render:tree:wear", rect); + } + if row.clicked { + select(app, "wear", None); + } +} + /// Returns true when the object section is closed or the By look lens drew its objects. pub(crate) fn objects(app: &mut SolveApp, ui: &mut egui::Ui, hover_bodies: &mut Vec, hovered: &mut bool) -> bool { if app.tree.reveal.is_some() { @@ -351,6 +383,7 @@ pub(crate) fn objects(app: &mut SolveApp, ui: &mut egui::Ui, hover_bodies: &mut if !section(app, ui, "objects") { return true; } + wear(app, ui); if !app.render_workspace.view.by_look { return false; } diff --git a/crates/ui-egui/src/render_ui/wear.rs b/crates/ui-egui/src/render_ui/wear.rs new file mode 100644 index 000000000..90f5c55c3 --- /dev/null +++ b/crates/ui-egui/src/render_ui/wear.rs @@ -0,0 +1,171 @@ +//! The scene's wear stack. Edits retain the existing render draft and save path. +use super::{ + ImageMethod, + effects::{failure, layer_actions, note, number}, + materials, studio, +}; +use crate::{SolveApp, theme::Tokens, ui_kit}; +use solidcraft_engine::render::job::aging::{AgingKind, AgingLayer, SurfaceClass}; + +pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { + note(app, ui, "render.effects_gpu_only"); + ui.add_space(Tokens::get().space_4); + let enabled = app.render_workspace.view.method == ImageMethod::GpuRaytrace; + let response = ui.add_enabled_ui(enabled, |ui| layer_controls(app, ui)); + crate::scenario::publish_rect("render:wear:controls", response.response.rect); +} + +fn layer_controls(app: &mut SolveApp, ui: &mut egui::Ui) { + note(app, ui, "render.aging_help"); + let mut editor = std::mem::take(&mut app.render_workspace.view.inspector.effects); + let before = app.render_workspace.view.studio.aging.clone(); + let mut stack = before.clone(); + let title = app.tr("render.wear_layers").to_string(); + ui_kit::section(ui, "render_wear_layers", &title, true, |ui| { + let add = ui_kit::dropdown_menu(ui, "render_aging_add", app.tr("render.aging_add"), |ui| { + for kind in AgingKind::ALL { + let id = format!("aging-add-{}", kind.code()); + if ui_kit::list_picker(ui, &id, app.tr(kind.key()), false).clicked() { + match stack.push(AgingLayer::preset(kind)) { + Ok(()) => editor.selected_aging = stack.len() - 1, + Err(error) => app.set_status(error.to_string(), true), + } + ui.close(); + } + } + }); + crate::scenario::publish_target("render:aging-add", add.rect); + if stack.is_empty() { + note(app, ui, "render.aging_empty"); + } + editor.selected_aging = editor.selected_aging.min(stack.len().saturating_sub(1)); + for index in 0..stack.len() { + let Some(layer) = stack.get_mut(index) else { continue }; + let label = format!("{} · {}", index + 1, app.tr(layer.kind.key())); + let eye_target = format!("render:aging-layer:{index}:enabled"); + let actions = [ui_kit::TreeAction { + icon: if layer.enabled { "eye" } else { "suppress" }, + hover_only: false, + label: app.tr("render.layer_enabled"), + reason: None, + target: &eye_target, + }]; + let row = ui_kit::tree_row( + ui, + ui.id().with(("aging-layer", index)), + &ui_kit::Row { label: &label, name: true, selected: index == editor.selected_aging, actions: &actions, ..Default::default() }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target(&format!("render:aging-layer:{index}"), rect); + } + if row.clicked { + editor.selected_aging = index; + } + if row.actions.iter().any(|response| response.clicked()) { + layer.enabled = !layer.enabled; + } + } + if !stack.is_empty() { + let (movement, remove) = layer_actions(app, ui, "aging", editor.selected_aging, stack.len()); + if remove { + failure(app, stack.remove(editor.selected_aging).map_err(|e| e.to_string())); + editor.selected_aging = editor.selected_aging.min(stack.len().saturating_sub(1)); + } else if movement != 0 { + let next = if movement < 0 { editor.selected_aging.saturating_sub(1) } else { editor.selected_aging + 1 }; + failure(app, stack.move_layer(editor.selected_aging, next).map_err(|e| e.to_string())); + editor.selected_aging = next; + } + } + }); + if let Some(layer) = stack.get_mut(editor.selected_aging) { + let title = app.tr("render.wear_selected_layer").to_string(); + ui_kit::section(ui, "render_wear_selected_layer", &title, true, |ui| { + let response = ui_kit::checkbox(ui, app.tr("render.layer_enabled"), &mut layer.enabled); + crate::scenario::publish_target("render:aging-enabled", response.rect); + number(app, ui, "render.layer_strength", &mut layer.strength, 0.0..=1.0, 0.01, ""); + number(app, ui, "render.aging_coverage", &mut layer.coverage, 0.0..=1.0, 0.01, ""); + number(app, ui, "render.aging_scale", &mut layer.scale_mm, 0.01..=100000.0, 0.1, " mm"); + let response = ui_kit::row(ui, app.tr("render.effects_seed"), |ui| ui_kit::number_field(ui, &mut layer.seed, 0..=65535, 1.0, "")); + crate::scenario::publish_target("render:aging-seed", response.rect); + let response = ui_kit::row(ui, app.tr("render.aging_color"), |ui| ui_kit::color_field(ui, &mut layer.color_srgb)); + crate::scenario::publish_target("render:aging-color", response.rect); + number(app, ui, "render.aging_roughness", &mut layer.roughness, 0.02..=1.0, 0.01, ""); + number(app, ui, "render.aging_metallic", &mut layer.metallic, 0.0..=1.0, 0.01, ""); + number(app, ui, "render.aging_upward", &mut layer.upward_bias, 0.0..=1.0, 0.01, ""); + let current = match layer.surface_class { + SurfaceClass::AnyOpaque => "render.aging_class_any", + SurfaceClass::Metal => "render.aging_class_metal", + SurfaceClass::Dielectric => "render.aging_class_dielectric", + }; + let class = ui_kit::dropdown_menu(ui, "render_aging_class", app.tr(current), |ui| { + for (value, key) in [ + (SurfaceClass::AnyOpaque, "render.aging_class_any"), + (SurfaceClass::Metal, "render.aging_class_metal"), + (SurfaceClass::Dielectric, "render.aging_class_dielectric"), + ] { + if ui_kit::list_picker(ui, key, app.tr(key), layer.surface_class == value).clicked() { + layer.surface_class = value; + ui.close(); + } + } + }); + crate::scenario::publish_target("render:aging-class", class.rect); + }); + let title = app.tr("render.aging_target").to_string(); + ui_kit::section(ui, "render_aging_target_section", &title, true, |ui| { + if ui_kit::button(ui, app.tr("render.aging_refresh_targets"), ui_kit::Button::Normal).clicked() { + match materials::read_targets(app) { + Ok(targets) => editor.targets = targets, + Err(error) => app.set_status(error, true), + } + } + let search_label = app.tr("render.aging_target_search").to_string(); + ui_kit::bounded_cell_editor(ui, ui.id().with("aging_target_search"), &mut editor.search, &search_label, false, 128); + let selected = layer.target.as_ref().map_or_else( + || app.tr("render.aging_all_bodies").to_string(), + |identity| { + editor.targets.iter().find(|target| target.stable_target.as_ref() == Some(identity)).map_or_else( + || format!("{}: {}", identity.definition, app.tr("render.material_target_missing")), + |target| target.name.clone(), + ) + }, + ); + ui_kit::row(ui, app.tr("render.wear_applies_to"), |ui| { + let target = ui_kit::dropdown_menu(ui, "render_aging_target", &selected, |ui| { + if ui_kit::list_picker(ui, "aging-target-all", app.tr("render.aging_all_bodies"), layer.target.is_none()).clicked() { + layer.target = None; + ui.close(); + } + let search = editor.search.to_lowercase(); + for target in + editor.targets.iter().filter(|t| !t.name.starts_with("__render_stage__/") && t.name.to_lowercase().contains(&search)).take(64) + { + if ui_kit::list_picker( + ui, + &format!("aging-target-{}", target.ordinal), + &target.name, + layer.target.is_some() && layer.target == target.stable_target, + ) + .clicked() + { + if let Some(identity) = &target.stable_target { + layer.target = Some(identity.clone()); + } else { + app.set_status(app.tr("render.material_target_missing").to_string(), true); + } + ui.close(); + } + } + }); + crate::scenario::publish_target("render:aging-target", target.rect); + }); + studio::vector(ui, app.tr("render.aging_origin"), &mut layer.origin_mm, -1e9..=1e9, 1.0); + note(app, ui, "render.aging_target_help"); + }); + } + if app.render_workspace.view.method == ImageMethod::GpuRaytrace && before != stack { + app.render_workspace.view.studio.aging = stack; + app.render_workspace.view.dirty = true; + } + app.render_workspace.view.inspector.effects = editor; +} diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs index 2d9fac44b..f0fd059f2 100644 --- a/crates/ui-egui/src/render_workspace.rs +++ b/crates/ui-egui/src/render_workspace.rs @@ -58,6 +58,8 @@ mod transport; #[path = "render_workspace_thumbnails.rs"] mod thumbnails; +#[path = "render_ui/wear.rs"] +mod wear; #[cfg(test)] #[path = "render_workspace_tests.rs"] @@ -261,6 +263,7 @@ pub enum RenderSelection { Nothing, Object(Vec), Environment, + Wear, /// Method/type/index identity until named light commands provide persistent IDs. Light(String), Shot(String), @@ -2002,5 +2005,14 @@ pub(crate) fn interactive_command_info(app: &SolveApp, command: &solidcraft_engi info } pub(crate) fn start_interactive(app: &mut SolveApp, id: &str) -> bool { - ribbon::start(app, id) + let handled = ribbon::start(app, id); + // Opening Appearance Advanced must still reach its atmosphere controls after leaving Wear. + if handled + && id == "render.aging.describe" + && app.render_workspace.view.inspector.page == inspector::Page::Appearance + && app.render_workspace.view.selection == RenderSelection::Wear + { + let _ = app.run("view.render_select", json!({"kind":"nothing"})); + } + handled } diff --git a/crates/ui-egui/src/render_workspace_effects.rs b/crates/ui-egui/src/render_workspace_effects.rs index b7838e849..cad8f277a 100644 --- a/crates/ui-egui/src/render_workspace_effects.rs +++ b/crates/ui-egui/src/render_workspace_effects.rs @@ -2,26 +2,23 @@ //! Numerical edits remain one render draft until the ordinary Save action. use super::{ImageMethod, materials, studio}; use crate::{SolveApp, ui_kit}; -use solidcraft_engine::render::job::{ - aging::{AgingKind, AgingLayer, SurfaceClass}, - looks::{LookKind, LookLayer}, -}; +use solidcraft_engine::render::job::looks::{LookKind, LookLayer}; #[derive(Clone, Debug, Default)] pub(super) struct View { pub selected_aging: usize, pub selected_look: usize, - targets: Vec, - search: String, + pub(super) targets: Vec, + pub(super) search: String, } -fn note(app: &SolveApp, ui: &mut egui::Ui, key: &'static str) { +pub(super) fn note(app: &SolveApp, ui: &mut egui::Ui, key: &'static str) { ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key)); } -fn number(app: &SolveApp, ui: &mut egui::Ui, key: &str, value: &mut f64, range: std::ops::RangeInclusive, speed: f64, suffix: &str) { +pub(super) fn number(app: &SolveApp, ui: &mut egui::Ui, key: &str, value: &mut f64, range: std::ops::RangeInclusive, speed: f64, suffix: &str) { let response = ui_kit::row(ui, app.tr(key), |ui| ui_kit::number_field(ui, value, range, speed, suffix)); crate::scenario::publish_target(key, response.rect); } -fn failure(app: &mut SolveApp, result: Result<(), String>) { +pub(super) fn failure(app: &mut SolveApp, result: Result<(), String>) { if let Err(error) = result { app.set_status(error, true); } @@ -33,7 +30,7 @@ fn gpu(app: &SolveApp, ui: &mut egui::Ui) -> bool { } true } -fn layer_actions(app: &SolveApp, ui: &mut egui::Ui, prefix: &str, selected: usize, length: usize) -> (i32, bool) { +pub(super) fn layer_actions(app: &SolveApp, ui: &mut egui::Ui, prefix: &str, selected: usize, length: usize) -> (i32, bool) { let mut movement = 0; let mut remove = false; ui.horizontal_wrapped(|ui| { @@ -55,136 +52,10 @@ fn layer_actions(app: &SolveApp, ui: &mut egui::Ui, prefix: &str, selected: usiz } pub(super) fn aging_controls(app: &mut SolveApp, ui: &mut egui::Ui) { - if !gpu(app, ui) { + super::wear::controls(app, ui); + if app.render_workspace.view.method != ImageMethod::GpuRaytrace { return; } - note(app, ui, "render.aging_help"); - let mut editor = std::mem::take(&mut app.render_workspace.view.inspector.effects); - let before = app.render_workspace.view.studio.aging.clone(); - let mut stack = before.clone(); - let add = ui_kit::dropdown_menu(ui, "render_aging_add", app.tr("render.aging_add"), |ui| { - for kind in AgingKind::ALL { - let id = format!("aging-add-{}", kind.code()); - if ui_kit::list_picker(ui, &id, app.tr(kind.key()), false).clicked() { - match stack.push(AgingLayer::preset(kind)) { - Ok(()) => editor.selected_aging = stack.len() - 1, - Err(error) => app.set_status(error.to_string(), true), - } - ui.close(); - } - } - }); - crate::scenario::publish_target("render:aging-add", add.rect); - if stack.is_empty() { - note(app, ui, "render.aging_empty"); - } - editor.selected_aging = editor.selected_aging.min(stack.len().saturating_sub(1)); - for (index, layer) in stack.iter().enumerate() { - let label = - format!("{} · {}{}", index + 1, app.tr(layer.kind.key()), if layer.enabled { "" } else { crate::i18n::tr("render.layer_off_suffix") }); - let response = ui_kit::list_picker(ui, &format!("aging-layer-{index}"), &label, index == editor.selected_aging); - crate::scenario::publish_target(&format!("render:aging-layer:{index}"), response.rect); - if response.clicked() { - editor.selected_aging = index; - } - } - if !stack.is_empty() { - let (movement, remove) = layer_actions(app, ui, "aging", editor.selected_aging, stack.len()); - if remove { - failure(app, stack.remove(editor.selected_aging).map_err(|e| e.to_string())); - editor.selected_aging = editor.selected_aging.min(stack.len().saturating_sub(1)); - } else if movement != 0 { - let next = if movement < 0 { editor.selected_aging.saturating_sub(1) } else { editor.selected_aging + 1 }; - failure(app, stack.move_layer(editor.selected_aging, next).map_err(|e| e.to_string())); - editor.selected_aging = next; - } - } - if let Some(layer) = stack.get_mut(editor.selected_aging) { - let response = ui_kit::checkbox(ui, app.tr("render.layer_enabled"), &mut layer.enabled); - crate::scenario::publish_target("render:aging-enabled", response.rect); - number(app, ui, "render.layer_strength", &mut layer.strength, 0.0..=1.0, 0.01, ""); - number(app, ui, "render.aging_coverage", &mut layer.coverage, 0.0..=1.0, 0.01, ""); - number(app, ui, "render.aging_scale", &mut layer.scale_mm, 0.01..=100000.0, 0.1, " mm"); - let response = ui_kit::row(ui, app.tr("render.effects_seed"), |ui| ui_kit::number_field(ui, &mut layer.seed, 0..=65535, 1.0, "")); - crate::scenario::publish_target("render:aging-seed", response.rect); - let response = ui_kit::row(ui, app.tr("render.aging_color"), |ui| ui_kit::color_field(ui, &mut layer.color_srgb)); - crate::scenario::publish_target("render:aging-color", response.rect); - number(app, ui, "render.aging_roughness", &mut layer.roughness, 0.02..=1.0, 0.01, ""); - number(app, ui, "render.aging_metallic", &mut layer.metallic, 0.0..=1.0, 0.01, ""); - number(app, ui, "render.aging_upward", &mut layer.upward_bias, 0.0..=1.0, 0.01, ""); - let current = match layer.surface_class { - SurfaceClass::AnyOpaque => "render.aging_class_any", - SurfaceClass::Metal => "render.aging_class_metal", - SurfaceClass::Dielectric => "render.aging_class_dielectric", - }; - let class = ui_kit::dropdown_menu(ui, "render_aging_class", app.tr(current), |ui| { - for (value, key) in [ - (SurfaceClass::AnyOpaque, "render.aging_class_any"), - (SurfaceClass::Metal, "render.aging_class_metal"), - (SurfaceClass::Dielectric, "render.aging_class_dielectric"), - ] { - if ui_kit::list_picker(ui, key, app.tr(key), layer.surface_class == value).clicked() { - layer.surface_class = value; - ui.close(); - } - } - }); - crate::scenario::publish_target("render:aging-class", class.rect); - let title = app.tr("render.aging_target").to_string(); - ui_kit::section(ui, "render_aging_target_section", &title, false, |ui| { - if ui_kit::button(ui, app.tr("render.aging_refresh_targets"), ui_kit::Button::Normal).clicked() { - match materials::read_targets(app) { - Ok(targets) => editor.targets = targets, - Err(error) => app.set_status(error, true), - } - } - let search_label = app.tr("render.aging_target_search").to_string(); - ui_kit::bounded_cell_editor(ui, ui.id().with("aging_target_search"), &mut editor.search, &search_label, false, 128); - let selected = layer.target.as_ref().map_or_else( - || app.tr("render.aging_all_bodies").to_string(), - |identity| { - editor.targets.iter().find(|target| target.stable_target.as_ref() == Some(identity)).map_or_else( - || format!("{}: {}", identity.definition, app.tr("render.material_target_missing")), - |target| target.name.clone(), - ) - }, - ); - let target = ui_kit::dropdown_menu(ui, "render_aging_target", &selected, |ui| { - if ui_kit::list_picker(ui, "aging-target-all", app.tr("render.aging_all_bodies"), layer.target.is_none()).clicked() { - layer.target = None; - ui.close(); - } - let search = editor.search.to_lowercase(); - for target in - editor.targets.iter().filter(|t| !t.name.starts_with("__render_stage__/") && t.name.to_lowercase().contains(&search)).take(64) - { - if ui_kit::list_picker( - ui, - &format!("aging-target-{}", target.ordinal), - &target.name, - layer.target.is_some() && layer.target == target.stable_target, - ) - .clicked() - { - if let Some(identity) = &target.stable_target { - layer.target = Some(identity.clone()); - } else { - app.set_status(app.tr("render.material_target_missing").to_string(), true); - } - ui.close(); - } - } - }); - crate::scenario::publish_target("render:aging-target", target.rect); - studio::vector(ui, app.tr("render.aging_origin"), &mut layer.origin_mm, -1e9..=1e9, 1.0); - note(app, ui, "render.aging_target_help"); - }); - } - if before != stack { - app.render_workspace.view.studio.aging = stack; - app.render_workspace.view.dirty = true; - } - app.render_workspace.view.inspector.effects = editor; let title = app.tr("render.aging_airborne").to_string(); ui_kit::section(ui, "render_aging_atmosphere", &title, false, |ui| { note(app, ui, "render.aging_airborne_help"); diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs index 913825c35..853ab8d34 100644 --- a/crates/ui-egui/src/render_workspace_inspector.rs +++ b/crates/ui-egui/src/render_workspace_inspector.rs @@ -215,11 +215,15 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { let bounds = crate::shell::panel_bounds(app, ui.available_rect_before_wrap()); let mut side = app.preferences.render_inspector_side.clone(); let mut width = app.preferences.render_inspector_width; - let output = app.render_workspace.view.inspector.page == Page::Output || app.render_workspace.view.selection == super::RenderSelection::Output; + let wear = app.render_workspace.view.selection == super::RenderSelection::Wear; + let output = + !wear && (app.render_workspace.view.inspector.page == Page::Output || app.render_workspace.view.selection == super::RenderSelection::Output); let page = if output { Page::Output } else { app.render_workspace.view.inspector.page }; - let appearance_editor = page == Page::Appearance; + let appearance_editor = !wear && page == Page::Appearance; let selection_appearance = appearance_editor && !app.session.selection.is_empty(); - let title = if selection_appearance { + let title = if wear { + app.tr("render.wear_title").to_string() + } else if selection_appearance { app.session .selection .last() @@ -232,7 +236,13 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { } else { app.tr(if output { "render.page_output" } else { "render.studio_title" }).to_string() }; - let icon = if selection_appearance { "body" } else { page.icon() }; + let icon = if wear { + "appearance" + } else if selection_appearance { + "body" + } else { + page.icon() + }; let scope = selection_appearance::scope_label(app).to_owned(); let header_action = std::cell::Cell::new(None); let content = ui_kit::Panel::workspace_with_header( @@ -277,9 +287,14 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { } egui::ScrollArea::vertical() .max_width(ui.available_width()) - .id_salt(("render_inspector", page.handle(), app.docs.active)) + .id_salt(("render_inspector", wear, page.handle(), app.docs.active)) .auto_shrink([false, false]) .show(ui, |ui| { + if wear { + super::wear::controls(app, ui); + setups::refresh_dirty(app); + return; + } if !appearance_editor && !output { ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key())); } diff --git a/crates/ui-egui/src/render_workspace_inspector_tests.rs b/crates/ui-egui/src/render_workspace_inspector_tests.rs index 802b0c533..4bbf02c32 100644 --- a/crates/ui-egui/src/render_workspace_inspector_tests.rs +++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs @@ -36,8 +36,10 @@ fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_foote } if page == Page::Output { assert!(crate::scenario::rect_of("render:job-footer").is_none()); + let bar = crate::scenario::rect_of("render:stage_bar").unwrap(); for name in ["render:stage:render.start", "render:stage:render.cancel"] { - assert!(crate::scenario::rect_of(name).is_some()); + let action = crate::scenario::rect_of(name).unwrap(); + assert!(bar.contains_rect(action), "{name} outside stage bar"); } continue; } @@ -883,6 +885,176 @@ fn aging_tab_adds_reorders_disables_and_persists_layers_without_engineering_edit assert_eq!(h.app.render_workspace.view.studio.aging.len(), 1); } +#[test] +fn wear_selection_precedes_output_page_and_appearance_selection_chrome() { + fn assert_header(h: &Harness, title: &str) { + let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + let header = crate::scenario::rect_of("render:inspector:header").unwrap(); + assert!(inspector.contains_rect(header)); + let tree = h.output.accesskit_update.as_ref().unwrap(); + let context = format!( + "layout={:?}, page={:?}, title={title:?}, header={header:?}, pixels_per_point={}", + h.app.ui.layout, + h.app.render_workspace.view.inspector.page, + h.ctx.pixels_per_point(), + ); + // egui stores Role::Label text in value(), not label(). Each pass supplies the + // title node; its bounds are UI points (the root carries the pixel-scale transform). + let titles: Vec<_> = + tree.nodes.iter().filter(|(_, node)| node.role() == egui::accesskit::Role::Label && node.value() == Some(title)).collect(); + assert!(!titles.is_empty(), "missing inspector title: {context}"); + let bounds: Vec<_> = titles.iter().map(|(id, node)| (id, node.bounds())).collect(); + eprintln!( + "header diagnostic: {context}, bounds={bounds:?}, label_matches={}", + tree.nodes.iter().filter(|(_, node)| node.label() == Some(title)).count() + ); + assert!( + titles.iter().any(|(_, node)| { + node.bounds().is_some_and(|bounds| { + bounds.x1 > bounds.x0 + && bounds.y1 > bounds.y0 + && header.contains_rect(egui::Rect::from_min_max( + egui::pos2(bounds.x0 as f32, bounds.y0 as f32), + egui::pos2(bounds.x1 as f32, bounds.y1 as f32), + )) + }) + }), + "inspector title has missing, empty or out-of-header bounds: {context}, bounds={bounds:?}" + ); + } + for layout in [crate::shell::LayoutMode::Docked, crate::shell::LayoutMode::Floating] { + let mut h = fixture(); + h.app.ui.layout = layout; + h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }]; + let before = h.app.session.doc.to_json(); + let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()); + h.app.run("view.render_select", json!({"kind":"wear"})).unwrap(); + assert!(h.app.session.selection.is_empty(), "Render focus clears object picks"); + let wear_history = (history.0 + 1, history.1, history.2); + assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), wear_history); + // Exercise stale object picks alongside Wear; normal focus commands clear them. + h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }]; + for page in [Page::Output, Page::Appearance] { + h.app.render_workspace.view.inspector.page = page; + h.frames(3); + assert_header(&h, h.app.tr("render.wear_title")); + assert!(crate::scenario::rect_of("render:wear:controls").is_some()); + assert!(crate::scenario::rect_of("render:appearance:close").is_none()); + assert!(crate::scenario::rect_of("dialog:editor_footer").is_none()); + assert!(crate::scenario::rect_of("render:page:aging").is_none()); + let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + let footer = crate::scenario::rect_of("render:job-footer").unwrap(); + assert!(inspector.contains_rect(footer)); + for name in ["render:check", "render:start", "render:cancel", "render:export"] { + assert!(footer.contains_rect(crate::scenario::rect_of(name).unwrap()), "{name} outside Wear footer"); + } + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), wear_history); + } + h.app.run("view.render_select", json!({"kind":"output"})).unwrap(); + assert!(h.app.session.selection.is_empty()); + let output_history = (history.0 + 2, history.1, history.2); + assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), output_history); + h.app.render_workspace.view.inspector.page = Page::Appearance; + h.frames(3); + assert_header(&h, h.app.tr("render.page_output")); + assert!(crate::scenario::rect_of("render:wear:controls").is_none()); + assert!(crate::scenario::rect_of("render:job-footer").is_none()); + assert!(crate::scenario::rect_of("render:appearance:close").is_none()); + h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); + // Select a body again to test recovery of the ordinary Appearance header. + h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }]; + h.frames(3); + assert_header(&h, "Subject"); + let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + let header = crate::scenario::rect_of("render:inspector:header").unwrap(); + assert!(header.contains_rect(crate::scenario::rect_of("render:appearance:close").unwrap())); + assert!(inspector.contains_rect(crate::scenario::rect_of("dialog:editor_footer").unwrap())); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), output_history); + } +} + +#[test] +fn wear_selection_shows_disabled_controls_with_reason_and_never_changes_method() { + use solidcraft_engine::render::job::aging::{AgingKind, AgingLayer}; + fn text_color(shape: &egui::Shape, label: &str) -> Option { + match shape { + egui::Shape::Text(text) if text.galley.text().to_lowercase().contains(&label.to_lowercase()) => Some(text.fallback_color), + egui::Shape::Vec(shapes) => shapes.iter().find_map(|shape| text_color(shape, label)), + _ => None, + } + } + let mut h = fixture(); + h.call("ui.resize", json!({"width":1440,"height":1800})); + h.app.render_workspace.view.studio.aging.push(AgingLayer::preset(AgingKind::Rust)).unwrap(); + h.app.render_workspace.view.dirty = true; + let document = h.app.session.doc.to_json(); + let stack = h.app.render_workspace.view.studio.aging.clone(); + h.app.run("view.render_select", json!({"kind":"wear"})).unwrap(); + let mut colours = Vec::new(); + for method in [ImageMethod::Raster, ImageMethod::CpuRaytrace, ImageMethod::GpuRaytrace] { + h.app.render_workspace.view.method = method; + h.frames(3); + assert_eq!(h.app.render_workspace.view.method, method); + assert!(crate::scenario::rect_of("render:wear:controls").is_some()); + assert!(crate::scenario::rect_of("render:aging-enabled").is_some()); + assert!(crate::scenario::rect_of("render:aging-target").is_some()); + assert!(crate::scenario::rect_of("render:page:aging").is_none(), "Wear has no master page switcher"); + assert!(h.shapes.iter().any(|s| text_color(&s.shape, h.app.tr("render.effects_gpu_only")).is_some())); + colours.push(h.shapes.iter().find_map(|s| text_color(&s.shape, h.app.tr("render.wear_layers"))).unwrap()); + if method != ImageMethod::GpuRaytrace { + for handle in ["render:aging-add", "render:aging-enabled", "render:aging-layer:0:enabled", "render:aging-remove"] { + h.step(&json!({"click":{"handle":handle}})).unwrap(); + assert_eq!(h.app.render_workspace.view.studio.aging, stack); + } + } + assert_eq!(h.app.session.doc.to_json(), document); + } + for colour in &colours[..2] { + assert!(colour.a() < colours[2].a(), "unsupported methods fade the editor"); + } + h.step(&json!({"click":{"handle":"render:aging-layer:0:enabled"}})).unwrap(); + assert!(!h.app.render_workspace.view.studio.aging.get(0).unwrap().enabled); + h.app.start("render.aging.describe"); + h.frames(3); + assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Nothing); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + assert!(crate::scenario::rect_of("render:wear:controls").is_some(), "Appearance Advanced mounts the same editor"); + assert!(h.shapes.iter().any(|s| text_color(&s.shape, h.app.tr("render.aging_airborne")).is_some())); +} + +#[test] +fn wear_editor_bounds_stale_selection_and_hostile_layer_values_never_panic() { + use solidcraft_engine::render::job::aging::{AgingKind, AgingLayer}; + let mut h = fixture(); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + h.app.run("view.render_select", json!({"kind":"wear"})).unwrap(); + h.app.render_workspace.view.inspector.effects.selected_aging = usize::MAX; + h.frames(3); + assert_eq!(h.app.render_workspace.view.inspector.effects.selected_aging, 0); + h.app.render_workspace.view.studio.aging.push(AgingLayer::preset(AgingKind::Dust)).unwrap(); + h.app.render_workspace.view.dirty = true; + for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1e300, 1e300] { + let layer = h.app.render_workspace.view.studio.aging.get_mut(0).unwrap(); + layer.strength = value; + layer.coverage = value; + layer.scale_mm = value; + layer.roughness = value; + layer.metallic = value; + layer.upward_bias = value; + layer.origin_mm = [value; 3]; + layer.seed = u32::MAX; + h.app.render_workspace.view.inspector.effects.selected_aging = usize::MAX; + h.frames(3); + assert_eq!(h.app.render_workspace.view.inspector.effects.selected_aging, 0); + } + h.step(&json!({"click":{"handle":"render:aging-remove"}})).unwrap(); + assert!(h.app.render_workspace.view.studio.aging.is_empty()); + h.frames(3); + assert!(crate::scenario::rect_of("render:aging-enabled").is_none()); +} + #[test] fn output_effects_retains_ordered_looks_and_photographic_intent_across_save_and_reload() { use solidcraft_engine::render::job::looks::LookKind; diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs index df0adc024..682f16d52 100644 --- a/crates/ui-egui/src/render_workspace_tests.rs +++ b/crates/ui-egui/src/render_workspace_tests.rs @@ -4643,6 +4643,47 @@ fn render_workspace_browser_focus_is_per_document_and_invalid_selection_is_atomi assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Output); } +#[test] +fn render_workspace_wear_tree_selects_the_scene_stack_and_counts_layers_in_both_lenses() { + use solidcraft_engine::render::job::aging::{AgingKind, AgingLayer}; + fn has_text(shape: &egui::Shape, needle: &str) -> bool { + match shape { + egui::Shape::Text(text) => text.galley.text().contains(needle), + egui::Shape::Vec(shapes) => shapes.iter().any(|shape| has_text(shape, needle)), + _ => false, + } + } + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1400})); + h.app.run("solid.box", json!({"length":20,"width":15,"height":10,"body_name":"Subject"})).unwrap(); + enter(&mut h.app, true).unwrap(); + h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: "Subject".into() }]})).unwrap(); + let document = h.app.session.doc.clone(); + assert_eq!(scene::wear_subtitle(&h.app), h.app.tr("render.wear_no_layers")); + h.frames(3); + assert!(h.shapes.iter().any(|s| has_text(&s.shape, h.app.tr("render.wear_no_layers")))); + h.step(&json!({"click":{"handle":"render:tree:wear"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Wear); + assert!(h.app.session.selection.is_empty()); + assert!(crate::scenario::rect_of("render:wear:controls").is_some()); + assert!(!crate::icon_svg::resolve("appearance").placeholder); + for count in 1..=2 { + h.app.render_workspace.view.studio.aging.push(AgingLayer::preset(AgingKind::Dust)).unwrap(); + h.app.render_workspace.view.dirty = true; + let label = + crate::i18n::format(if count == 1 { "render.wear_layer_one" } else { "render.wear_layer_count" }, &[("count", &count.to_string())]); + assert_eq!(scene::wear_subtitle(&h.app), label); + for by_look in [false, true] { + h.app.run("view.render_browser", json!({"by_look":by_look})).unwrap(); + h.frames(3); + assert!(crate::scenario::rect_of("render:tree:wear").is_some()); + assert!(h.shapes.iter().any(|s| has_text(&s.shape, &label))); + } + } + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert!(h.app.dialog.is_none() && h.app.tool.is_none()); +} + /// Actual application tree at the approved card width, in both themes and both task states. #[test] fn render_workspace_browser_compact_geometry_search_and_theme_evidence() {