Skip to content

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.json
new file mode 100644
index 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.md
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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: &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 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.rs
index 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_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 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.rs
index 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.rs
index 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_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<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.rs
index 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_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() {