SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Render wear: a Wear row and editor for the aging layers (#6281) (#7459)
Nathan Dane40ff251e5fbc
diff --git a/assets/locales/pending/render-wear.json b/assets/locales/pending/render-wear.jsonnew file mode 100644index 0000000000..cfc22c72ff--- /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.mdnew file mode 100644index 0000000000..8d0f72642b--- /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.rsindex 3a8fb5643a..1904773df6 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::<crate::schema::view_navigation::RenderSelect>).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<Value> {Ok(json!(request))}+const RENDER_SELECT_CONTRACT: crate::schema::TypedContract<crate::schema::view_navigation::RenderSelect> = crate::schema::TypedContract::new();+fn render_select(s: &mut Session, p: &Value) -> Result<Value> {- #[derive(serde::Deserialize, serde::Serialize)]- #[serde(deny_unknown_fields)]- struct Request {- kind: String,- #[serde(skip_serializing_if = "Option::is_none")]- id: Option<String>,- }- 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::<Vec<_>>(), ["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.rsindex 7bdae0b296..7d1554bccc 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<String>,}+/// 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<String>,+}++impl<'de> Deserialize<'de> for RenderSelect {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ #[derive(Deserialize)]+ #[serde(deny_unknown_fields)]+ struct Request {+ kind: String,+ id: Option<String>,+ }+ 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.rsindex 57b66799e4..c4947813c2 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.rsindex 0fcae1ce8a..e2778a5632 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<LookGroup> {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<String>, 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: &mutif !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.rsnew file mode 100644index 0000000000..90f5c55c3f--- /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.rsindex 2d9fac44b1..f0fd059f2d 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<solidcraft_engine::Sel>),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_engiinfo}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.rsindex b7838e849a..cad8f277a6 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<materials::Target>,- search: String,+ pub(super) targets: Vec<materials::Target>,+ 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<f64>, speed: f64, suffix: &str) {+pub(super) fn number(app: &SolveApp, ui: &mut egui::Ui, key: &str, value: &mut f64, range: std::ops::RangeInclusive<f64>, 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.rsindex 913825c358..853ab8d340 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.rsindex 802b0c533e..4bbf02c32d 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_editassert_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<egui::Color32> {+ 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.rsindex df0adc0246..682f16d522 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_atomiassert_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() {