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
This commit is contained in:
Nathan Dane authored and GitHub committed 2026-10-29 03:29:10 +00:00
1 parent 081c4bca73
commit 40ff251e5f
12 files changed
+634 -164

No files matched your search

+74
View File
@@ -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"
}
}
+1
View File
@@ -0,0 +1 @@
| assets/locales/pending/render-wear.json | SolidCraft contributors | Original UI labels and translations | MIT OR Apache-2.0 |
+36 -17
View File
@@ -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() {
+62 -2
View File
@@ -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;
+1
View File
@@ -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()),
+33
View File
@@ -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;
}
+171
View File
@@ -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;
}
+13 -1
View File
@@ -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
}
+9 -138
View File
@@ -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");
@@ -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()));
}
@@ -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;
@@ -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() {